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: