Commit 56525965 authored by Fotis Soldatos's avatar Fotis Soldatos
Browse files

Merge branch 'policy/implement-contextService-interface' into 'develop' 

Policy/implement context service interface

See merge request teraflow-h2020/controller!144
parents 007b2e2a d72559b1

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

+178 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ import context.ContextOuterClass.ConfigRule_ACL; 
import context.ContextOuterClass.ConfigRule_Custom;

import context.ContextOuterClass.ContextId;

import context.ContextOuterClass.DeviceId;

import context.ContextOuterClass.DeviceOperationalStatusEnum;

import context.ContextOuterClass.Uuid;

import eu.teraflow.policy.acl.AclAction;

import eu.teraflow.policy.acl.AclEntry;
@@ -51,6 +52,11 @@ import eu.teraflow.policy.context.model.ConstraintTypeSlaAvailability; 
import eu.teraflow.policy.context.model.ConstraintTypeSlaCapacity;

import eu.teraflow.policy.context.model.ConstraintTypeSlaIsolationLevel;

import eu.teraflow.policy.context.model.ConstraintTypeSlaLatency;

import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.DeviceConfig;

import eu.teraflow.policy.context.model.DeviceDriverEnum;

import eu.teraflow.policy.context.model.DeviceOperationalStatus;

import eu.teraflow.policy.context.model.EndPoint;

import eu.teraflow.policy.context.model.EndPointId;

import eu.teraflow.policy.context.model.Event;

import eu.teraflow.policy.context.model.EventTypeEnum;
@@ -1952,6 +1958,178 @@ public class Serializer { 
                sliceId);

    }



    public ContextOuterClass.DeviceConfig serialize(DeviceConfig deviceConfig) {

        final var builder = ContextOuterClass.DeviceConfig.newBuilder();



        final var serializedConfigRules =

                deviceConfig.getConfigRules().stream().map(this::serialize).collect(Collectors.toList());

        builder.addAllConfigRules(serializedConfigRules);



        return builder.build();

    }



    public DeviceConfig deserialize(ContextOuterClass.DeviceConfig deviceConfig) {

        final var configRules =

                deviceConfig.getConfigRulesList().stream()

                        .map(this::deserialize)

                        .collect(Collectors.toList());



        return new DeviceConfig(configRules);

    }



    public ContextOuterClass.DeviceOperationalStatusEnum serialize(DeviceOperationalStatus opStatus) {

        switch (opStatus) {

            case ENABLED:

                return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED;

            case DISABLED:

                return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_DISABLED;

            case UNDEFINED:

            default:

                return DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_UNDEFINED;

        }

    }



    public DeviceOperationalStatus deserialize(

            ContextOuterClass.DeviceOperationalStatusEnum opStatus) {

        switch (opStatus) {

            case DEVICEOPERATIONALSTATUS_ENABLED:

                return DeviceOperationalStatus.ENABLED;

            case DEVICEOPERATIONALSTATUS_DISABLED:

                return DeviceOperationalStatus.DISABLED;

            case DEVICEOPERATIONALSTATUS_UNDEFINED:

            case UNRECOGNIZED:

            default:

                return DeviceOperationalStatus.UNDEFINED;

        }

    }



    public ContextOuterClass.DeviceDriverEnum serialize(DeviceDriverEnum deviceDriverEnum) {

        switch (deviceDriverEnum) {

            case OPENCONFIG:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG;

            case TRANSPORT_API:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_TRANSPORT_API;

            case P4:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_P4;

            case IETF_NETWORK_TOPOLOGY:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_IETF_NETWORK_TOPOLOGY;

            case ONF_TR_352:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_ONF_TR_352;

            case UNDEFINED:

            default:

                return ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_UNDEFINED;

        }

    }



    public DeviceDriverEnum deserialize(

            ContextOuterClass.DeviceDriverEnum serializedDeviceDriverEnum) {

        switch (serializedDeviceDriverEnum) {

            case DEVICEDRIVER_OPENCONFIG:

                return DeviceDriverEnum.OPENCONFIG;

            case DEVICEDRIVER_TRANSPORT_API:

                return DeviceDriverEnum.TRANSPORT_API;

            case DEVICEDRIVER_P4:

                return DeviceDriverEnum.P4;

            case DEVICEDRIVER_IETF_NETWORK_TOPOLOGY:

                return DeviceDriverEnum.IETF_NETWORK_TOPOLOGY;

            case DEVICEDRIVER_ONF_TR_352:

                return DeviceDriverEnum.ONF_TR_352;

            case DEVICEDRIVER_UNDEFINED:

            case UNRECOGNIZED:

            default:

                return DeviceDriverEnum.UNDEFINED;

        }

    }



    public ContextOuterClass.EndPoint serialize(EndPoint endPoint) {

        final var builder = ContextOuterClass.EndPoint.newBuilder();



        final var endPointId = endPoint.getEndPointId();

        final var endPointType = endPoint.getEndPointType();

        final var kpiSampleTypes = endPoint.getKpiSampleTypes();

        final var endPointLocation = endPoint.getEndPointLocation();



        final var serializedEndPointId = serialize(endPointId);

        final var serializedKpiSampleTypes =

                kpiSampleTypes.stream().map(this::serialize).collect(Collectors.toList());

        final var serializedEndPointLocation = serialize(endPointLocation);



        builder.setEndpointId(serializedEndPointId);

        builder.setEndpointType(endPointType);

        builder.addAllKpiSampleTypes(serializedKpiSampleTypes);

        builder.setEndpointLocation(serializedEndPointLocation);



        return builder.build();

    }



    public EndPoint deserialize(ContextOuterClass.EndPoint serializedEndPoint) {

        final var serializedEndPointId = serializedEndPoint.getEndpointId();

        final var endPointType = serializedEndPoint.getEndpointType();

        final var serializedKpiSampleTypes = serializedEndPoint.getKpiSampleTypesList();

        final var serializedEndPointLocation = serializedEndPoint.getEndpointLocation();



        final var endPointId = deserialize(serializedEndPointId);

        final var kpiSampleTypes =

                serializedKpiSampleTypes.stream().map(this::deserialize).collect(Collectors.toList());

        final var endPointLocation = deserialize(serializedEndPointLocation);



        return new EndPoint(endPointId, endPointType, kpiSampleTypes, endPointLocation);

    }



    public ContextOuterClass.Device serialize(Device device) {

        final var builder = ContextOuterClass.Device.newBuilder();



        final var deviceIdUuid = serializeUuid(device.getDeviceId());

        final var deviceId = DeviceId.newBuilder().setDeviceUuid(deviceIdUuid);

        final var deviceType = device.getDeviceType();

        final var deviceConfig = device.getDeviceConfig();

        final var deviceOperationalStatus = device.getDeviceOperationalStatus();

        final var deviceDrivers = device.getDeviceDrivers();

        final var deviceEndPoints = device.getEndPoints();



        final var serializedDeviceConfig = serialize(deviceConfig);

        final var serializedDeviceOperationalStatus = serialize(deviceOperationalStatus);

        final var serializedDeviceDrivers =

                deviceDrivers.stream().map(this::serialize).collect(Collectors.toList());

        final var serializedDeviceEndPoints =

                deviceEndPoints.stream().map(this::serialize).collect(Collectors.toList());



        builder.setDeviceId(deviceId);

        builder.setDeviceType(deviceType);

        builder.setDeviceConfig(serializedDeviceConfig);

        builder.setDeviceOperationalStatus(serializedDeviceOperationalStatus);

        builder.addAllDeviceDrivers(serializedDeviceDrivers);

        builder.addAllDeviceEndpoints(serializedDeviceEndPoints);



        return builder.build();

    }



    public Device deserialize(ContextOuterClass.Device device) {



        final var serializedDeviceId = device.getDeviceId();

        final var deviceType = device.getDeviceType();

        final var serializedDeviceConfig = device.getDeviceConfig();

        final var serializedDeviceOperationalStatus = device.getDeviceOperationalStatus();

        final var serializedDeviceDrivers = device.getDeviceDriversList();

        final var serializedDeviceEndPoints = device.getDeviceEndpointsList();



        final var deviceId = deserialize(serializedDeviceId);

        final var deviceConfig = deserialize(serializedDeviceConfig);

        final var deviceOperationalStatus = deserialize(serializedDeviceOperationalStatus);

        final var deviceDrivers =

                serializedDeviceDrivers.stream().map(this::deserialize).collect(Collectors.toList());

        final var deviceEndPoints =

                serializedDeviceEndPoints.stream().map(this::deserialize).collect(Collectors.toList());



        return new Device(

                deviceId,

                deviceType,

                deviceConfig,

                deviceOperationalStatus,

                deviceDrivers,

                deviceEndPoints);

    }



    public Uuid serializeUuid(String uuid) {

        return Uuid.newBuilder().setUuid(uuid).build();

    }

src/policy/src/main/java/eu/teraflow/policy/context/ContextGateway.java

0 → 100644
+38 −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.context;



import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.Service;

import eu.teraflow.policy.context.model.ServiceId;

import eu.teraflow.policy.model.PolicyRuleBasic;

import io.smallrye.mutiny.Uni;



public interface ContextGateway {



    // Context related methods

    Uni<Service> getService(ServiceId serviceId);



    Uni<ServiceId> setService(Service service);



    Uni<Device> getDevice(String deviceId);



    // Context-policy related methods

    Uni<PolicyRuleBasic> getPolicyRule(String policyRuleId);



    Uni<String> setPolicyRule(PolicyRuleBasic policyRuleBasic);

}

src/policy/src/main/java/eu/teraflow/policy/context/ContextGatewayImpl.java

0 → 100644
+99 −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.context;



import context.MutinyContextServiceGrpc.MutinyContextServiceStub;

import context_policy.MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub;

import eu.teraflow.policy.Serializer;

import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.Service;

import eu.teraflow.policy.context.model.ServiceId;

import eu.teraflow.policy.model.PolicyRuleBasic;

import io.quarkus.grpc.GrpcClient;

import io.smallrye.mutiny.Uni;

import javax.enterprise.context.ApplicationScoped;

import javax.inject.Inject;



@ApplicationScoped

public class ContextGatewayImpl implements ContextGateway {



    @GrpcClient("context")

    MutinyContextServiceStub streamingDelegateContext;



    // TODO remove client when RPCs declared in context-policy.proto are moved in context.proto

    //  and use streamingDelegateContext for all methods

    @GrpcClient("context_policy")

    MutinyContextPolicyServiceStub streamingDelegateContextPolicy;



    private final Serializer serializer;



    @Inject

    public ContextGatewayImpl(Serializer serializer) {

        this.serializer = serializer;

    }



    @Override

    public Uni<Service> getService(ServiceId serviceId) {



        final var serializedServiceId = serializer.serialize(serviceId);



        return streamingDelegateContext

                .getService(serializedServiceId)

                .onItem()

                .transform(serializer::deserialize);

    }



    @Override

    public Uni<ServiceId> setService(Service service) {

        final var serializedService = serializer.serialize(service);



        return streamingDelegateContext

                .setService(serializedService)

                .onItem()

                .transform(serializer::deserialize);

    }



    @Override

    public Uni<Device> getDevice(String deviceId) {

        final var serializedDeviceId = serializer.serializeDeviceId(deviceId);



        return streamingDelegateContext

                .getDevice(serializedDeviceId)

                .onItem()

                .transform(serializer::deserialize);

    }



    @Override

    public Uni<PolicyRuleBasic> getPolicyRule(String policyRuleId) {

        final var serializedPolicyRuleId = serializer.serializePolicyRuleId(policyRuleId);



        return streamingDelegateContextPolicy

                .getPolicyRule(serializedPolicyRuleId)

                .onItem()

                .transform(serializer::deserialize);

    }



    @Override

    public Uni<String> setPolicyRule(PolicyRuleBasic policyRuleBasic) {

        final var serializedPolicyRuleBasic = serializer.serialize(policyRuleBasic);



        return streamingDelegateContextPolicy

                .setPolicyRule(serializedPolicyRuleBasic)

                .onItem()

                .transform(serializer::deserialize);

    }

}

src/policy/src/main/java/eu/teraflow/policy/context/ContextService.java

+18 −1
Original line number Diff line number Diff line
@@ -16,4 +16,21 @@ 


package eu.teraflow.policy.context;



public interface ContextService {}
 
import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.Service;

import eu.teraflow.policy.context.model.ServiceId;

import eu.teraflow.policy.model.PolicyRuleBasic;

import io.smallrye.mutiny.Uni;



public interface ContextService {



    Uni<Service> getService(ServiceId serviceId);



    Uni<ServiceId> setService(Service service);



    Uni<Device> getDevice(String deviceId);



    Uni<PolicyRuleBasic> getPolicyRule(String policyRuleId);



    Uni<String> setPolicyRule(PolicyRuleBasic policyRuleBasic);

}

src/policy/src/main/java/eu/teraflow/policy/context/ContextServiceImpl.java

0 → 100644
+61 −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.context;



import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.Service;

import eu.teraflow.policy.context.model.ServiceId;

import eu.teraflow.policy.model.PolicyRuleBasic;

import io.smallrye.mutiny.Uni;

import javax.enterprise.context.ApplicationScoped;

import javax.inject.Inject;



@ApplicationScoped

public class ContextServiceImpl implements ContextService {



    private final ContextGateway contextGateway;



    @Inject

    public ContextServiceImpl(ContextGateway contextGateway) {

        this.contextGateway = contextGateway;

    }



    @Override

    public Uni<Service> getService(ServiceId serviceId) {

        return contextGateway.getService(serviceId);

    }



    @Override

    public Uni<ServiceId> setService(Service service) {

        return contextGateway.setService(service);

    }



    @Override

    public Uni<Device> getDevice(String deviceId) {

        return contextGateway.getDevice(deviceId);

    }



    @Override

    public Uni<PolicyRuleBasic> getPolicyRule(String policyRuleId) {

        return contextGateway.getPolicyRule(policyRuleId);

    }



    @Override

    public Uni<String> setPolicyRule(PolicyRuleBasic policyRuleBasic) {

        return contextGateway.setPolicyRule(policyRuleBasic);

    }

}