diff --git a/src/device/service/drivers/openconfig/templates/Interfaces.py b/src/device/service/drivers/openconfig/templates/Interfaces.py index 3d4c73fc11c686b4d4e181a1f98ed3f5922f7c15..51ee9fc66334a30a450144b4b8079575498aeef9 100644 --- a/src/device/service/drivers/openconfig/templates/Interfaces.py +++ b/src/device/service/drivers/openconfig/templates/Interfaces.py @@ -31,10 +31,6 @@ def parse(xml_data : ET.Element) -> List[Tuple[str, Dict[str, Any]]]: interface = {} - interface_name = xml_interface.find('oci:name', namespaces=NAMESPACES) - if interface_name is None or interface_name.text is None: continue - add_value_from_tag(interface, 'name', interface_name) - #interface_type = xml_interface.find('oci:config/oci:type', namespaces=NAMESPACES) #add_value_from_tag(interface, 'type', interface_type) @@ -42,8 +38,11 @@ def parse(xml_data : ET.Element) -> List[Tuple[str, Dict[str, Any]]]: interface_type = xml_interface.find('oci:config/oci:type', namespaces=NAMESPACES) elif xml_interface.find('oci:state/oci:type', namespaces=NAMESPACES) is not None: interface_type = xml_interface.find('oci:state/oci:type', namespaces=NAMESPACES) - else: - interface_type = '' + else: continue + + interface_name = xml_interface.find('oci:name', namespaces=NAMESPACES) + if interface_name is None or interface_name.text is None: continue + add_value_from_tag(interface, 'name', interface_name) # Get the type of interface according to the vendor's type if 'ianaift:' in interface_type.text: diff --git a/src/device/service/drivers/openconfig/templates/Inventory.py b/src/device/service/drivers/openconfig/templates/Inventory.py index 2ae67ba47dad162b8c8e4a15d3004b27359d4ca2..916af0478c51d381d670b7678095867537f3bdc9 100644 --- a/src/device/service/drivers/openconfig/templates/Inventory.py +++ b/src/device/service/drivers/openconfig/templates/Inventory.py @@ -54,7 +54,6 @@ XPATH_PORTS = "//ocp:components/ocp:component" def parse(xml_data : ET.Element) -> List[Tuple[str, Dict[str, Any]]]: response = [] - LOGGER.debug("InventoryPrueba") parent_types = {} for xml_component in xml_data.xpath(XPATH_PORTS, namespaces=NAMESPACES): LOGGER.info('xml_component inventario = {:s}'.format(str(ET.tostring(xml_component)))) @@ -78,9 +77,9 @@ def parse(xml_data : ET.Element) -> List[Tuple[str, Dict[str, Any]]]: add_value_from_tag(inventory['attributes'], 'location', component_location) component_type = xml_component.find('ocp:state/ocp:type', namespaces=NAMESPACES) - component_type.text = component_type.text.replace('oc-platform-types:','') - if component_type is None: continue - add_value_from_tag(inventory, 'class', component_type) + if component_type is not None: + component_type.text = component_type.text.replace('oc-platform-types:','') + add_value_from_tag(inventory, 'class', component_type) if inventory['class'] == 'CPU' or inventory['class'] == 'STORAGE': continue diff --git a/src/device/service/drivers/openconfig/templates/RoutingPolicy.py b/src/device/service/drivers/openconfig/templates/RoutingPolicy.py index acafa021824f94f929e849117824e8120974d0b1..96dc1c5a49d0007f4b0a28b10c2f35868a18a71f 100644 --- a/src/device/service/drivers/openconfig/templates/RoutingPolicy.py +++ b/src/device/service/drivers/openconfig/templates/RoutingPolicy.py @@ -35,7 +35,7 @@ def parse(xml_data : ET.Element) -> List[Tuple[str, Dict[str, Any]]]: #LOGGER.info('xml_policy_definition = {:s}'.format(str(ET.tostring(xml_policy_definition)))) policy_definition = {} - + statement_name = '' policy_name = xml_policy_definition.find('ocrp:name', namespaces=NAMESPACES) if policy_name is None or policy_name.text is None: continue add_value_from_tag(policy_definition, 'policy_name', policy_name) diff --git a/src/device/tests/test_unitary_ietf_actn.py b/src/device/tests/test_unitary_ietf_actn.py index 5f01a412d88bca142d2bd96ce238947844bc9087..011b3ddbc54d9b68ec6c95cc6b0816385ad93eff 100644 --- a/src/device/tests/test_unitary_ietf_actn.py +++ b/src/device/tests/test_unitary_ietf_actn.py @@ -151,6 +151,11 @@ def test_device_ietf_actn_configure( retrieved_driver_config_rules = sorted(driver.GetConfig(), key=operator.itemgetter(0)) LOGGER.info('driver_config = {:s}'.format(str(retrieved_driver_config_rules))) assert isinstance(retrieved_driver_config_rules, list) + retrieved_driver_config_rules = [ + (resource_key, resource_value) + for resource_key, resource_value in retrieved_driver_config_rules + if resource_key != '/endpoints/endpoint[mgmt]' + ] if len(retrieved_driver_config_rules) > 0: LOGGER.error('PRE DRIVER CONFIG RULES - Differences:\n{:s}'.format(str(retrieved_driver_config_rules))) assert len(retrieved_driver_config_rules) == 0 @@ -186,6 +191,7 @@ def test_device_ietf_actn_configure( retrieved_driver_config_rules = [ {'action': 1, 'custom': {'resource_key': resource_key, 'resource_value': resource_value}} for resource_key, resource_value in retrieved_driver_config_rules + if resource_key != '/endpoints/endpoint[mgmt]' ] with open(DATA_FILE_CONFIG_RULES, 'r', encoding='UTF-8') as f: expected_driver_config_rules = sorted(json.load(f), key=lambda cr: cr['custom']['resource_key']) @@ -231,6 +237,7 @@ def test_device_ietf_actn_deconfigure( retrieved_driver_config_rules = [ {'action': 1, 'custom': {'resource_key': resource_key, 'resource_value': resource_value}} for resource_key, resource_value in retrieved_driver_config_rules + if resource_key != '/endpoints/endpoint[mgmt]' ] with open(DATA_FILE_CONFIG_RULES, 'r', encoding='UTF-8') as f: expected_driver_config_rules = sorted(json.load(f), key=lambda cr: cr['custom']['resource_key']) @@ -266,6 +273,11 @@ def test_device_ietf_actn_deconfigure( retrieved_driver_config_rules = sorted(driver.GetConfig(), key=operator.itemgetter(0)) LOGGER.info('retrieved_driver_config_rules = {:s}'.format(str(retrieved_driver_config_rules))) assert isinstance(retrieved_driver_config_rules, list) + retrieved_driver_config_rules = [ + (resource_key, resource_value) + for resource_key, resource_value in retrieved_driver_config_rules + if resource_key != '/endpoints/endpoint[mgmt]' + ] if len(retrieved_driver_config_rules) > 0: LOGGER.error('POST DRIVER CONFIG RULES - Differences:\n{:s}'.format(str(retrieved_driver_config_rules))) assert len(retrieved_driver_config_rules) == 0 diff --git a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py index 47be3ee5622d882279a0ca7d295bfdfd7d302081..22f01031c3d994d859314f83fae56379c2a4cba3 100644 --- a/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py +++ b/src/nbi/service/rest_server/nbi_plugins/ietf_l3vpn/L3VPN_Services.py @@ -11,9 +11,8 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - -import logging -import json + +import json, logging from typing import Dict, List from flask import request @@ -50,6 +49,35 @@ class L3VPN_Services(Resource): # LOGGER.debug('Request: {:s}'.format(str(request_data))) LOGGER.debug('Request: {:s}'.format(str(jsonAValidarDict))) + errors = list() + if 'ietf-l3vpn-svc:l3vpn-services' in request_data: + # processing multiple L3VPN service requests formatted as: + #{ + # "ietf-l3vpn-svc:l3vpn-services": { + # "l3vpn-svc": [ + # { + # "service-id": "vpn1", + # "vpn-services": { + # "vpn-service": [ + for l3vpn_svc in request_data['ietf-l3vpn-svc:l3vpn-services']['l3vpn-svc']: + l3vpn_svc.pop('service-id', None) + l3vpn_svc_request_data = {'ietf-l3vpn-svc:l3vpn-svc': l3vpn_svc} + errors.extend(self._process_l3vpn(l3vpn_svc_request_data)) + elif 'ietf-l3vpn-svc:l3vpn-svc' in request_data: + # processing single (standard) L3VPN service request formatted as: + #{ + # "ietf-l3vpn-svc:l3vpn-svc": { + # "vpn-services": { + # "vpn-service": [ + errors.extend(self._process_l3vpn(request_data)) + else: + errors.append('unexpected request: {:s}'.format(str(request_data))) + + response = jsonify(errors) + response.status_code = HTTP_CREATED if len(errors) == 0 else HTTP_SERVERERROR + return response + + def _process_l3vpn(self, request_data : Dict) -> List[Dict]: yang_validator = YangValidator('ietf-l3vpn-svc') request_data = yang_validator.parse_to_dict(jsonAValidarDict) yang_validator.destroy() @@ -88,7 +116,7 @@ class L3VPN_Services(Resource): ###### - # errors = [] + errors = [] # for vpn_service in request_data['l3vpn-svc']['vpn-services']['vpn-service']: # process_vpn_service(vpn_service, errors) @@ -99,4 +127,5 @@ class L3VPN_Services(Resource): # response = jsonify(errors) # response.status_code = HTTP_CREATED if len(errors) == 0 else HTTP_SERVERERROR # return response - \ No newline at end of file + + return errors diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java b/src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java index b5f1d85eb4d55668e16c0bdf32212e6ef559b8c9..c94aa37a92bdc5f7d0ad8f47e3b7a7c97e20f313 100644 --- a/src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java +++ b/src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java @@ -16,6 +16,8 @@ package org.etsi.tfs.policy; +import static org.etsi.tfs.policy.common.ApplicationProperties.*; + import io.smallrye.mutiny.Multi; import io.smallrye.mutiny.Uni; import io.smallrye.mutiny.groups.UniJoin; @@ -38,6 +40,7 @@ import org.etsi.tfs.policy.context.model.Constraint; import org.etsi.tfs.policy.context.model.ConstraintCustom; import org.etsi.tfs.policy.context.model.ConstraintTypeCustom; import org.etsi.tfs.policy.context.model.ServiceConfig; +import org.etsi.tfs.policy.context.model.ServiceId; import org.etsi.tfs.policy.device.DeviceService; import org.etsi.tfs.policy.model.BooleanOperator; import org.etsi.tfs.policy.model.PolicyRule; @@ -64,8 +67,7 @@ import org.jboss.logging.Logger; public class PolicyServiceImpl implements PolicyService { private static final Logger LOGGER = Logger.getLogger(PolicyServiceImpl.class); - private static final String INVALID_MESSAGE = "%s is invalid."; - private static final String VALID_MESSAGE = "%s is valid."; + private static final int POLICY_EVALUATION_TIMEOUT = 5; private static final int ACCEPTABLE_NUMBER_OF_ALARMS = 3; private static final int MONITORING_WINDOW_IN_SECONDS = 5; @@ -74,39 +76,6 @@ public class PolicyServiceImpl implements PolicyService { // Temporary solution for not calling the same rpc more than it's needed private static int noAlarms = 0; - private static final PolicyRuleState INSERTED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_INSERTED, "Successfully entered to INSERTED state"); - private static final PolicyRuleState VALIDATED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_VALIDATED, "Successfully transitioned to VALIDATED state"); - private static final PolicyRuleState PROVISIONED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_PROVISIONED, - "Successfully transitioned from VALIDATED to PROVISIONED state"); - private static final PolicyRuleState ACTIVE_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_ACTIVE, - "Successfully transitioned from PROVISIONED to ACTIVE state"); - private static final PolicyRuleState ENFORCED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_ENFORCED, - "Successfully transitioned from ACTIVE to ENFORCED state"); - private static final PolicyRuleState INEFFECTIVE_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_INEFFECTIVE, - "Transitioned from ENFORCED to INEFFECTIVE state"); - private static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_EFFECTIVE, - "Successfully transitioned from ENFORCED to EFFECTIVE state"); - private static final PolicyRuleState UPDATED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_UPDATED, "Successfully entered to UPDATED state"); - private static final PolicyRuleState REMOVED_POLICYRULE_STATE = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_REMOVED, "Successfully entered to REMOVED state"); - private final ContextService contextService; private final MonitoringService monitoringService; private final ServiceService serviceService; @@ -176,81 +145,122 @@ public class PolicyServiceImpl implements PolicyService { return isServiceValid .onItem() .transform( - isService -> { - if (!isService) { - var policyRuleState = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_FAILED, - String.format(INVALID_MESSAGE, serviceId)); - - return policyRuleState; - } + isService -> + constructPolicyStateBasedOnCriteria( + isService, serviceId, policyRuleService, policyRuleBasic)); + } - final var policyRuleTypeService = new PolicyRuleTypeService(policyRuleService); - final var policyRule = new PolicyRule(policyRuleTypeService); - final var alarmDescriptorList = createAlarmDescriptorList(policyRule); - - if (alarmDescriptorList.isEmpty()) { - var policyRuleState = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_FAILED, - String.format( - "Invalid PolicyRuleConditions in PolicyRule with ID: %s", - policyRuleBasic.getPolicyRuleId())); - return policyRuleState; - } else { - contextService - .setPolicyRule(policyRule) - .subscribe() - .with( - policyId -> { - setPolicyRuleServiceToContext( - policyRuleService, VALIDATED_POLICYRULE_STATE); - noAlarms = 0; - - // Create an alarmIds list that contains the promised ids returned from - // setKpiAlarm - List<Uni<String>> alarmIds = new ArrayList<Uni<String>>(); - for (AlarmDescriptor alarmDescriptor : alarmDescriptorList) { - LOGGER.infof("alarmDescriptor:"); - LOGGER.infof(alarmDescriptor.toString()); - alarmIds.add(monitoringService.setKpiAlarm(alarmDescriptor)); - } - // Transform the alarmIds into promised alarms returned from the - // getAlarmResponseStream - List<Multi<AlarmResponse>> alarmResponseStreamList = new ArrayList<>(); - for (Uni<String> alarmId : alarmIds) { - alarmResponseStreamList.add( - alarmId - .onItem() - .transformToMulti( - id -> { - alarmPolicyRuleServiceMap.put(id, policyRuleService); - - // TODO: Create infinite subscription - var alarmSubscription = - new AlarmSubscription(id, 259200, 5000); - return monitoringService.getAlarmResponseStream( - alarmSubscription); - })); - } - - // Merge the promised alarms into one stream (Multi Object) - final var multi = - Multi.createBy().merging().streams(alarmResponseStreamList); - setPolicyRuleServiceToContext( - policyRuleService, PROVISIONED_POLICYRULE_STATE); - - subscriptionList.put(policyId, monitorAlarmResponseForService(multi)); - - // TODO: Resubscribe to the stream, if it has ended - - // TODO: Redesign evaluation of action - // evaluateAction(policyRule, alarmDescriptorList, multi); - }); - return VALIDATED_POLICYRULE_STATE; - } - }); + private PolicyRuleState constructPolicyStateBasedOnCriteria( + Boolean isService, + ServiceId serviceId, + PolicyRuleService policyRuleService, + PolicyRuleBasic policyRuleBasic) { + + if (!isService) { + var policyRuleState = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, String.format(INVALID_MESSAGE, serviceId)); + + return policyRuleState; + } + + final var policyRuleTypeService = new PolicyRuleTypeService(policyRuleService); + final var policyRule = new PolicyRule(policyRuleTypeService); + final var alarmDescriptorList = createAlarmDescriptorList(policyRule); + + if (alarmDescriptorList.isEmpty()) { + var policyRuleState = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, + String.format( + "Invalid PolicyRuleConditions in PolicyRule with ID: %s", + policyRuleBasic.getPolicyRuleId())); + return policyRuleState; + } + + return setPolicyRuleOnContextAndReturnState(policyRule, policyRuleService, alarmDescriptorList); + } + + private PolicyRuleState setPolicyRuleOnContextAndReturnState( + PolicyRule policyRule, + PolicyRuleService policyRuleService, + List<AlarmDescriptor> alarmDescriptorList) { + contextService + .setPolicyRule(policyRule) + .subscribe() + .with( + policyId -> + startMonitoringBasedOnAlarmDescriptors( + policyId, policyRuleService, alarmDescriptorList)); + return VALIDATED_POLICYRULE_STATE; + } + + private void startMonitoringBasedOnAlarmDescriptors( + String policyId, + PolicyRuleService policyRuleService, + List<AlarmDescriptor> alarmDescriptorList) { + setPolicyRuleServiceToContext(policyRuleService, VALIDATED_POLICYRULE_STATE); + noAlarms = 0; + + List<Uni<String>> alarmIds = + createAlarmList(alarmDescriptorList); // setAllarmtomonitoring get back alarmid + + List<Multi<AlarmResponse>> alarmResponseStreamList = + transformAlarmIds(alarmIds, policyRuleService); + + // Merge the promised alarms into one stream (Multi Object) + final var multi = Multi.createBy().merging().streams(alarmResponseStreamList); + setPolicyRuleServiceToContext(policyRuleService, PROVISIONED_POLICYRULE_STATE); + + subscriptionList.put(policyId, monitorAlarmResponseForService(multi)); + + // TODO: Resubscribe to the stream, if it has ended + + // TODO: Redesign evaluation of action + // evaluateAction(policyRule, alarmDescriptorList, multi); + } + + /** + * Transform the alarmIds into promised alarms returned from the getAlarmResponseStream + * + * @param alarmIds the list of alarm ids + * @param policyRuleService the policy rule service + * @return + */ + private List<Multi<AlarmResponse>> transformAlarmIds( + List<Uni<String>> alarmIds, PolicyRuleService policyRuleService) { + List<Multi<AlarmResponse>> alarmResponseStreamList = new ArrayList<>(); + for (Uni<String> alarmId : alarmIds) { + Multi<AlarmResponse> alarmResponseStream = + alarmId.onItem().transformToMulti(id -> setPolicyMonitor(policyRuleService, id)); + + alarmResponseStreamList.add(alarmResponseStream); + } + return alarmResponseStreamList; + } + + private Multi<AlarmResponse> setPolicyMonitor(PolicyRuleService policyRuleService, String id) { + alarmPolicyRuleServiceMap.put(id, policyRuleService); + + // TODO: Create infinite subscription + var alarmSubscription = new AlarmSubscription(id, 259200, 5000); + return monitoringService.getAlarmResponseStream(alarmSubscription); + } + + /** + * Create an alarmIds list that contains the promised ids returned from setKpiAlarm + * + * @param alarmDescriptorList the list of alarm descriptors + * @return the list of alarm descriptors + */ + public List<Uni<String>> createAlarmList(List<AlarmDescriptor> alarmDescriptorList) { + List<Uni<String>> alarmIds = new ArrayList<Uni<String>>(); + for (AlarmDescriptor alarmDescriptor : alarmDescriptorList) { + LOGGER.infof("alarmDescriptor:"); + LOGGER.infof(alarmDescriptor.toString()); + alarmIds.add(monitoringService.setKpiAlarm(alarmDescriptor)); + } + return alarmIds; } @Override @@ -280,74 +290,102 @@ public class PolicyServiceImpl implements PolicyService { return areDevicesValid .onItem() - .transform( - areDevices -> { - if (areDevices.contains(false)) { - var policyRuleState = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_FAILED, - String.format( - INVALID_MESSAGE, - policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId())); - - return policyRuleState; - } + .transform(areDevices -> areDeviceOnContext(areDevices, policyRuleDevice, policyRuleBasic)); + } - final var policyRuleTypeDevice = new PolicyRuleTypeDevice(policyRuleDevice); - final var policyRule = new PolicyRule(policyRuleTypeDevice); - - final var alarmDescriptorList = createAlarmDescriptorList(policyRule); - if (alarmDescriptorList.isEmpty()) { - var policyRuleState = - new PolicyRuleState( - PolicyRuleStateEnum.POLICY_FAILED, - String.format( - "Invalid PolicyRuleConditions in PolicyRule with ID: %s", - policyRuleBasic.getPolicyRuleId())); - return policyRuleState; - } + private PolicyRuleState areDeviceOnContext( + List<Boolean> areDevices, + PolicyRuleDevice policyRuleDevice, + PolicyRuleBasic policyRuleBasic) { + if (areDevices.contains(false)) { + var policyRuleState = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, + String.format( + INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId())); - contextService.setPolicyRule(policyRule).subscribe().with(x -> {}); - setPolicyRuleDeviceToContext(policyRuleDevice, VALIDATED_POLICYRULE_STATE); - noAlarms = 0; + return policyRuleState; + } - List<Uni<String>> alarmIds = new ArrayList<Uni<String>>(); - for (AlarmDescriptor alarmDescriptor : alarmDescriptorList) { - LOGGER.infof("alarmDescriptor:"); - LOGGER.infof(alarmDescriptor.toString()); - alarmIds.add(monitoringService.setKpiAlarm(alarmDescriptor)); - } + final var policyRuleTypeDevice = new PolicyRuleTypeDevice(policyRuleDevice); + final var policyRule = new PolicyRule(policyRuleTypeDevice); - // Transform the alarmIds into promised alarms returned from the - // getAlarmResponseStream - List<Multi<AlarmResponse>> alarmResponseStreamList = new ArrayList<>(); - for (Uni<String> alarmId : alarmIds) { - alarmResponseStreamList.add( - alarmId - .onItem() - .transformToMulti( - id -> { - alarmPolicyRuleDeviceMap.put(id, policyRuleDevice); - - // TODO: Create infinite subscription - var alarmSubscription = new AlarmSubscription(id, 259200, 5000); - return monitoringService.getAlarmResponseStream(alarmSubscription); - })); - } + final var alarmDescriptorList = createAlarmDescriptorList(policyRule); + if (alarmDescriptorList.isEmpty()) { + var policyRuleState = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, + String.format( + "Invalid PolicyRuleConditions in PolicyRule with ID: %s", + policyRuleBasic.getPolicyRuleId())); + return policyRuleState; + } - // Merge the promised alarms into one stream (Multi Object) - final var multi = Multi.createBy().merging().streams(alarmResponseStreamList); - setPolicyRuleDeviceToContext(policyRuleDevice, PROVISIONED_POLICYRULE_STATE); + contextService + .setPolicyRule(policyRule) + .subscribe() + .with( + policyId -> { + startMonitoringBasedOnAlarmDescriptors( + policyId, policyRuleDevice, alarmDescriptorList); + }); - monitorAlarmResponseForDevice(multi); + return VALIDATED_POLICYRULE_STATE; + } - // TODO: Resubscribe to the stream, if it has ended + private void startMonitoringBasedOnAlarmDescriptors( + String policyId, + PolicyRuleDevice policyRuleDevice, + List<AlarmDescriptor> alarmDescriptorList) { + setPolicyRuleDeviceToContext(policyRuleDevice, VALIDATED_POLICYRULE_STATE); + noAlarms = 0; - // TODO: Redesign evaluation of action - // evaluateAction(policyRule, alarmDescriptorList, multi); + List<Uni<String>> alarmIds = getAlarmIds(alarmDescriptorList); - return VALIDATED_POLICYRULE_STATE; - }); + List<Multi<AlarmResponse>> alarmResponseStreamList = + getAlarmResponse(alarmIds, policyRuleDevice); + + // Merge the promised alarms into one stream (Multi Object) + final var multi = Multi.createBy().merging().streams(alarmResponseStreamList); + setPolicyRuleDeviceToContext(policyRuleDevice, PROVISIONED_POLICYRULE_STATE); + + subscriptionList.put(policyId, monitorAlarmResponseForDevice(multi)); + + // TODO: Resubscribe to the stream, if it has ended + + // TODO: Redesign evaluation of action + // evaluateAction(policyRule, alarmDescriptorList, multi); + } + + private List<Multi<AlarmResponse>> getAlarmResponse( + List<Uni<String>> alarmIds, PolicyRuleDevice policyRuleDevice) { + // Transform the alarmIds into promised alarms returned from the + // getAlarmResponseStream + List<Multi<AlarmResponse>> alarmResponseStreamList = new ArrayList<>(); + for (Uni<String> alarmId : alarmIds) { + alarmResponseStreamList.add( + alarmId.onItem().transformToMulti(id -> setPolicyMonitoringDevice(policyRuleDevice, id))); + } + return alarmResponseStreamList; + } + + private Multi<AlarmResponse> setPolicyMonitoringDevice( + PolicyRuleDevice policyRuleDevice, String id) { + alarmPolicyRuleDeviceMap.put(id, policyRuleDevice); + + // TODO: Create infinite subscription + var alarmSubscription = new AlarmSubscription(id, 259200, 5000); + return monitoringService.getAlarmResponseStream(alarmSubscription); + } + + private List<Uni<String>> getAlarmIds(List<AlarmDescriptor> alarmDescriptorList) { + List<Uni<String>> alarmIds = new ArrayList<Uni<String>>(); + for (AlarmDescriptor alarmDescriptor : alarmDescriptorList) { + LOGGER.infof("alarmDescriptor:"); + LOGGER.infof(alarmDescriptor.toString()); + alarmIds.add(monitoringService.setKpiAlarm(alarmDescriptor)); + } + return alarmIds; } @Override @@ -435,32 +473,32 @@ public class PolicyServiceImpl implements PolicyService { final var getPolicyRule = contextService.getPolicyRule(policyRuleId); - return getPolicyRule - .onItem() - .transform( - policyRule -> { - var policyRuleBasic = policyRule.getPolicyRuleType().getPolicyRuleBasic(); - String policyId = policyRuleBasic.getPolicyRuleId(); + return getPolicyRule.onItem().transform(policyRule -> removePolicyFromContext(policyRule)); + } - policyRule - .getPolicyRuleType() - .getPolicyRuleBasic() - .setPolicyRuleState(REMOVED_POLICYRULE_STATE); + private PolicyRuleState removePolicyFromContext(PolicyRule policyRule) { + var policyRuleBasic = policyRule.getPolicyRuleType().getPolicyRuleBasic(); + String policyId = policyRuleBasic.getPolicyRuleId(); - contextService - .setPolicyRule(policyRule) - .subscribe() - .with( - tmp -> - LOGGER.infof( - "DeletePolicy with id: " + VALID_MESSAGE, - policyRuleBasic.getPolicyRuleId())); + policyRule + .getPolicyRuleType() + .getPolicyRuleBasic() + .setPolicyRuleState(REMOVED_POLICYRULE_STATE); + + contextService + .setPolicyRule(policyRule) + .subscribe() + .with( + tmp -> + LOGGER.infof( + "DeletePolicy with id: " + VALID_MESSAGE, policyRuleBasic.getPolicyRuleId())); - contextService.removePolicyRule(policyId).subscribe().with(x -> {}); - subscriptionList.get(policyId).cancel(); + contextService.removePolicyRule(policyId).subscribe().with(x -> {}); - return policyRuleBasic.getPolicyRuleState(); - }); + // TODO: When the Map doesn't contains the policyId we should throw an exception? + if (subscriptionList.contains(policyId)) subscriptionList.get(policyId).cancel(); + + return policyRuleBasic.getPolicyRuleState(); } private Uni<List<Boolean>> returnInvalidDeviceIds(List<String> deviceIds) { @@ -514,8 +552,8 @@ public class PolicyServiceImpl implements PolicyService { }); } - private void monitorAlarmResponseForDevice(Multi<AlarmResponse> multi) { - multi + private Cancellable monitorAlarmResponseForDevice(Multi<AlarmResponse> multi) { + return multi .subscribe() .with( alarmResponse -> { diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java b/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java new file mode 100644 index 0000000000000000000000000000000000000000..f01fcd9cca39350bf103fd1e2fe894334c4a3b80 --- /dev/null +++ b/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java @@ -0,0 +1,59 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy.common; + +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; + +public class ApplicationProperties { + + public static final String INVALID_MESSAGE = "%s is invalid."; + public static final String VALID_MESSAGE = "%s is valid."; + + public static final PolicyRuleState INSERTED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_INSERTED, "Successfully entered to INSERTED state"); + public static final PolicyRuleState VALIDATED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_VALIDATED, "Successfully transitioned to VALIDATED state"); + public static final PolicyRuleState PROVISIONED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_PROVISIONED, + "Successfully transitioned from VALIDATED to PROVISIONED state"); + public static final PolicyRuleState ACTIVE_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_ACTIVE, + "Successfully transitioned from PROVISIONED to ACTIVE state"); + public static final PolicyRuleState ENFORCED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_ENFORCED, + "Successfully transitioned from ACTIVE to ENFORCED state"); + public static final PolicyRuleState INEFFECTIVE_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_INEFFECTIVE, + "Transitioned from ENFORCED to INEFFECTIVE state"); + public static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_EFFECTIVE, + "Successfully transitioned from ENFORCED to EFFECTIVE state"); + public static final PolicyRuleState UPDATED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_UPDATED, "Successfully entered to UPDATED state"); + public static final PolicyRuleState REMOVED_POLICYRULE_STATE = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_REMOVED, "Successfully entered to REMOVED state"); +} diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java index ea00ea3fc2a2fc8492ef60a860df4e9baf220bfe..7df894abd91f23005e95a5cda8d5df6d196c61f0 100644 --- a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java +++ b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java @@ -64,7 +64,7 @@ public class PolicyRuleBasic { this.booleanOperator = BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_UNDEFINED; this.policyRuleActions = new ArrayList<PolicyRuleAction>(); this.isValid = false; - this.exceptionMessage = e.toString(); + this.exceptionMessage = e.getMessage(); } } diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java index 9c23692a13827e7701a3877a64fa4d625e25f877..f46635e87bebbcf1dee44987a770b01a2dc3b712 100644 --- a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java +++ b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java @@ -40,7 +40,7 @@ public class PolicyRuleDevice { this.policyRuleBasic = policyRuleBasic; this.deviceIds = new ArrayList<String>(); this.isValid = false; - this.exceptionMessage = e.toString(); + this.exceptionMessage = e.getMessage(); } } diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java index 1f507ebc944ceab6f8018b52c8d534f5b9795930..db25dc9bfb15bc64212ac1f141b73a18eed7ff24 100644 --- a/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java +++ b/src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java @@ -50,7 +50,7 @@ public class PolicyRuleService { this.serviceId = new ServiceId("", ""); this.deviceIds = new ArrayList<String>(); this.isValid = false; - this.exceptionMessage = e.toString(); + this.exceptionMessage = e.getMessage(); } } diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddDeviceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddDeviceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..7c7c6b1b5e096ac9422ec5209b213e4f4435410b --- /dev/null +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddDeviceTest.java @@ -0,0 +1,204 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE; +import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import io.smallrye.mutiny.Uni; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.inject.Inject; +import org.etsi.tfs.policy.context.ContextService; +import org.etsi.tfs.policy.model.BooleanOperator; +import org.etsi.tfs.policy.model.NumericalOperator; +import org.etsi.tfs.policy.model.PolicyRuleAction; +import org.etsi.tfs.policy.model.PolicyRuleActionConfig; +import org.etsi.tfs.policy.model.PolicyRuleActionEnum; +import org.etsi.tfs.policy.model.PolicyRuleBasic; +import org.etsi.tfs.policy.model.PolicyRuleCondition; +import org.etsi.tfs.policy.model.PolicyRuleDevice; +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; +import org.etsi.tfs.policy.monitoring.MonitoringService; +import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue; +import org.etsi.tfs.policy.monitoring.model.KpiValue; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +@QuarkusTest +class PolicyAddDeviceTest { + + @Inject PolicyServiceImpl policyService; + + @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator; + + @InjectMock ContextService contextService; + + @InjectMock MonitoringService monitoringService; + static PolicyRuleBasic policyRuleBasic; + static PolicyRuleDevice policyRuleDevice; + + @BeforeAll + static void init() { + + String policyId = "policyRuleId"; + KpiValue kpiValue = new IntegerKpiValue(100); + + PolicyRuleCondition policyRuleCondition = + new PolicyRuleCondition( + "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue); + + PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value"); + + PolicyRuleAction policyRuleAction = + new PolicyRuleAction( + PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION, + Arrays.asList(policyRuleActionConfig)); + + policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + Arrays.asList(policyRuleCondition), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + Arrays.asList(policyRuleAction)); + + List<String> deviceIds = Arrays.asList("device1", "device2"); + + policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds); + } + + @Test + void deviceListMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty."); + + policyService + .addPolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleBasic policyRuleBasic = + new PolicyRuleBasic( + "policyId", + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 0, + new ArrayList<>(), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + new ArrayList<>()); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty."); + + policyService + .addPolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void isPolicyRuleIdValid() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, + String.format( + INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId())); + + Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString())) + .thenReturn(Uni.createFrom().item(Boolean.FALSE)); + + policyService + .addPolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void successPolicyDevice() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_VALIDATED, + VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage()); + + Mockito.when(policyRuleConditionValidator.isDeviceIdValid(Mockito.anyString())) + .thenReturn(Uni.createFrom().item(Boolean.TRUE)); + + policyService + .addPolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } +} diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..773187f0748c6f2d0507e2f78b6ba42cd558e2ae --- /dev/null +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java @@ -0,0 +1,251 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.etsi.tfs.policy.common.ApplicationProperties.*; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import io.smallrye.mutiny.Uni; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.inject.Inject; +import org.etsi.tfs.policy.context.ContextService; +import org.etsi.tfs.policy.context.model.Service; +import org.etsi.tfs.policy.context.model.ServiceId; +import org.etsi.tfs.policy.context.model.ServiceTypeEnum; +import org.etsi.tfs.policy.model.BooleanOperator; +import org.etsi.tfs.policy.model.NumericalOperator; +import org.etsi.tfs.policy.model.PolicyRule; +import org.etsi.tfs.policy.model.PolicyRuleAction; +import org.etsi.tfs.policy.model.PolicyRuleActionConfig; +import org.etsi.tfs.policy.model.PolicyRuleActionEnum; +import org.etsi.tfs.policy.model.PolicyRuleBasic; +import org.etsi.tfs.policy.model.PolicyRuleCondition; +import org.etsi.tfs.policy.model.PolicyRuleService; +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; +import org.etsi.tfs.policy.monitoring.MonitoringService; +import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue; +import org.etsi.tfs.policy.monitoring.model.KpiValue; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +@QuarkusTest +public class PolicyAddServiceTest { + + @Inject PolicyServiceImpl policyService; + + @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator; + + @InjectMock ContextService contextService; + + @InjectMock MonitoringService monitoringService; + + static PolicyRuleBasic policyRuleBasic; + static PolicyRuleService policyRuleService; + + @BeforeAll + static void init() { + + String policyId = "policyRuleId"; + KpiValue kpiValue = new IntegerKpiValue(100); + + PolicyRuleCondition policyRuleCondition = + new PolicyRuleCondition( + "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue); + + PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value"); + + PolicyRuleAction policyRuleAction = + new PolicyRuleAction( + PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION, + Arrays.asList(policyRuleActionConfig)); + + policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + Arrays.asList(policyRuleCondition), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + Arrays.asList(policyRuleAction)); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0); + + List<String> deviceIds = Arrays.asList("device1", "device2"); + + policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + } + + @Test + void contextOrServiceIdMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("", ""); + List<String> deviceIds = Arrays.asList("device1", "device2"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, "Context Id of Service Id must not be empty."); + + policyService + .addPolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void serviceIdMustNotBeEmpty() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("sdf", ""); + List<String> deviceIds = Arrays.asList("device1", "device2"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Service Id must not be empty."); + + policyService + .addPolicyService(policyRuleService) + .subscribe() + .with(item -> message.complete(item)); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void policyRuleIdMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + String policyId = ""; + + PolicyRuleBasic policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + new ArrayList<>(), + null, + new ArrayList<>()); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Policy rule ID must not be empty."); + + policyService + .addPolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void checkMessageIfServiceIsNotValid() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, serviceId + " is invalid."); + + Mockito.when( + policyRuleConditionValidator.isServiceIdValid( + Mockito.any(ServiceId.class), Mockito.anyList())) + .thenReturn(Uni.createFrom().item(Boolean.FALSE)); + + policyService + .addPolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void policyServiceSuccess() + throws ExecutionException, InterruptedException, TimeoutException, IOException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_VALIDATED, + VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage()); + + Mockito.when( + policyRuleConditionValidator.isServiceIdValid( + Mockito.any(ServiceId.class), Mockito.anyList())) + .thenReturn(Uni.createFrom().item(Boolean.TRUE)); + + Mockito.when(contextService.setPolicyRule(Mockito.any(PolicyRule.class))) + .thenReturn(Uni.createFrom().item("policyRuleId")); + + policyService + .addPolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } +} diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyDeleteServiceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyDeleteServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..56e686bf6822a577439b020ea71d8c7f40b51c94 --- /dev/null +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyDeleteServiceTest.java @@ -0,0 +1,131 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.etsi.tfs.policy.common.ApplicationProperties.REMOVED_POLICYRULE_STATE; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import io.smallrye.mutiny.Uni; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.inject.Inject; +import org.etsi.tfs.policy.context.ContextService; +import org.etsi.tfs.policy.context.model.Service; +import org.etsi.tfs.policy.context.model.ServiceId; +import org.etsi.tfs.policy.context.model.ServiceTypeEnum; +import org.etsi.tfs.policy.model.BooleanOperator; +import org.etsi.tfs.policy.model.NumericalOperator; +import org.etsi.tfs.policy.model.PolicyRule; +import org.etsi.tfs.policy.model.PolicyRuleAction; +import org.etsi.tfs.policy.model.PolicyRuleActionConfig; +import org.etsi.tfs.policy.model.PolicyRuleActionEnum; +import org.etsi.tfs.policy.model.PolicyRuleBasic; +import org.etsi.tfs.policy.model.PolicyRuleCondition; +import org.etsi.tfs.policy.model.PolicyRuleService; +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; +import org.etsi.tfs.policy.model.PolicyRuleType; +import org.etsi.tfs.policy.model.PolicyRuleTypeService; +import org.etsi.tfs.policy.monitoring.MonitoringService; +import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue; +import org.etsi.tfs.policy.monitoring.model.KpiValue; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +@QuarkusTest +class PolicyDeleteServiceTest { + + @Inject PolicyServiceImpl policyService; + @InjectMock ContextService contextService; + + @InjectMock MonitoringService monitoringService; + + static PolicyRuleBasic policyRuleBasic; + static PolicyRuleService policyRuleService; + + @BeforeAll + static void init() { + + String policyId = "policyRuleId"; + KpiValue kpiValue = new IntegerKpiValue(100); + + PolicyRuleCondition policyRuleCondition = + new PolicyRuleCondition( + "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue); + + PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value"); + + PolicyRuleAction policyRuleAction = + new PolicyRuleAction( + PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION, + Arrays.asList(policyRuleActionConfig)); + + policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + Arrays.asList(policyRuleCondition), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + Arrays.asList(policyRuleAction)); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0); + + List<String> deviceIds = Arrays.asList("device1", "device2"); + + policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + } + + @Test + void contextOrServiceIdMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + String policyRuleId = ""; + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_REMOVED, + REMOVED_POLICYRULE_STATE.getPolicyRuleStateMessage()); + + PolicyRuleType policyRuleType = new PolicyRuleTypeService(policyRuleService); + + PolicyRule policyRule = new PolicyRule(policyRuleType); + + Mockito.when(contextService.getPolicyRule(Mockito.anyString())) + .thenReturn(Uni.createFrom().item(policyRule)); + + policyService + .deletePolicy(policyRuleId) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } +} diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyServiceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyGrpcServiceTest.java similarity index 99% rename from src/policy/src/test/java/org/etsi/tfs/policy/PolicyServiceTest.java rename to src/policy/src/test/java/org/etsi/tfs/policy/PolicyGrpcServiceTest.java index 2d1a425a8d4166779d7e18e5deaecb9ff9ec49ca..2461bcee61984656dc99ac75679dae680ab7b20b 100644 --- a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyServiceTest.java +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyGrpcServiceTest.java @@ -46,14 +46,14 @@ import policy.PolicyCondition.PolicyRuleCondition; import policy.PolicyService; @QuarkusTest -class PolicyServiceTest { - private static final Logger LOGGER = Logger.getLogger(PolicyServiceTest.class); +class PolicyGrpcServiceTest { + private static final Logger LOGGER = Logger.getLogger(PolicyGrpcServiceTest.class); @GrpcClient PolicyService client; private final Serializer serializer; @Inject - PolicyServiceTest(Serializer serializer) { + PolicyGrpcServiceTest(Serializer serializer) { this.serializer = serializer; } diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateDeviceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateDeviceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..ac8757508f2e0ccb5575fe210fe21819ab7e93aa --- /dev/null +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateDeviceTest.java @@ -0,0 +1,204 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE; +import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import io.smallrye.mutiny.Uni; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.inject.Inject; +import org.etsi.tfs.policy.model.BooleanOperator; +import org.etsi.tfs.policy.model.NumericalOperator; +import org.etsi.tfs.policy.model.PolicyRuleAction; +import org.etsi.tfs.policy.model.PolicyRuleActionConfig; +import org.etsi.tfs.policy.model.PolicyRuleActionEnum; +import org.etsi.tfs.policy.model.PolicyRuleBasic; +import org.etsi.tfs.policy.model.PolicyRuleCondition; +import org.etsi.tfs.policy.model.PolicyRuleDevice; +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; +import org.etsi.tfs.policy.monitoring.MonitoringService; +import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue; +import org.etsi.tfs.policy.monitoring.model.KpiValue; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +@QuarkusTest +class PolicyUpdateDeviceTest { + + @Inject PolicyServiceImpl policyService; + + @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator; + + @InjectMock MonitoringService monitoringService; + + static PolicyRuleBasic policyRuleBasic; + static PolicyRuleDevice policyRuleDevice; + + @BeforeAll + static void init() { + + String policyId = "policyRuleId"; + KpiValue kpiValue = new IntegerKpiValue(100); + + PolicyRuleCondition policyRuleCondition = + new PolicyRuleCondition( + "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue); + + PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value"); + + PolicyRuleAction policyRuleAction = + new PolicyRuleAction( + PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION, + Arrays.asList(policyRuleActionConfig)); + + policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + Arrays.asList(policyRuleCondition), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + Arrays.asList(policyRuleAction)); + + List<String> deviceIds = Arrays.asList("device1", "device2"); + + policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds); + } + + @Test + void deviceListMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty."); + + policyService + .updatePolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleBasic policyRuleBasic = + new PolicyRuleBasic( + "policyId", + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 0, + new ArrayList<>(), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + new ArrayList<>()); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty."); + + policyService + .updatePolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void isUpdatedPolicyRuleIdValid() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, + String.format( + INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId())); + + Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString())) + .thenReturn(Uni.createFrom().item(Boolean.FALSE)); + + policyService + .updatePolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void successUpdatePolicyService() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + PolicyRuleDevice policyRuleDevice = + new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1")); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_VALIDATED, + VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage()); + + Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString())) + .thenReturn(Uni.createFrom().item(Boolean.TRUE)); + + policyService + .updatePolicyDevice(policyRuleDevice) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } +} diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateServiceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e65f2d459557c25fe9ca1a61c97d9fd1accc1895 --- /dev/null +++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateServiceTest.java @@ -0,0 +1,215 @@ +/* +* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +package org.etsi.tfs.policy; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE; +import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE; + +import io.quarkus.test.junit.QuarkusTest; +import io.quarkus.test.junit.mockito.InjectMock; +import io.smallrye.mutiny.Uni; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.inject.Inject; +import org.etsi.tfs.policy.context.ContextService; +import org.etsi.tfs.policy.context.model.Service; +import org.etsi.tfs.policy.context.model.ServiceId; +import org.etsi.tfs.policy.context.model.ServiceTypeEnum; +import org.etsi.tfs.policy.model.BooleanOperator; +import org.etsi.tfs.policy.model.NumericalOperator; +import org.etsi.tfs.policy.model.PolicyRuleAction; +import org.etsi.tfs.policy.model.PolicyRuleActionConfig; +import org.etsi.tfs.policy.model.PolicyRuleActionEnum; +import org.etsi.tfs.policy.model.PolicyRuleBasic; +import org.etsi.tfs.policy.model.PolicyRuleCondition; +import org.etsi.tfs.policy.model.PolicyRuleService; +import org.etsi.tfs.policy.model.PolicyRuleState; +import org.etsi.tfs.policy.model.PolicyRuleStateEnum; +import org.etsi.tfs.policy.monitoring.MonitoringService; +import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue; +import org.etsi.tfs.policy.monitoring.model.KpiValue; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +@QuarkusTest +class PolicyUpdateServiceTest { + + @Inject PolicyServiceImpl policyService; + + @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator; + + @InjectMock ContextService contextService; + + @InjectMock MonitoringService monitoringService; + + static PolicyRuleBasic policyRuleBasic; + static PolicyRuleService policyRuleService; + + @BeforeAll + static void init() { + + String policyId = "policyRuleId"; + KpiValue kpiValue = new IntegerKpiValue(100); + + PolicyRuleCondition policyRuleCondition = + new PolicyRuleCondition( + "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue); + + PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value"); + + PolicyRuleAction policyRuleAction = + new PolicyRuleAction( + PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION, + Arrays.asList(policyRuleActionConfig)); + + policyRuleBasic = + new PolicyRuleBasic( + policyId, + new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"), + 1, + Arrays.asList(policyRuleCondition), + BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR, + Arrays.asList(policyRuleAction)); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0); + + List<String> deviceIds = Arrays.asList("device1", "device2"); + + policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + } + + @Test + void contextOrServiceIdMustNotBeEmpty() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("", ""); + List<String> deviceIds = Arrays.asList("device1", "device2"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, "Context Id of Service Id must not be empty."); + + policyService + .updatePolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void serviceIdMustNotBeEmpty() throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("sdf", ""); + List<String> deviceIds = Arrays.asList("device1", "device2"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, deviceIds); + + PolicyRuleState expectedResult = + new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Service Id must not be empty."); + + policyService + .updatePolicyService(policyRuleService) + .subscribe() + .with(item -> message.complete(item)); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void checkMessageIfServiceIsNotValid() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_FAILED, String.format(INVALID_MESSAGE, serviceId)); + + Mockito.when( + policyRuleConditionValidator.isPolicyRuleServiceValid( + Mockito.anyString(), Mockito.any(ServiceId.class))) + .thenReturn(Uni.createFrom().item(Boolean.FALSE)); + + policyService + .updatePolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } + + @Test + void successUpdatePolicyService() + throws ExecutionException, InterruptedException, TimeoutException { + CompletableFuture<PolicyRuleState> message = new CompletableFuture<>(); + + ServiceId serviceId = new ServiceId("contextId", "serviceId"); + + PolicyRuleService policyRuleService = + new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>()); + + PolicyRuleState expectedResult = + new PolicyRuleState( + PolicyRuleStateEnum.POLICY_VALIDATED, + VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage()); + + Mockito.when( + policyRuleConditionValidator.isPolicyRuleServiceValid( + Mockito.anyString(), Mockito.any(ServiceId.class))) + .thenReturn(Uni.createFrom().item(Boolean.TRUE)); + + policyService + .updatePolicyService(policyRuleService) + .subscribe() + .with( + item -> { + message.complete(item); + }); + + assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage()) + .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString()); + } +} diff --git a/src/policy/target/kubernetes/kubernetes.yml b/src/policy/target/kubernetes/kubernetes.yml index 55847f89e7c031de854d1e54336342f7a24e320a..2737f8546570e5d483c62024018137d96fe32a4d 100644 --- a/src/policy/target/kubernetes/kubernetes.yml +++ b/src/policy/target/kubernetes/kubernetes.yml @@ -3,8 +3,8 @@ apiVersion: v1 kind: Service metadata: annotations: - app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467 - app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000 + app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db + app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000 prometheus.io/scrape: "true" prometheus.io/path: /q/metrics prometheus.io/port: "8080" @@ -29,8 +29,8 @@ apiVersion: apps/v1 kind: Deployment metadata: annotations: - app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467 - app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000 + app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db + app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000 prometheus.io/scrape: "true" prometheus.io/path: /q/metrics prometheus.io/port: "8080" @@ -47,8 +47,8 @@ spec: template: metadata: annotations: - app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467 - app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000 + app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db + app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000 prometheus.io/scrape: "true" prometheus.io/path: /q/metrics prometheus.io/port: "8080" @@ -63,12 +63,12 @@ spec: valueFrom: fieldRef: fieldPath: metadata.namespace + - name: CONTEXT_SERVICE_HOST + value: contextservice - name: SERVICE_SERVICE_HOST value: serviceservice - name: MONITORING_SERVICE_HOST value: monitoringservice - - name: CONTEXT_SERVICE_HOST - value: contextservice image: labs.etsi.org:5050/tfs/controller/policy:0.1.0 imagePullPolicy: Always livenessProbe: diff --git a/src/tests/tools/mock_ietf_actn_sdn_ctrl/README.md b/src/tests/tools/mock_ietf_actn_sdn_ctrl/README.md index a12ae907e792f98413903b6637738c392506be4a..52aa2922d0699b1d286319e11cc25f8707fda686 100644 --- a/src/tests/tools/mock_ietf_actn_sdn_ctrl/README.md +++ b/src/tests/tools/mock_ietf_actn_sdn_ctrl/README.md @@ -7,22 +7,17 @@ This REST server implements very basic support for the following YANG data model - Ref: https://datatracker.ietf.org/doc/draft-ietf-teas-yang-te/ The aim of this server is to enable testing the IetfActnDeviceDriver and the IetfActnServiceHandler. -Follow the steps below to perform the test: -## 1. Deploy TeraFlowSDN controller and the scenario -Deploy the test scenario "ietf_actn_deploy.sh": -```bash -source src/tests/tools/mock_ietf_actn_sdn_ctrl/scenario/ietf_actn_deploy.sh -./deploy/all.sh -``` -## 2. Install requirements and run the Mock IETF ACTN SDN controller -__NOTE__: if you run the Mock IETF ACTN SDN controller from the PyEnv used for developping on the TeraFlowSDN framework, +## 1. Install requirements for the Mock IETF ACTN SDN controller +__NOTE__: if you run the Mock IETF ACTN SDN controller from the PyEnv used for developing on the TeraFlowSDN +framework and you followed the official steps in +[Development Guide > Configure Environment > Python](https://labs.etsi.org/rep/tfs/controller/-/wikis/2.-Development-Guide/2.1.-Configure-Environment/2.1.1.-Python), all the requirements are already in place. Install them only if you execute it in a separate/standalone environment. Install the required dependencies as follows: ```bash -pip install Flask==2.1.3 Flask-RESTful==0.3.9 +pip install -r src/tests/tools/mock_ietf_actn_sdn_ctrl/requirements.in ``` Run the Mock IETF ACTN SDN Controller as follows: @@ -30,24 +25,9 @@ Run the Mock IETF ACTN SDN Controller as follows: python src/tests/tools/mock_ietf_actn_sdn_ctrl/MockIetfActnSdnCtrl.py ``` -## 3. Deploy the test descriptors -Edit the descriptors to meet your environment specifications. -Edit "network_descriptors.json" and change IP address and port of the IETF ACTN SDN controller of the "ACTN" device. -- Set value of config rule "_connect/address" to the address of the host where the Mock IETF ACTN SDN controller is - running (default="192.168.1.1"). -- Set value of config rule "_connect/port" to the port where your Mock IETF ACTN SDN controller is listening on - (default="8443"). - -Upload the "network_descriptors.json" through the TeraFlowSDN WebUI. -- If not already selected, select Context(admin)/Topology(admin). -- Check that a network topology with 4 routers + 1 IETF ACTN radio system are loaded. They should form 2 rings. - -Upload the "service_descriptor.json" through the TeraFlowSDN WebUI. -- Check that 2 services have been created. -- The "actn-svc" should have a connection and be supported by a sub-service. -- The sub-service should also have a connection. -- The R1, R3, and MW devices should have configuration rules established. - -# 4. Delete the IETF ACTN service -Find the "mw-svc" on the WebUI, navigate to its details, and delete the service pressing the "Delete Service" button. -The service, sub-service, and device configuration rules should be removed. + +## 2. Run the Mock IETF ACTN SDN controller +Run the Mock IETF ACTN SDN Controller as follows: +```bash +python src/tests/tools/mock_ietf_actn_sdn_ctrl/MockIetfActnSdnCtrl.py +``` diff --git a/src/tests/tools/mock_ietf_actn_sdn_ctrl/build.sh b/src/tests/tools/mock_ietf_actn_sdn_ctrl/build.sh index d9db334cbf1d361cc9cbce42f95fb10bafc609ed..fe958995ac303ca003aee9557b7fc07905933fce 100755 --- a/src/tests/tools/mock_ietf_actn_sdn_ctrl/build.sh +++ b/src/tests/tools/mock_ietf_actn_sdn_ctrl/build.sh @@ -13,6 +13,9 @@ # See the License for the specific language governing permissions and # limitations under the License. +# Make folder containing the script the root folder for its execution +cd $(dirname $0) + docker build -t mock-ietf-actn-sdn-ctrl:test -f Dockerfile . docker tag mock-ietf-actn-sdn-ctrl:test localhost:32000/tfs/mock-ietf-actn-sdn-ctrl:test docker push localhost:32000/tfs/mock-ietf-actn-sdn-ctrl:test diff --git a/src/tests/tools/mock_ietf_actn_sdn_ctrl/run.sh b/src/tests/tools/mock_ietf_actn_sdn_ctrl/run.sh index 2697e538ec69a99da4c0fae898748ff496b5d28f..48a23f2e41d6d30d244ef01c72ac9700b588b140 100755 --- a/src/tests/tools/mock_ietf_actn_sdn_ctrl/run.sh +++ b/src/tests/tools/mock_ietf_actn_sdn_ctrl/run.sh @@ -13,4 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +# Make folder containing the script the root folder for its execution +cd $(dirname $0) + python MockIetfActnSdnCtrl.py