refactor: add exception handling mechanism on addPolicyService. (d96c938f) · Commits · TFS / controller

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

+23 −12

Original line number	Diff line number	Diff line
		@@ -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 ->
		.onFailure()
		.transform(failure -> new NewException(failure.getMessage()))
		.onItem()
		.transform(
		policyId -> {
		startMonitoringBasedOnAlarmDescriptors(
		policyId, policyRuleService, alarmDescriptorList));
		policyId, policyRuleService, alarmDescriptorList);

		return VALIDATED_POLICYRULE_STATE;
		});
		}

		private void startMonitoringBasedOnAlarmDescriptors(

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

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		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

0 → 100644

+44 −0

Original line number	Diff line number	Diff line
		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

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		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);
		}
		}