Commit de07e72e authored by Vasilis Katopodis's avatar Vasilis Katopodis
Browse files

Merge branch 'policy/implement-conditional-part-of-PolicyAddService-rpc' into 'develop' 

refactor(policy): integrate monitoring protobuf updates

See merge request teraflow-h2020/controller!167
parents ee3bfcf3 d9e45eaa

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;

    }