refactor: add exception handling mechanism on addPolicyService.

src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java

@@ -31,6 +31,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
 import org.etsi.tfs.policy.context.ContextService;
 import org.etsi.tfs.policy.context.model.ConfigActionEnum;
 import org.etsi.tfs.policy.context.model.ConfigRule;
@@ -42,6 +44,8 @@ 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.exception.ExternalServiceFailureException;
+import org.etsi.tfs.policy.exception.NewException;
 import org.etsi.tfs.policy.model.BooleanOperator;
 import org.etsi.tfs.policy.model.PolicyRule;
 import org.etsi.tfs.policy.model.PolicyRuleAction;
@@ -143,14 +147,17 @@ public class PolicyServiceImpl implements PolicyService {
         final var isServiceValid = policyRuleConditionValidator.isServiceIdValid(serviceId, deviceIds);
 
         return isServiceValid
+                .onFailure()
+                .transform(failure -> new ExternalServiceFailureException(failure.getMessage()))
                 .onItem()
                 .transform(
                         isService ->
                                 constructPolicyStateBasedOnCriteria(
-                                        isService, serviceId, policyRuleService, policyRuleBasic));
+                                        isService, serviceId, policyRuleService, policyRuleBasic))
+                .flatMap(Function.identity());
     }
 
-    private PolicyRuleState constructPolicyStateBasedOnCriteria(
+    private Uni<PolicyRuleState> constructPolicyStateBasedOnCriteria(
             Boolean isService,
             ServiceId serviceId,
             PolicyRuleService policyRuleService,
@@ -161,7 +168,7 @@ public class PolicyServiceImpl implements PolicyService {
                     new PolicyRuleState(
                             PolicyRuleStateEnum.POLICY_FAILED, String.format(INVALID_MESSAGE, serviceId));
 
-            return policyRuleState;
+            return Uni.createFrom().item(policyRuleState);
         }
 
         final var policyRuleTypeService = new PolicyRuleTypeService(policyRuleService);
@@ -175,24 +182,28 @@ public class PolicyServiceImpl implements PolicyService {
                             String.format(
                                     "Invalid PolicyRuleConditions in PolicyRule with ID: %s",
                                     policyRuleBasic.getPolicyRuleId()));
-            return policyRuleState;
+            return Uni.createFrom().item(policyRuleState);
         }
 
         return setPolicyRuleOnContextAndReturnState(policyRule, policyRuleService, alarmDescriptorList);
     }
 
-    private PolicyRuleState setPolicyRuleOnContextAndReturnState(
+    private Uni<PolicyRuleState> setPolicyRuleOnContextAndReturnState(
             PolicyRule policyRule,
             PolicyRuleService policyRuleService,
             List<AlarmDescriptor> alarmDescriptorList) {
-        contextService
+        return contextService
                 .setPolicyRule(policyRule)
-                .subscribe()
-                .with(
-                        policyId ->
-                                startMonitoringBasedOnAlarmDescriptors(
-                                        policyId, policyRuleService, alarmDescriptorList));
-        return VALIDATED_POLICYRULE_STATE;
+                .onFailure()
+                .transform(failure -> new NewException(failure.getMessage()))
+                .onItem()
+                .transform(
+                        policyId -> {
+                            startMonitoringBasedOnAlarmDescriptors(
+                                    policyId, policyRuleService, alarmDescriptorList);
+
+                            return VALIDATED_POLICYRULE_STATE;
+                        });
     }
 
     private void startMonitoringBasedOnAlarmDescriptors(

src/policy/src/main/java/org/etsi/tfs/policy/exception/ExternalServiceFailureException.java

+package org.etsi.tfs.policy.exception;
+
+public class ExternalServiceFailureException extends RuntimeException {
+
+    public ExternalServiceFailureException(String message, Exception e) {
+        super(message, e);
+    }
+
+    public ExternalServiceFailureException(String message) {
+        super(message);
+    }
+}

src/policy/src/main/java/org/etsi/tfs/policy/exception/GeneralExceptionHandler.java

+package org.etsi.tfs.policy.exception;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.quarkus.grpc.ExceptionHandler;
+import io.quarkus.grpc.ExceptionHandlerProvider;
+import jakarta.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class GeneralExceptionHandler implements ExceptionHandlerProvider {
+    @Override
+    public <ReqT, RespT> ExceptionHandler<ReqT, RespT> createHandler(
+            ServerCall.Listener<ReqT> listener, ServerCall<ReqT, RespT> serverCall, Metadata metadata) {
+        return new HelloExceptionHandler<>(listener, serverCall, metadata);
+    }
+
+    @Override
+    public Throwable transform(Throwable t) {
+        if (t instanceof ExternalServiceFailureException) {
+            return new StatusRuntimeException(Status.INTERNAL.withDescription(t.getMessage()));
+        }else if (t instanceof NewException) {
+            return new StatusRuntimeException(Status.UNIMPLEMENTED.withDescription(t.getMessage()));
+        } else {
+            return ExceptionHandlerProvider.toStatusException(t, true);
+        }
+    }
+
+    private static class HelloExceptionHandler<A, B> extends ExceptionHandler<A, B> {
+        public HelloExceptionHandler(
+                ServerCall.Listener<A> listener, ServerCall<A, B> call, Metadata metadata) {
+            super(listener, call, metadata);
+        }
+
+        @Override
+        protected void handleException(Throwable t, ServerCall<A, B> call, Metadata metadata) {
+            StatusRuntimeException sre =
+                    (StatusRuntimeException) ExceptionHandlerProvider.toStatusException(t, true);
+            Metadata trailers = sre.getTrailers() != null ? sre.getTrailers() : metadata;
+            call.close(sre.getStatus(), trailers);
+        }
+    }
+}

src/policy/src/main/java/org/etsi/tfs/policy/exception/NewException.java

+package org.etsi.tfs.policy.exception;
+
+public class NewException extends RuntimeException {
+
+    public NewException(String message, Exception e) {
+        super(message, e);
+    }
+
+    public NewException(String message) {
+        super(message);
+    }
+}