refactor(policy): integrate monitoring protobuf updates (d9e45eaa) · Commits · TFS / controller

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

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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 eu.teraflow.policy;

		import eu.teraflow.policy.model.NumericalOperator;
		import eu.teraflow.policy.model.PolicyRuleCondition;
		import eu.teraflow.policy.monitoring.model.KpiValue;
		import java.util.List;
		import java.util.stream.Collectors;
		import javax.inject.Singleton;

		@Singleton
		public class PolicyRuleConditionFieldsGetter {

		public List<String> getKpiIds(List<PolicyRuleCondition> policyRuleConditions) {
		return policyRuleConditions.stream()
		.map(PolicyRuleCondition::getKpiId)
		.collect(Collectors.toList());
		}

		public List<KpiValue> getKpiValues(List<PolicyRuleCondition> policyRuleConditions) {
		return policyRuleConditions.stream()
		.map(PolicyRuleCondition::getKpiValue)
		.collect(Collectors.toList());
		}

		public List<NumericalOperator> getNumericalOperators(
		List<PolicyRuleCondition> policyRuleConditions) {
		return policyRuleConditions.stream()
		.map(PolicyRuleCondition::getNumericalOperator)
		.collect(Collectors.toList());
		}
		}

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

0 → 100644

+101 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
		*
		* 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 eu.teraflow.policy;

		import eu.teraflow.policy.context.ContextService;
		import eu.teraflow.policy.context.model.Device;
		import eu.teraflow.policy.context.model.Service;
		import eu.teraflow.policy.context.model.ServiceId;
		import io.smallrye.mutiny.Uni;
		import javax.enterprise.context.ApplicationScoped;
		import javax.inject.Inject;
		import org.jboss.logging.Logger;

		@ApplicationScoped
		public class PolicyRuleConditionValidator {

		private static final Logger LOGGER = Logger.getLogger(PolicyRuleConditionValidator.class);
		private static final String INVALID_MESSAGE = "%s is invalid.";
		private static final String VALID_MESSAGE = "%s is valid.";

		private final ContextService contextService;

		@Inject
		public PolicyRuleConditionValidator(ContextService contextService) {
		this.contextService = contextService;
		}

		public Uni<Boolean> validateDeviceId(String deviceId) {
		final var isDeviceIdValid = isDeviceIdValid(deviceId);

		isDeviceIdValid
		.subscribe()
		.with(
		deviceIdIdBooleanValue -> {
		if (Boolean.FALSE.equals(deviceIdIdBooleanValue)) {
		LOGGER.errorf(INVALID_MESSAGE, deviceId);
		}
		LOGGER.infof(VALID_MESSAGE, deviceId);
		});

		return isDeviceIdValid;
		}

		public Uni<Boolean> validateServiceId(ServiceId serviceId) {
		final var isServiceIdValid = isServiceIdValid(serviceId);

		isServiceIdValid
		.subscribe()
		.with(
		serviceIdBooleanValue -> {
		if (Boolean.FALSE.equals(serviceIdBooleanValue)) {
		LOGGER.errorf(INVALID_MESSAGE, serviceId);
		}
		});

		return isServiceIdValid;
		}

		private Uni<Boolean> isDeviceIdValid(String deviceId) {
		return contextService
		.getDevice(deviceId)
		.onItem()
		.transform(device -> checkIfDeviceIdExists(device, deviceId));
		}

		private boolean checkIfDeviceIdExists(Device device, String deviceId) {
		final var deviceDeviceId = device.getDeviceId();

		return deviceDeviceId.equals(deviceId);
		}

		private Uni<Boolean> isServiceIdValid(ServiceId serviceId) {
		return contextService
		.getService(serviceId)
		.onItem()
		.transform(service -> checkIfServiceIdExists(service, serviceId));
		}

		private boolean checkIfServiceIdExists(Service service, ServiceId serviceId) {
		final var serviceServiceIdServiceId = service.getServiceId();
		final var serviceServiceIdContextId = serviceServiceIdServiceId.getContextId();
		final var serviceServiceIdId = serviceServiceIdServiceId.getId();

		return serviceServiceIdContextId.equals(serviceId.getContextId())
		&& serviceServiceIdId.equals(serviceId.getId());
		}
		}

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

+141 −1

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		package eu.teraflow.policy;

		import eu.teraflow.policy.context.ContextService;
		import eu.teraflow.policy.model.PolicyRuleBasic;
		import eu.teraflow.policy.model.PolicyRuleDevice;
		import eu.teraflow.policy.model.PolicyRuleService;
		import eu.teraflow.policy.model.PolicyRuleState;
		@@ -24,6 +25,8 @@ import eu.teraflow.policy.model.RuleState;
		import eu.teraflow.policy.monitoring.MonitoringService;
		import eu.teraflow.policy.service.ServiceService;
		import io.smallrye.mutiny.Uni;
		import java.util.ArrayList;
		import java.util.List;
		import javax.enterprise.context.ApplicationScoped;
		import javax.inject.Inject;
		import org.jboss.logging.Logger;
		@@ -32,23 +35,88 @@ 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 PolicyRuleState INSERTED_POLICYRULE_STATE =
		new PolicyRuleState(RuleState.POLICY_INSERTED);
		private static final PolicyRuleState VALIDATED_POLICYRULE_STATE =
		new PolicyRuleState(RuleState.POLICY_VALIDATED);
		private static final PolicyRuleState FAILED_POLICYRULE_STATE =
		new PolicyRuleState(RuleState.POLICY_FAILED);

		private final ContextService contextService;
		private final MonitoringService monitoringService;
		private final ServiceService serviceService;
		private final PolicyRuleConditionValidator policyRuleConditionValidator;
		private final PolicyRuleConditionFieldsGetter policyRuleConditionFieldsGetter;

		@Inject
		public PolicyServiceImpl(
		ContextService contextService,
		MonitoringService monitoringService,
		ServiceService serviceService) {
		ServiceService serviceService,
		PolicyRuleConditionValidator policyRuleConditionValidator,
		PolicyRuleConditionFieldsGetter policyRuleConditionFieldsGetter) {
		this.contextService = contextService;
		this.monitoringService = monitoringService;
		this.serviceService = serviceService;
		this.policyRuleConditionValidator = policyRuleConditionValidator;
		this.policyRuleConditionFieldsGetter = policyRuleConditionFieldsGetter;
		}

		@Override
		public Uni<PolicyRuleState> addPolicyService(PolicyRuleService policyRuleService) {
		LOGGER.infof("Received %s", policyRuleService);

		final var serviceId = policyRuleService.getServiceId();
		final var deviceIds = policyRuleService.getDeviceIds();
		final var policyRuleBasic = policyRuleService.getPolicyRuleBasic();

		final var policyRuleConditions = policyRuleBasic.getPolicyRuleConditions();
		final var kpiIds = policyRuleConditionFieldsGetter.getKpiIds(policyRuleConditions);
		final var kpiValues = policyRuleConditionFieldsGetter.getKpiValues(policyRuleConditions);
		final var numericalOperators =
		policyRuleConditionFieldsGetter.getNumericalOperators(policyRuleConditions);

		final var isServiceIdValid = policyRuleConditionValidator.validateServiceId(serviceId);

		logAndSetPolicyRuleState(INSERTED_POLICYRULE_STATE, policyRuleBasic);
		contextService.setPolicyRule(policyRuleBasic);

		// VALIDATION PHASE
		isServiceIdValid
		.subscribe()
		.with(
		serviceIdBooleanValue -> {
		if (Boolean.FALSE.equals(serviceIdBooleanValue)) {
		LOGGER.errorf(INVALID_MESSAGE, serviceId);
		final var invalidDeviceIds = returnInvalidDeviceIds(deviceIds);

		if (invalidDeviceIds.isEmpty()) {
		LOGGER.info("All Device Ids are valid.");
		}

		logAndSetPolicyRuleState(FAILED_POLICYRULE_STATE, policyRuleBasic);
		} else {
		LOGGER.infof(VALID_MESSAGE, serviceId);

		final var invalidDeviceIds = returnInvalidDeviceIds(deviceIds);

		if (!invalidDeviceIds.isEmpty()) {
		logAndSetPolicyRuleState(FAILED_POLICYRULE_STATE, policyRuleBasic);
		contextService.setPolicyRule(policyRuleBasic);
		} else {
		LOGGER.infof("All deviceIds are valid");
		}

		logAndSetPolicyRuleState(VALIDATED_POLICYRULE_STATE, policyRuleBasic);
		}

		contextService.setPolicyRule(policyRuleBasic);
		});

		// PROVISION PHASE

		final var policyRuleState = new PolicyRuleState(RuleState.POLICY_VALIDATED);

		return Uni.createFrom().item(policyRuleState);
		@@ -56,8 +124,80 @@ public class PolicyServiceImpl implements PolicyService {

		@Override
		public Uni<PolicyRuleState> addPolicyDevice(PolicyRuleDevice policyRuleDevice) {
		LOGGER.infof("Received %s", policyRuleDevice);

		final var policyRuleBasic = policyRuleDevice.getPolicyRuleBasic();
		final var deviceIds = policyRuleDevice.getDeviceIds();

		final var policyRuleConditions = policyRuleBasic.getPolicyRuleConditions();
		final var kpiIds = policyRuleConditionFieldsGetter.getKpiIds(policyRuleConditions);
		final var kpiValues = policyRuleConditionFieldsGetter.getKpiValues(policyRuleConditions);
		final var numericalOperators =
		policyRuleConditionFieldsGetter.getNumericalOperators(policyRuleConditions);

		logAndSetPolicyRuleState(INSERTED_POLICYRULE_STATE, policyRuleBasic);
		contextService.setPolicyRule(policyRuleBasic);

		// VALIDATION PHASE
		final var invalidDeviceIds = returnInvalidDeviceIds(deviceIds);

		if (!invalidDeviceIds.isEmpty()) {
		logAndSetPolicyRuleState(FAILED_POLICYRULE_STATE, policyRuleBasic);
		} else {
		LOGGER.infof("All deviceIds are valid");
		logAndSetPolicyRuleState(VALIDATED_POLICYRULE_STATE, policyRuleBasic);
		}
		contextService.setPolicyRule(policyRuleBasic);

		// PROVISION PHASE

		final var policyRuleState = new PolicyRuleState(RuleState.POLICY_VALIDATED);

		return Uni.createFrom().item(policyRuleState);
		}

		private List<String> returnInvalidDeviceIds(List<String> deviceIds) {
		var invalidDeviceIds = new ArrayList<String>();

		if (!deviceIds.isEmpty()) {

		for (String deviceId : deviceIds) {
		final var validatedDeviceId = policyRuleConditionValidator.validateDeviceId(deviceId);

		validatedDeviceId
		.subscribe()
		.with(
		deviceIdBoolean -> {
		if (Boolean.FALSE.equals(deviceIdBoolean)) {
		invalidDeviceIds.add(deviceId);
		}
		});
		}

		} else {
		LOGGER.warnf("No deviceIds found");
		}

		return invalidDeviceIds;
		}

		private void logAndSetPolicyRuleState(
		PolicyRuleState policyRuleState, PolicyRuleBasic policyRuleBasic) {
		final var POLICY_RULE_STATE_MESSAGE = "Setting Policy Rule state to [%s]";

		if (policyRuleState.getRuleState() == RuleState.POLICY_INSERTED) {
		LOGGER.infof(POLICY_RULE_STATE_MESSAGE, RuleState.POLICY_INSERTED.toString());
		policyRuleBasic.setPolicyRuleState(policyRuleState);
		}

		if (policyRuleState.getRuleState() == RuleState.POLICY_VALIDATED) {
		LOGGER.infof(POLICY_RULE_STATE_MESSAGE, RuleState.POLICY_VALIDATED.toString());
		policyRuleBasic.setPolicyRuleState(policyRuleState);
		}

		if (policyRuleState.getRuleState() == RuleState.POLICY_FAILED) {
		LOGGER.errorf(POLICY_RULE_STATE_MESSAGE, RuleState.POLICY_FAILED.toString());
		policyRuleBasic.setPolicyRuleState(policyRuleState);
		}
		}
		}

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

+77 −27

Original line number	Diff line number	Diff line
		@@ -88,6 +88,7 @@ import eu.teraflow.policy.model.PolicyRuleState;
		import eu.teraflow.policy.model.RuleState;
		import eu.teraflow.policy.monitoring.model.AlarmDescriptor;
		import eu.teraflow.policy.monitoring.model.AlarmResponse;
		import eu.teraflow.policy.monitoring.model.AlarmSubscription;
		import eu.teraflow.policy.monitoring.model.BooleanKpiValue;
		import eu.teraflow.policy.monitoring.model.FloatKpiValue;
		import eu.teraflow.policy.monitoring.model.IntegerKpiValue;
		@@ -1472,12 +1473,12 @@ public class Serializer {
		public Monitoring.KpiValue serializeIntegerKpiValue(KpiValue<Integer> kpiValue) {
		final var builder = Monitoring.KpiValue.newBuilder();

		return builder.setIntVal(kpiValue.getValue()).build();
		return builder.setInt32Val(kpiValue.getValue()).build();
		}

		public int deserializeIntegerKpiValue(Monitoring.KpiValue serializedKpiValue) {

		return serializedKpiValue.getIntVal();
		return serializedKpiValue.getInt32Val();
		}

		public Monitoring.KpiValue serialize(KpiValue<?> kpiValue) {
		@@ -1485,7 +1486,7 @@ public class Serializer {

		if (kpiValue.getValue() instanceof Integer) {
		final var serializedIntegerKpiValue = serializeIntegerKpiValue((KpiValue<Integer>) kpiValue);
		builder.setIntVal(serializedIntegerKpiValue.getIntVal());
		builder.setInt32Val(serializedIntegerKpiValue.getInt32Val());
		}
		if (kpiValue.getValue() instanceof Float) {
		final var serializedFloatKpiValue = serializeFloatKpiValue((KpiValue<Float>) kpiValue);
		@@ -1508,7 +1509,7 @@ public class Serializer {
		final var typeOfKpiValue = serializedKpiValue.getValueCase();

		switch (typeOfKpiValue) {
		case INTVAL:
		case INT32VAL:
		final var intValue = deserializeIntegerKpiValue(serializedKpiValue);
		return new IntegerKpiValue(intValue);
		case BOOLVAL:
		@@ -1569,37 +1570,47 @@ public class Serializer {
		public Monitoring.AlarmDescriptor serialize(AlarmDescriptor alarmDescriptor) {
		final var builder = Monitoring.AlarmDescriptor.newBuilder();

		final var alarmId = alarmDescriptor.getAlarmId();
		final var alarmDescription = alarmDescriptor.getAlarmDescription();
		final var name = alarmDescriptor.getName();
		final var kpiId = alarmDescriptor.getKpiId();
		final var kpiValueRange = alarmDescriptor.getKpiValueRange();
		final var kpiIds = alarmDescriptor.getKpiIds();
		final var kpiValueRanges = alarmDescriptor.getKpiValueRanges();
		final var timestamp = alarmDescriptor.getTimestamp();

		final var serializedKpiIdUuid = serializeUuid(kpiId);
		final var serializedKpiId = KpiId.newBuilder().setKpiId(serializedKpiIdUuid).build();
		final var serializedKpiValueRange = serialize(kpiValueRange);
		final var serializedAlarmId = serializeAlarmId(alarmId);
		final var serializedKpiIds =
		kpiIds.stream().map(this::serializeKpiId).collect(Collectors.toList());
		final var serializedKpiValueRanges =
		kpiValueRanges.stream().map(this::serialize).collect(Collectors.toList());
		final var serializedTimestamp = serialize(timestamp);

		builder.setAlarmId(serializedAlarmId);
		builder.setAlarmDescription(alarmDescription);
		builder.setName(name);
		builder.setKpiId(serializedKpiId);
		builder.setKpiValueRange(serializedKpiValueRange);
		builder.setTimestamp(timestamp);
		builder.addAllKpiId(serializedKpiIds);
		builder.addAllKpiValueRange(serializedKpiValueRanges);
		builder.setTimestamp(serializedTimestamp);

		return builder.build();
		}

		public AlarmDescriptor deserialize(Monitoring.AlarmDescriptor serializedAlarmDescriptor) {

		final var serializedAlarmId = serializedAlarmDescriptor.getAlarmId();
		final var alarmDescription = serializedAlarmDescriptor.getAlarmDescription();
		final var name = serializedAlarmDescriptor.getName();
		final var serializedKpiId = serializedAlarmDescriptor.getKpiId();
		final var serializedKpiValueRange = serializedAlarmDescriptor.getKpiValueRange();
		final var timestamp = serializedAlarmDescriptor.getTimestamp();
		final var serializedKpiIds = serializedAlarmDescriptor.getKpiIdList();
		final var serializedKpiValueRanges = serializedAlarmDescriptor.getKpiValueRangeList();
		final var serializeTimestamp = serializedAlarmDescriptor.getTimestamp();

		final var kpiId = deserialize(serializedKpiId);
		final var kpiValueRange = deserialize(serializedKpiValueRange);
		final var alarmId = deserialize(serializedAlarmId);
		final var kpiIds =
		serializedKpiIds.stream().map(this::deserialize).collect(Collectors.toList());
		final var kpiValueRanges =
		serializedKpiValueRanges.stream().map(this::deserialize).collect(Collectors.toList());
		final var timestamp = deserialize(serializeTimestamp);

		return new AlarmDescriptor(alarmDescription, name, kpiId, kpiValueRange, timestamp);
		return new AlarmDescriptor(alarmId, alarmDescription, name, kpiIds, kpiValueRanges, timestamp);
		}

		public Monitoring.AlarmResponse serialize(AlarmResponse alarmResponse) {
		@@ -1635,34 +1646,44 @@ public class Serializer {
		public Monitoring.SubsDescriptor serialize(SubsDescriptor subDescriptor) {
		final var builder = Monitoring.SubsDescriptor.newBuilder();

		final var subscriptionId = subDescriptor.getSubscriptionId();
		final var kpiId = subDescriptor.getKpiId();
		final var samplingDurationS = subDescriptor.getSamplingDurationS();
		final var samplingIntervalS = subDescriptor.getSamplingIntervalS();
		final var startDate = subDescriptor.getStartDate();
		final var endDate = subDescriptor.getEndDate();
		final var startTimestamp = subDescriptor.getStartTimestamp();
		final var endTimestamp = subDescriptor.getEndTimestamp();

		final var serializedSubscriptionIdUuid = serializeSubscriptionIdId(subscriptionId);
		final var serializedKpiIdUuid = serializeUuid(kpiId);
		final var serializedKpiId = Monitoring.KpiId.newBuilder().setKpiId(serializedKpiIdUuid).build();
		final var serializedStartTimestamp = serialize(startTimestamp);
		final var serializedEndTimestamp = serialize(endTimestamp);

		builder.setSubsId(serializedSubscriptionIdUuid);
		builder.setKpiId(serializedKpiId);
		builder.setSamplingDurationS(samplingDurationS);
		builder.setSamplingIntervalS(samplingIntervalS);
		builder.setStartDate(startDate);
		builder.setEndDate(endDate);
		builder.setStartTimestamp(serializedStartTimestamp);
		builder.setEndTimestamp(serializedEndTimestamp);

		return builder.build();
		}

		public SubsDescriptor deserialize(Monitoring.SubsDescriptor serializedSubDescriptor) {
		final var serializedSubscriptionId = serializedSubDescriptor.getSubsId();
		final var serializedKpiId = serializedSubDescriptor.getKpiId();
		final var samplingDurationS = serializedSubDescriptor.getSamplingDurationS();
		final var samplingIntervalS = serializedSubDescriptor.getSamplingIntervalS();
		final var startDate = serializedSubDescriptor.getStartDate();
		final var endDate = serializedSubDescriptor.getEndDate();
		final var serializedStartTimestamp = serializedSubDescriptor.getStartTimestamp();
		final var serializedEndTimestamp = serializedSubDescriptor.getEndTimestamp();

		final var subscriptionId = deserialize(serializedSubscriptionId);
		final var kpiId = deserialize(serializedKpiId);
		final var startTimestamp = deserialize(serializedStartTimestamp);
		final var endTimestamp = deserialize(serializedEndTimestamp);

		return new SubsDescriptor(kpiId, samplingDurationS, samplingIntervalS, startDate, endDate);
		return new SubsDescriptor(
		subscriptionId, kpiId, samplingDurationS, samplingIntervalS, startTimestamp, endTimestamp);
		}

		public SubscriptionID serializeSubscriptionIdId(String subscriptionId) {
		@@ -1930,10 +1951,11 @@ public class Serializer {
		final var kpiValue = kpi.getKpiValue();

		final var serializedKpiId = serializeKpiId(kpiId);
		final var serializedTimestamp = serialize(timestamp);
		final var serializedKpiValue = serialize(kpiValue);

		builder.setKpiId(serializedKpiId);
		builder.setTimestamp(timestamp);
		builder.setTimestamp(serializedTimestamp);
		builder.setKpiValue(serializedKpiValue);

		return builder.build();
		@@ -1942,10 +1964,11 @@ public class Serializer {
		public Kpi deserialize(Monitoring.Kpi serializedKpi) {

		final var serializedKpiId = serializedKpi.getKpiId();
		final var timestamp = serializedKpi.getTimestamp();
		final var serializedTimestamp = serializedKpi.getTimestamp();
		final var serializedKpiValue = serializedKpi.getKpiValue();

		final var kpiId = deserialize(serializedKpiId);
		final var timestamp = deserialize(serializedTimestamp);
		final var kpiValue = deserialize(serializedKpiValue);

		return new Kpi(kpiId, timestamp, kpiValue);
		@@ -2149,6 +2172,33 @@ public class Serializer {
		return new EndPoint.EndPointBuilder(endPointId, endPointType, kpiSampleTypes).build();
		}

		public Monitoring.AlarmSubscription serialize(AlarmSubscription alarmSubscription) {
		final var builder = Monitoring.AlarmSubscription.newBuilder();

		final var alarmId = alarmSubscription.getAlarmId();
		final var subscriptionTimeoutS = alarmSubscription.getSubscriptionTimeoutS();
		final var subscriptionFrequencyMs = alarmSubscription.getSubscriptionFrequencyMs();

		final var serializedAlarmId = serializeAlarmId(alarmId);

		builder.setAlarmID(serializedAlarmId);
		builder.setSubscriptionTimeoutS(subscriptionTimeoutS);
		builder.setSubscriptionFrequencyMs(subscriptionFrequencyMs);

		return builder.build();
		}

		public AlarmSubscription deserialize(Monitoring.AlarmSubscription serializedAlarmSubscription) {

		final var serializedAlarmId = serializedAlarmSubscription.getAlarmID();
		final var subscriptionTimeoutS = serializedAlarmSubscription.getSubscriptionTimeoutS();
		final var subscriptionFrequencyMs = serializedAlarmSubscription.getSubscriptionFrequencyMs();

		final var alarmId = deserialize(serializedAlarmId);

		return new AlarmSubscription(alarmId, subscriptionTimeoutS, subscriptionFrequencyMs);
		}

		public ContextOuterClass.Device serialize(Device device) {
		final var builder = ContextOuterClass.Device.newBuilder();

src/policy/src/main/java/eu/teraflow/policy/model/PolicyRuleBasic.java

+5 −1

Original line number	Diff line number	Diff line
		@@ -25,7 +25,7 @@ import java.util.List;
		public class PolicyRuleBasic {

		private final String policyRuleId;
		private final PolicyRuleState policyRuleState;
		private PolicyRuleState policyRuleState;
		private final int priority;
		private final List<PolicyRuleCondition> policyRuleConditions;
		private final BooleanOperator booleanOperator;
		@@ -64,6 +64,10 @@ public class PolicyRuleBasic {
		return policyRuleState;
		}

		public void setPolicyRuleState(PolicyRuleState state) {
		this.policyRuleState = state;
		}

		public int getPriority() {
		return priority;
		}

Admin message