Add UpdatePolicyService grpc implementation

src/policy/src/main/java/eu/teraflow/policy/PolicyGatewayImpl.java

@@ -52,24 +52,23 @@ public class PolicyGatewayImpl implements PolicyGateway {
     }
 
     @Override
-    public Uni<PolicyRuleState> policyAddDevice(PolicyRuleDevice request) {
-        final var policyRuleDevice = serializer.deserialize(request);
+    public Uni<PolicyRuleState> policyUpdateService(PolicyRuleService request) {
+        final var policyRuleService = serializer.deserialize(request);
 
         return policyService
-                .addPolicyDevice(policyRuleDevice)
+                .updatePolicyService(policyRuleService)
                 .onItem()
                 .transform(serializer::serialize);
     }
 
     @Override
-    public Uni<PolicyRuleState> policyUpdateService(PolicyRuleService request) {
-        return Uni.createFrom()
-                .item(
-                        () ->
-                                Policy.PolicyRuleState.newBuilder()
-                                        .setPolicyRuleState(
-                                                request.getPolicyRuleBasic().getPolicyRuleState().getPolicyRuleState())
-                                        .build());
+    public Uni<PolicyRuleState> policyAddDevice(PolicyRuleDevice request) {
+        final var policyRuleDevice = serializer.deserialize(request);
+
+        return policyService
+                .addPolicyDevice(policyRuleDevice)
+                .onItem()
+                .transform(serializer::serialize);
     }
 
     @Override

src/policy/src/main/java/eu/teraflow/policy/PolicyRuleConditionValidator.java

@@ -70,6 +70,21 @@ public class PolicyRuleConditionValidator {
         return isServiceIdValid;
     }
 
+    public Uni<Boolean> validateUpdatedPolicyRuleId(String updatedPolicyRuleId) {
+        final var isUpdatedPolicyRuleIdValid = isUpdatedPolicyRuleIdValid(updatedPolicyRuleId);
+
+        isUpdatedPolicyRuleIdValid
+                .subscribe()
+                .with(
+                        serviceIdBooleanValue -> {
+                            if (Boolean.FALSE.equals(serviceIdBooleanValue)) {
+                                LOGGER.errorf(INVALID_MESSAGE, updatedPolicyRuleId);
+                            }
+                        });
+
+        return isUpdatedPolicyRuleIdValid;
+    }
+
     private Uni<Boolean> isDeviceIdValid(String deviceId) {
         return contextService
                 .getDevice(deviceId)
@@ -98,4 +113,18 @@ public class PolicyRuleConditionValidator {
         return serviceServiceIdContextId.equals(serviceId.getContextId())
                 && serviceServiceIdId.equals(serviceId.getId());
     }
+
+    private Uni<Boolean> isUpdatedPolicyRuleIdValid(String updatedPolicyRuleId) {
+        return contextService
+                .getPolicyRule(updatedPolicyRuleId)
+                .onItem()
+                .ifNotNull()
+                .transform(
+                        id -> {
+                            return true;
+                        })
+                .onItem()
+                .ifNull()
+                .continueWith(false);
+    }
 }

src/policy/src/main/java/eu/teraflow/policy/PolicyService.java

@@ -25,5 +25,7 @@ public interface PolicyService {
 
     Uni<PolicyRuleState> addPolicyService(PolicyRuleService policyRuleService);
 
+    Uni<PolicyRuleState> updatePolicyService(PolicyRuleService policyRuleService);
+
     Uni<PolicyRuleState> addPolicyDevice(PolicyRuleDevice policyRuleDevice);
 }

src/policy/src/main/java/eu/teraflow/policy/PolicyServiceImpl.java

@@ -81,6 +81,8 @@ public class PolicyServiceImpl implements PolicyService {
             new PolicyRuleState(PolicyRuleStateEnum.POLICY_INEFFECTIVE);
     private static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE =
             new PolicyRuleState(PolicyRuleStateEnum.POLICY_EFFECTIVE);
+    private static final PolicyRuleState UPDATED_POLICYRULE_STATE =
+            new PolicyRuleState(PolicyRuleStateEnum.POLICY_UPDATED);
 
     private final ContextService contextService;
     private final MonitoringService monitoringService;
@@ -121,6 +123,59 @@ public class PolicyServiceImpl implements PolicyService {
         return Long.valueOf(now).doubleValue();
     }
 
+    @Override
+    public Uni<PolicyRuleState> addPolicyService(PolicyRuleService policyRuleService) {
+        LOGGER.infof("Received %s", policyRuleService);
+
+        final var policyRuleBasic = policyRuleService.getPolicyRuleBasic();
+        policyRuleBasic.setPolicyRuleState(INSERTED_POLICYRULE_STATE);
+
+        new Thread(
+                        () -> {
+                            validateService(policyRuleService);
+                        })
+                .start();
+
+        contextService.setPolicyRule(policyRuleBasic);
+
+        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
+    }
+
+    @Override
+    public Uni<PolicyRuleState> updatePolicyService(PolicyRuleService policyRuleService) {
+        LOGGER.infof("Received %s", policyRuleService);
+
+        final var policyRuleBasic = policyRuleService.getPolicyRuleBasic();
+        policyRuleBasic.setPolicyRuleState(UPDATED_POLICYRULE_STATE);
+
+        new Thread(
+                        () -> {
+                            validateUpdatedPolicyService(policyRuleService);
+                        })
+                .start();
+
+        contextService.setPolicyRule(policyRuleBasic);
+
+        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
+    }
+
+    @Override
+    public Uni<PolicyRuleState> addPolicyDevice(PolicyRuleDevice policyRuleDevice) {
+        LOGGER.infof("Received %s", policyRuleDevice);
+
+        final var policyRuleBasic = policyRuleDevice.getPolicyRuleBasic();
+        policyRuleBasic.setPolicyRuleState(INSERTED_POLICYRULE_STATE);
+
+        new Thread(
+                        () -> {
+                            validateDevice(policyRuleDevice);
+                        })
+                .start();
+
+        contextService.setPolicyRule(policyRuleBasic);
+        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
+    }
+
     private void provisionAlarm(
             PolicyRuleBasic policyRuleBasic,
             List<AlarmDescriptor> alarmDescriptorList,
@@ -374,6 +429,27 @@ public class PolicyServiceImpl implements PolicyService {
         return;
     }
 
+    private void validateUpdatedPolicyService(PolicyRuleService policyRuleService) {
+
+        final var policyRuleBasic = policyRuleService.getPolicyRuleBasic();
+        final var isUpdatedPolicyRuleValid =
+                policyRuleConditionValidator.validateUpdatedPolicyRuleId(policyRuleBasic.getPolicyRuleId());
+
+        isUpdatedPolicyRuleValid
+                .subscribe()
+                .with(
+                        policyRuleBoolean -> {
+                            if (Boolean.TRUE.equals(isUpdatedPolicyRuleValid)) {
+                                validateService(policyRuleService);
+                                return;
+                            } else {
+                                policyRuleBasic.setPolicyRuleState(FAILED_POLICYRULE_STATE);
+                                contextService.setPolicyRule(policyRuleBasic);
+                                return;
+                            }
+                        });
+    }
+
     private void validateService(PolicyRuleService policyRuleService) {
         final var serviceId = policyRuleService.getServiceId();
         final var deviceIds = policyRuleService.getDeviceIds();
@@ -626,41 +702,6 @@ public class PolicyServiceImpl implements PolicyService {
                 getTimeStamp());
     }
 
-    @Override
-    public Uni<PolicyRuleState> addPolicyService(PolicyRuleService policyRuleService) {
-        LOGGER.infof("Received %s", policyRuleService);
-
-        final var policyRuleBasic = policyRuleService.getPolicyRuleBasic();
-        policyRuleBasic.setPolicyRuleState(INSERTED_POLICYRULE_STATE);
-
-        new Thread(
-                        () -> {
-                            validateService(policyRuleService);
-                        })
-                .start();
-
-        contextService.setPolicyRule(policyRuleBasic);
-
-        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
-    }
-
-    @Override
-    public Uni<PolicyRuleState> addPolicyDevice(PolicyRuleDevice policyRuleDevice) {
-        LOGGER.infof("Received %s", policyRuleDevice);
-
-        final var policyRuleBasic = policyRuleDevice.getPolicyRuleBasic();
-        policyRuleBasic.setPolicyRuleState(INSERTED_POLICYRULE_STATE);
-
-        new Thread(
-                        () -> {
-                            validateDevice(policyRuleDevice);
-                        })
-                .start();
-
-        contextService.setPolicyRule(policyRuleBasic);
-        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
-    }
-
     private List<String> returnInvalidDeviceIds(List<String> deviceIds) {
         var invalidDeviceIds = new ArrayList<String>();
 

src/policy/src/test/java/eu/teraflow/policy/PolicyRuleBasicValidationTest.java

@@ -35,6 +35,8 @@ import java.util.List;
 import java.util.UUID;
 import org.junit.jupiter.api.Test;
 
+// TODO: Revisit PolicyRuleBasicValidationTest cases after handling exceptions in PolicyRuleBasic
+// constructor
 @QuarkusTest
 class PolicyRuleBasicValidationTestHelper {
 

src/policy/src/test/java/eu/teraflow/policy/PolicyServiceTest.java

@@ -183,7 +183,7 @@ class PolicyServiceTest {
 
         final var expectedPolicyRuleState =
                 Policy.PolicyRuleState.newBuilder()
-                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_ENFORCED)
+                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_UPDATED)
                         .build();
 
         final var policyRuleBasic =