diff --git a/src/policy/src/main/java/eu/teraflow/policy/Serializer.java b/src/policy/src/main/java/eu/teraflow/policy/Serializer.java
index f794d8bafa402bc0dbe3296034bc235f30d9c969..9970852124fb0a5334087ef703a6b0fb5b3ef9a8 100644
--- a/src/policy/src/main/java/eu/teraflow/policy/Serializer.java
+++ b/src/policy/src/main/java/eu/teraflow/policy/Serializer.java
@@ -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();
}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/ContextGateway.java b/src/policy/src/main/java/eu/teraflow/policy/context/ContextGateway.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f1c2446aeeec7e2dc62d8732187255df8c477a1
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/ContextGateway.java
@@ -0,0 +1,38 @@
+/*
+* 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);
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/ContextGatewayImpl.java b/src/policy/src/main/java/eu/teraflow/policy/context/ContextGatewayImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..3af300d4914ef589d380c32a3389383c5dd37c0d
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/ContextGatewayImpl.java
@@ -0,0 +1,99 @@
+/*
+* 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);
+ }
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/ContextService.java b/src/policy/src/main/java/eu/teraflow/policy/context/ContextService.java
index 4d2b317cb3e76b043f919fa7112147a6bda8697e..133318a05bad7f8a2fd4b7d2ae423e1375d34287 100644
--- a/src/policy/src/main/java/eu/teraflow/policy/context/ContextService.java
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/ContextService.java
@@ -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);
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/ContextServiceImpl.java b/src/policy/src/main/java/eu/teraflow/policy/context/ContextServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb5c8d61bd5f73375b531f43bcfb744dc5bf2c20
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/ContextServiceImpl.java
@@ -0,0 +1,61 @@
+/*
+* 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);
+ }
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/model/Device.java b/src/policy/src/main/java/eu/teraflow/policy/context/model/Device.java
new file mode 100644
index 0000000000000000000000000000000000000000..b00fd235cbcd2c65606d357646fa41bd10716569
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/model/Device.java
@@ -0,0 +1,83 @@
+/*
+* 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.model;
+
+import eu.teraflow.policy.common.Util;
+import java.util.List;
+
+public class Device {
+
+ private final String deviceId;
+ private final String deviceType;
+ private DeviceConfig deviceConfig;
+ private DeviceOperationalStatus deviceOperationalStatus;
+ private List<DeviceDriverEnum> deviceDrivers;
+ private List<EndPoint> endPoints;
+
+ public Device(
+ String deviceId,
+ String deviceType,
+ DeviceConfig deviceConfig,
+ DeviceOperationalStatus deviceOperationalStatus,
+ List<DeviceDriverEnum> deviceDrivers,
+ List<EndPoint> endPoints) {
+
+ this.deviceId = deviceId;
+ this.deviceType = deviceType;
+ this.deviceConfig = deviceConfig;
+ this.deviceOperationalStatus = deviceOperationalStatus;
+ this.deviceDrivers = deviceDrivers;
+ this.endPoints = endPoints;
+ }
+
+ public String getDeviceId() {
+ return deviceId;
+ }
+
+ public String getDeviceType() {
+ return deviceType;
+ }
+
+ public DeviceConfig getDeviceConfig() {
+ return deviceConfig;
+ }
+
+ public DeviceOperationalStatus getDeviceOperationalStatus() {
+ return deviceOperationalStatus;
+ }
+
+ public List<DeviceDriverEnum> getDeviceDrivers() {
+ return deviceDrivers;
+ }
+
+ public List<EndPoint> getEndPoints() {
+ return endPoints;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "%s:{deviceId:\"%s\", deviceType:\"%s\", %s, deviceOperationalStatus=\"%s\", [%s], [%s]}",
+ getClass().getSimpleName(),
+ deviceId,
+ deviceType,
+ deviceConfig,
+ deviceOperationalStatus.toString(),
+ Util.toString(deviceDrivers),
+ Util.toString(endPoints));
+ }
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceConfig.java b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6fa702dd66c9ee315856f08cb85910b4da78ce1
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceConfig.java
@@ -0,0 +1,39 @@
+/*
+* 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.model;
+
+import eu.teraflow.policy.common.Util;
+import java.util.List;
+
+public class DeviceConfig {
+
+ private final List<ConfigRule> configRules;
+
+ public DeviceConfig(List<ConfigRule> configRules) {
+
+ this.configRules = configRules;
+ }
+
+ public List<ConfigRule> getConfigRules() {
+ return configRules;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("%s:{[%s]}", getClass().getSimpleName(), Util.toString(configRules));
+ }
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceDriverEnum.java b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceDriverEnum.java
new file mode 100644
index 0000000000000000000000000000000000000000..c98fc1fce545974a8067db2667ec1e519a058ae2
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceDriverEnum.java
@@ -0,0 +1,26 @@
+/*
+* 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.model;
+
+public enum DeviceDriverEnum {
+ UNDEFINED,
+ OPENCONFIG,
+ TRANSPORT_API,
+ P4,
+ IETF_NETWORK_TOPOLOGY,
+ ONF_TR_352
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceOperationalStatus.java b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceOperationalStatus.java
new file mode 100644
index 0000000000000000000000000000000000000000..2efe9052ec96decc74bd1f5a254fd32bca88a9e8
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceOperationalStatus.java
@@ -0,0 +1,23 @@
+/*
+* 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.model;
+
+public enum DeviceOperationalStatus {
+ UNDEFINED,
+ DISABLED,
+ ENABLED
+}
diff --git a/src/policy/src/main/java/eu/teraflow/policy/context/model/EndPoint.java b/src/policy/src/main/java/eu/teraflow/policy/context/model/EndPoint.java
new file mode 100644
index 0000000000000000000000000000000000000000..a657b59218598c375cfe272f6d3dc1b2ed5bdd04
--- /dev/null
+++ b/src/policy/src/main/java/eu/teraflow/policy/context/model/EndPoint.java
@@ -0,0 +1,66 @@
+/*
+* 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.model;
+
+import eu.teraflow.policy.common.Util;
+import eu.teraflow.policy.kpi_sample_types.model.KpiSampleType;
+import java.util.List;
+
+public class EndPoint {
+ private final EndPointId endPointId;
+ private final String endPointType;
+ private final List<KpiSampleType> kpiSampleTypes;
+ private final Location endPointLocation;
+
+ public EndPoint(
+ EndPointId endPointId,
+ String endPointType,
+ List<KpiSampleType> kpiSampleTypes,
+ Location endPointLocation) {
+ this.endPointId = endPointId;
+ this.endPointType = endPointType;
+ this.kpiSampleTypes = kpiSampleTypes;
+ this.endPointLocation = endPointLocation;
+ }
+
+ public EndPointId getEndPointId() {
+ return endPointId;
+ }
+
+ public String getEndPointType() {
+ return endPointType;
+ }
+
+ public List<KpiSampleType> getKpiSampleTypes() {
+ return kpiSampleTypes;
+ }
+
+ public Location getEndPointLocation() {
+ return endPointLocation;
+ }
+
+ @Override
+ public String toString() {
+ return String.format(
+ "%s:{%s, endPointType:\"%s\", [%s], %s}",
+ getClass().getSimpleName(),
+ endPointId,
+ endPointType,
+ Util.toString(kpiSampleTypes),
+ endPointLocation);
+ }
+}
diff --git a/src/policy/src/main/proto/context-policy.proto b/src/policy/src/main/proto/context-policy.proto
new file mode 120000
index 0000000000000000000000000000000000000000..5c0888e9edf15c8fa540e85afabb98342c0e0c51
--- /dev/null
+++ b/src/policy/src/main/proto/context-policy.proto
@@ -0,0 +1 @@
+../../../../../proto/context-policy.proto
\ No newline at end of file
diff --git a/src/policy/src/test/java/eu/teraflow/policy/SerializerTest.java b/src/policy/src/test/java/eu/teraflow/policy/SerializerTest.java
index 49aa004be4e225262d89db5fff8f30b911fce93b..e8c582013366c993992ff3fd504bb9b2c7578c17 100644
--- a/src/policy/src/test/java/eu/teraflow/policy/SerializerTest.java
+++ b/src/policy/src/test/java/eu/teraflow/policy/SerializerTest.java
@@ -23,6 +23,7 @@ import acl.Acl;
import context.ContextOuterClass;
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;
@@ -52,6 +53,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;
@@ -3169,6 +3175,412 @@ class SerializerTest {
assertThat(kpiDescriptor).usingRecursiveComparison().isEqualTo(expectedKpiDescriptor);
}
+ @Test
+ void shouldSerializeDeviceConfig() {
+ final var expectedConfigRuleCustomA =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyA")
+ .setResourceValue("resourceValueA")
+ .build();
+
+ final var configRuleCustomA = new ConfigRuleCustom("resourceKeyA", "resourceValueA");
+
+ final var expectedConfigRuleCustomB =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyB")
+ .setResourceValue("resourceValueB")
+ .build();
+
+ final var configRuleCustomB = new ConfigRuleCustom("resourceKeyB", "resourceValueB");
+
+ final var expectedConfigRuleA =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_SET)
+ .setCustom(expectedConfigRuleCustomA)
+ .build();
+ final var expectedConfigRuleB =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_DELETE)
+ .setCustom(expectedConfigRuleCustomB)
+ .build();
+
+ final var expectedDeviceConfig =
+ ContextOuterClass.DeviceConfig.newBuilder()
+ .addAllConfigRules(List.of(expectedConfigRuleA, expectedConfigRuleB))
+ .build();
+
+ final var configRuleTypeA = new ConfigRuleTypeCustom(configRuleCustomA);
+ final var configRuleTypeB = new ConfigRuleTypeCustom(configRuleCustomB);
+
+ final var configRuleA = new ConfigRule(ConfigActionEnum.SET, configRuleTypeA);
+ final var configRuleB = new ConfigRule(ConfigActionEnum.DELETE, configRuleTypeB);
+
+ final var deviceConfig = new DeviceConfig(List.of(configRuleA, configRuleB));
+ final var serializedDeviceConfig = serializer.serialize(deviceConfig);
+
+ assertThat(serializedDeviceConfig).isEqualTo(expectedDeviceConfig);
+ }
+
+ @Test
+ void shouldDeserializeDeviceConfig() {
+ final var expectedConfigRuleCustomA = new ConfigRuleCustom("resourceKeyA", "resourceValueA");
+ final var expectedConfigRuleCustomB = new ConfigRuleCustom("resourceKeyB", "resourceValueB");
+
+ final var expectedConfigRuleTypeA = new ConfigRuleTypeCustom(expectedConfigRuleCustomA);
+ final var expectedConfigRuleTypeB = new ConfigRuleTypeCustom(expectedConfigRuleCustomB);
+
+ final var expectedConfigRuleA = new ConfigRule(ConfigActionEnum.SET, expectedConfigRuleTypeA);
+ final var expectedConfigRuleB =
+ new ConfigRule(ConfigActionEnum.DELETE, expectedConfigRuleTypeB);
+
+ final var expectedDeviceConfig =
+ new DeviceConfig(List.of(expectedConfigRuleA, expectedConfigRuleB));
+
+ final var configRuleCustomA =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyA")
+ .setResourceValue("resourceValueA")
+ .build();
+
+ final var configRuleCustomB =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyB")
+ .setResourceValue("resourceValueB")
+ .build();
+
+ final var configRuleA =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_SET)
+ .setCustom(configRuleCustomA)
+ .build();
+ final var configRuleB =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_DELETE)
+ .setCustom(configRuleCustomB)
+ .build();
+ final var serializedDeviceConfig =
+ ContextOuterClass.DeviceConfig.newBuilder()
+ .addAllConfigRules(List.of(configRuleA, configRuleB))
+ .build();
+ final var deviceConfig = serializer.deserialize(serializedDeviceConfig);
+
+ assertThat(deviceConfig).usingRecursiveComparison().isEqualTo(expectedDeviceConfig);
+ }
+
+ private static Stream<Arguments> provideOperationalStatusEnum() {
+ return Stream.of(
+ Arguments.of(
+ DeviceOperationalStatus.ENABLED,
+ DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED),
+ Arguments.of(
+ DeviceOperationalStatus.DISABLED,
+ DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_DISABLED),
+ Arguments.of(
+ DeviceOperationalStatus.UNDEFINED,
+ DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_UNDEFINED));
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideOperationalStatusEnum")
+ void shouldSerializeOperationalStatusEnum(
+ DeviceOperationalStatus opStatus,
+ ContextOuterClass.DeviceOperationalStatusEnum expectedOpStatus) {
+ final var serializedOpStatus = serializer.serialize(opStatus);
+ assertThat(serializedOpStatus.getNumber()).isEqualTo(expectedOpStatus.getNumber());
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideOperationalStatusEnum")
+ void shouldDeserializeOperationalStatusEnum(
+ DeviceOperationalStatus expectedOpStatus,
+ ContextOuterClass.DeviceOperationalStatusEnum serializedOpStatus) {
+ final var operationalStatus = serializer.deserialize(serializedOpStatus);
+ assertThat(operationalStatus).isEqualTo(expectedOpStatus);
+ }
+
+ private static Stream<Arguments> provideDeviceDriverEnum() {
+ return Stream.of(
+ Arguments.of(
+ DeviceDriverEnum.OPENCONFIG,
+ ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG),
+ Arguments.of(
+ DeviceDriverEnum.TRANSPORT_API,
+ ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_TRANSPORT_API),
+ Arguments.of(DeviceDriverEnum.P4, ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_P4),
+ Arguments.of(
+ DeviceDriverEnum.IETF_NETWORK_TOPOLOGY,
+ ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_IETF_NETWORK_TOPOLOGY),
+ Arguments.of(
+ DeviceDriverEnum.ONF_TR_352,
+ ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_ONF_TR_352),
+ Arguments.of(
+ DeviceDriverEnum.UNDEFINED, ContextOuterClass.DeviceDriverEnum.DEVICEDRIVER_UNDEFINED));
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideDeviceDriverEnum")
+ void shouldSerializeDeviceDriverEnum(
+ DeviceDriverEnum deviceDriverEnum,
+ ContextOuterClass.DeviceDriverEnum expectedDeviceDriverEnum) {
+ final var serializedDeviceDriverEnum = serializer.serialize(deviceDriverEnum);
+
+ assertThat(serializedDeviceDriverEnum.getNumber())
+ .isEqualTo(expectedDeviceDriverEnum.getNumber());
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideDeviceDriverEnum")
+ void shouldDeserializeDeviceDriverEnum(
+ DeviceDriverEnum expectedDeviceDriverEnum,
+ ContextOuterClass.DeviceDriverEnum serializedDeviceDriverEnum) {
+ final var deviceDriverEnum = serializer.deserialize(serializedDeviceDriverEnum);
+
+ assertThat(deviceDriverEnum).isEqualTo(expectedDeviceDriverEnum);
+ }
+
+ @Test
+ void shouldSerializeEndPoint() {
+ final var expectedTopologyId = new TopologyId("contextId", "id");
+ final var expectedDeviceId = "expectedDeviceId";
+ final var expectedId = "expectedId";
+ final var endPointId = new EndPointId(expectedTopologyId, expectedDeviceId, expectedId);
+ final var endPointType = "endPointType";
+ final var kpiSampleTypes =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+
+ final var locationTypeRegion = new LocationTypeRegion("ATH");
+ final var location = new Location(locationTypeRegion);
+
+ final var endPoint = new EndPoint(endPointId, endPointType, kpiSampleTypes, location);
+
+ final var serializedEndPointId = serializer.serialize(endPointId);
+ final var serializedKpiSampleTypes =
+ kpiSampleTypes.stream()
+ .map(kpiSampleType -> serializer.serialize(kpiSampleType))
+ .collect(Collectors.toList());
+ final var serializedLocation = serializer.serialize(location);
+
+ final var expectedEndPoint =
+ ContextOuterClass.EndPoint.newBuilder()
+ .setEndpointId(serializedEndPointId)
+ .setEndpointType(endPointType)
+ .addAllKpiSampleTypes(serializedKpiSampleTypes)
+ .setEndpointLocation(serializedLocation)
+ .build();
+
+ final var serializedEndPoint = serializer.serialize(endPoint);
+
+ assertThat(serializedEndPoint).usingRecursiveComparison().isEqualTo(expectedEndPoint);
+ }
+
+ @Test
+ void shouldDeserializeEndPoint() {
+ final var expectedTopologyId = new TopologyId("contextId", "id");
+ final var expectedDeviceId = "expectedDeviceId";
+ final var expectedId = "expectedId";
+ final var expectedEndPointId = new EndPointId(expectedTopologyId, expectedDeviceId, expectedId);
+ final var expectedEndPointType = "expectedEndPointType";
+ final var expectedKpiSampleTypes =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+
+ final var expectedLocationTypeRegion = new LocationTypeRegion("ATH");
+ final var expectedLocation = new Location(expectedLocationTypeRegion);
+
+ final var expectedEndPoint =
+ new EndPoint(
+ expectedEndPointId, expectedEndPointType, expectedKpiSampleTypes, expectedLocation);
+
+ final var serializedEndPointId = serializer.serialize(expectedEndPointId);
+ final var serializedKpiSampleTypes =
+ expectedKpiSampleTypes.stream()
+ .map(kpiSampleType -> serializer.serialize(kpiSampleType))
+ .collect(Collectors.toList());
+ final var serializedLocation = serializer.serialize(expectedLocation);
+
+ final var serializedEndPoint =
+ ContextOuterClass.EndPoint.newBuilder()
+ .setEndpointId(serializedEndPointId)
+ .setEndpointType(expectedEndPointType)
+ .addAllKpiSampleTypes(serializedKpiSampleTypes)
+ .setEndpointLocation(serializedLocation)
+ .build();
+
+ final var endPoint = serializer.deserialize(serializedEndPoint);
+
+ assertThat(endPoint).usingRecursiveComparison().isEqualTo(expectedEndPoint);
+ }
+
+ @Test
+ void shouldSerializeDevice() {
+ final var expectedConfigRuleCustomA =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyA")
+ .setResourceValue("resourceValueA")
+ .build();
+ final var configRuleCustomA = new ConfigRuleCustom("resourceKeyA", "resourceValueA");
+
+ final var expectedConfigRule =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_SET)
+ .setCustom(expectedConfigRuleCustomA)
+ .build();
+
+ final var configRuleTypeA = new ConfigRuleTypeCustom(configRuleCustomA);
+ final var deviceConfig =
+ new DeviceConfig(List.of(new ConfigRule(ConfigActionEnum.SET, configRuleTypeA)));
+
+ final var deviceDrivers = List.of(DeviceDriverEnum.IETF_NETWORK_TOPOLOGY, DeviceDriverEnum.P4);
+
+ final var expectedTopologyIdA = new TopologyId("contextIdA", "idA");
+ final var expectedDeviceIdA = "expectedDeviceIdA";
+ final var expectedIdA = "expectedIdA";
+ final var endPointIdA = new EndPointId(expectedTopologyIdA, expectedDeviceIdA, expectedIdA);
+
+ final var endPointTypeA = "endPointTypeA";
+ final var kpiSampleTypesA =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+ final var locationTypeRegionA = new LocationTypeRegion("ATH");
+ final var locationA = new Location(locationTypeRegionA);
+ final var endPointA = new EndPoint(endPointIdA, endPointTypeA, kpiSampleTypesA, locationA);
+
+ final var expectedTopologyIdB = new TopologyId("contextIdB", "idB");
+ final var expectedDeviceIdB = "expectedDeviceIdB";
+ final var expectedIdB = "expectedIdB";
+ final var endPointIdB = new EndPointId(expectedTopologyIdB, expectedDeviceIdB, expectedIdB);
+
+ final var endPointTypeB = "endPointTypeB";
+ final var kpiSampleTypesB =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+ final var locationTypeRegionB = new LocationTypeRegion("ATH");
+ final var locationB = new Location(locationTypeRegionB);
+ final var endPointB = new EndPoint(endPointIdB, endPointTypeB, kpiSampleTypesB, locationB);
+
+ final var endPoints = List.of(endPointA, endPointB);
+
+ final var expectedDeviceConfig =
+ ContextOuterClass.DeviceConfig.newBuilder().addConfigRules(expectedConfigRule).build();
+
+ final var serializedDeviceId = serializer.serializeDeviceId("deviceId");
+ final var serializedDrivers =
+ deviceDrivers.stream()
+ .map(deviceDriverEnum -> serializer.serialize(deviceDriverEnum))
+ .collect(Collectors.toList());
+
+ final var serializedEndPoints =
+ endPoints.stream()
+ .map(endPoint -> serializer.serialize(endPoint))
+ .collect(Collectors.toList());
+
+ final var deviceBuilder = ContextOuterClass.Device.newBuilder();
+
+ deviceBuilder.setDeviceId(serializedDeviceId);
+ deviceBuilder.setDeviceType("deviceType");
+ deviceBuilder.setDeviceConfig(expectedDeviceConfig);
+ deviceBuilder.setDeviceOperationalStatus(serializer.serialize(DeviceOperationalStatus.ENABLED));
+ deviceBuilder.addAllDeviceDrivers(serializedDrivers);
+ deviceBuilder.addAllDeviceEndpoints(serializedEndPoints);
+
+ final var expectedDevice = deviceBuilder.build();
+
+ final var device =
+ new Device(
+ "deviceId",
+ "deviceType",
+ deviceConfig,
+ DeviceOperationalStatus.ENABLED,
+ deviceDrivers,
+ endPoints);
+ final var serializedDevice = serializer.serialize(device);
+
+ assertThat(serializedDevice).isEqualTo(expectedDevice);
+ }
+
+ @Test
+ void shouldDeserializeDevice() {
+ final var configRuleCustom = new ConfigRuleCustom("resourceKeyA", "resourceValueA");
+ final var expectedConfigRuleCustom =
+ ContextOuterClass.ConfigRule_Custom.newBuilder()
+ .setResourceKey("resourceKeyA")
+ .setResourceValue("resourceValueA")
+ .build();
+ final var configRuleType = new ConfigRuleTypeCustom(configRuleCustom);
+
+ final var expectedConfig =
+ new DeviceConfig(List.of(new ConfigRule(ConfigActionEnum.DELETE, configRuleType)));
+
+ final var deviceDrivers = List.of(DeviceDriverEnum.IETF_NETWORK_TOPOLOGY, DeviceDriverEnum.P4);
+
+ final var expectedTopologyIdA = new TopologyId("contextIdA", "idA");
+ final var expectedDeviceIdA = "expectedDeviceIdA";
+ final var expectedIdA = "expectedIdA";
+ final var endPointIdA = new EndPointId(expectedTopologyIdA, expectedDeviceIdA, expectedIdA);
+
+ final var endPointTypeA = "endPointTypeA";
+ final var kpiSampleTypesA =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+ final var locationTypeRegionA = new LocationTypeRegion("ATH");
+ final var locationA = new Location(locationTypeRegionA);
+ final var endPointA = new EndPoint(endPointIdA, endPointTypeA, kpiSampleTypesA, locationA);
+
+ final var expectedTopologyIdB = new TopologyId("contextIdB", "idB");
+ final var expectedDeviceIdB = "expectedDeviceIdB";
+ final var expectedIdB = "expectedIdB";
+ final var endPointIdB = new EndPointId(expectedTopologyIdB, expectedDeviceIdB, expectedIdB);
+
+ final var endPointTypeB = "endPointTypeB";
+ final var kpiSampleTypesB =
+ List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);
+ final var locationTypeRegionB = new LocationTypeRegion("ATH");
+ final var locationB = new Location(locationTypeRegionB);
+ final var endPointB = new EndPoint(endPointIdB, endPointTypeB, kpiSampleTypesB, locationB);
+
+ final var endPoints = List.of(endPointA, endPointB);
+
+ final var expectedDevice =
+ new Device(
+ "deviceId",
+ "deviceType",
+ expectedConfig,
+ DeviceOperationalStatus.ENABLED,
+ deviceDrivers,
+ endPoints);
+
+ final var configRule =
+ ContextOuterClass.ConfigRule.newBuilder()
+ .setAction(ContextOuterClass.ConfigActionEnum.CONFIGACTION_DELETE)
+ .setCustom(expectedConfigRuleCustom)
+ .build();
+ final var deviceConfig =
+ ContextOuterClass.DeviceConfig.newBuilder().addConfigRules(configRule).build();
+
+ final var serializedDeviceId = serializer.serializeDeviceId("deviceId");
+ final var serializedDeviceOperationalStatus =
+ serializer.serialize(DeviceOperationalStatus.ENABLED);
+
+ final var serializedDrivers =
+ deviceDrivers.stream()
+ .map(deviceDriverEnum -> serializer.serialize(deviceDriverEnum))
+ .collect(Collectors.toList());
+
+ final var serializedEndPoints =
+ endPoints.stream()
+ .map(endPoint -> serializer.serialize(endPoint))
+ .collect(Collectors.toList());
+
+ final var deviceBuilder = ContextOuterClass.Device.newBuilder();
+ deviceBuilder.setDeviceId(serializedDeviceId);
+ deviceBuilder.setDeviceType("deviceType");
+ deviceBuilder.setDeviceConfig(deviceConfig);
+ deviceBuilder.setDeviceOperationalStatus(serializedDeviceOperationalStatus);
+ deviceBuilder.addAllDeviceDrivers(serializedDrivers);
+ deviceBuilder.addAllDeviceEndpoints(serializedEndPoints);
+
+ final var serializedDevice = deviceBuilder.build();
+ final var device = serializer.deserialize(serializedDevice);
+
+ assertThat(device).usingRecursiveComparison().isEqualTo(expectedDevice);
+ }
+
@Test
void shouldSerializeUuid() {
final var expectedUuid = "uuid";
diff --git a/src/policy/target/generated-sources/grpc/context_policy/ContextPolicy.java b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicy.java
new file mode 100644
index 0000000000000000000000000000000000000000..5048be4750db97e35f3007645927f2c7ea24be85
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicy.java
@@ -0,0 +1,49 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: context-policy.proto
+
+package context_policy;
+
+public final class ContextPolicy {
+ private ContextPolicy() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistryLite registry) {
+ }
+
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ registerAllExtensions(
+ (com.google.protobuf.ExtensionRegistryLite) registry);
+ }
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\024context-policy.proto\022\016context_policy\032\r" +
+ "context.proto\032\014policy.proto2\324\002\n\024ContextP" +
+ "olicyService\022?\n\021ListPolicyRuleIds\022\016.cont" +
+ "ext.Empty\032\030.policy.PolicyRuleIdList\"\000\022;\n" +
+ "\017ListPolicyRules\022\016.context.Empty\032\026.polic" +
+ "y.PolicyRuleList\"\000\022@\n\rGetPolicyRule\022\024.po" +
+ "licy.PolicyRuleId\032\027.policy.PolicyRuleBas" +
+ "ic\"\000\022@\n\rSetPolicyRule\022\027.policy.PolicyRul" +
+ "eBasic\032\024.policy.PolicyRuleId\"\000\022:\n\020Remove" +
+ "PolicyRule\022\024.policy.PolicyRuleId\032\016.conte" +
+ "xt.Empty\"\000b\006proto3"
+ };
+ descriptor = com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ context.ContextOuterClass.getDescriptor(),
+ policy.Policy.getDescriptor(),
+ });
+ context.ContextOuterClass.getDescriptor();
+ policy.Policy.getDescriptor();
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyService.java b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyService.java
new file mode 100644
index 0000000000000000000000000000000000000000..4870737ab496fff5c36ffa0824e44669532ecec0
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyService.java
@@ -0,0 +1,24 @@
+package context_policy;
+
+import io.quarkus.grpc.runtime.MutinyService;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: context-policy.proto")
+public interface ContextPolicyService extends MutinyService {
+
+
+ io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(context.ContextOuterClass.Empty request);
+
+ io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleList> listPolicyRules(context.ContextOuterClass.Empty request);
+
+ io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleBasic> getPolicyRule(policy.Policy.PolicyRuleId request);
+
+ io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleId> setPolicyRule(policy.Policy.PolicyRuleBasic request);
+
+ io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> removePolicyRule(policy.Policy.PolicyRuleId request);
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceBean.java b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceBean.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1a93a6014a9fb0d9ae0d0e528fda1a1e2658416
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceBean.java
@@ -0,0 +1,59 @@
+package context_policy;
+
+import io.grpc.BindableService;
+import io.quarkus.grpc.GrpcService;
+import io.quarkus.grpc.runtime.MutinyBean;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: context-policy.proto")
+public class ContextPolicyServiceBean extends MutinyContextPolicyServiceGrpc.ContextPolicyServiceImplBase implements BindableService, MutinyBean {
+
+ private final ContextPolicyService delegate;
+
+ ContextPolicyServiceBean(@GrpcService ContextPolicyService delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(context.ContextOuterClass.Empty request) {
+ try {
+ return delegate.listPolicyRuleIds(request);
+ } catch (UnsupportedOperationException e) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleList> listPolicyRules(context.ContextOuterClass.Empty request) {
+ try {
+ return delegate.listPolicyRules(request);
+ } catch (UnsupportedOperationException e) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleBasic> getPolicyRule(policy.Policy.PolicyRuleId request) {
+ try {
+ return delegate.getPolicyRule(request);
+ } catch (UnsupportedOperationException e) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleId> setPolicyRule(policy.Policy.PolicyRuleBasic request) {
+ try {
+ return delegate.setPolicyRule(request);
+ } catch (UnsupportedOperationException e) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> removePolicyRule(policy.Policy.PolicyRuleId request) {
+ try {
+ return delegate.removePolicyRule(request);
+ } catch (UnsupportedOperationException e) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceClient.java b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceClient.java
new file mode 100644
index 0000000000000000000000000000000000000000..d255415707710db2b225f4d4f7e3f7c4ee6fd6d5
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceClient.java
@@ -0,0 +1,44 @@
+package context_policy;
+
+import java.util.function.BiFunction;
+
+import io.quarkus.grpc.runtime.MutinyClient;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: context-policy.proto")
+public class ContextPolicyServiceClient implements ContextPolicyService, MutinyClient<MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub> {
+
+ private final MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub stub;
+
+ public ContextPolicyServiceClient(String name, io.grpc.Channel channel, BiFunction<String, MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub, MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub> stubConfigurator) {
+ this.stub = stubConfigurator.apply(name,MutinyContextPolicyServiceGrpc.newMutinyStub(channel));
+ }
+
+ @Override
+ public MutinyContextPolicyServiceGrpc.MutinyContextPolicyServiceStub getStub() {
+ return stub;
+ }
+
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(context.ContextOuterClass.Empty request) {
+ return stub.listPolicyRuleIds(request);
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleList> listPolicyRules(context.ContextOuterClass.Empty request) {
+ return stub.listPolicyRules(request);
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleBasic> getPolicyRule(policy.Policy.PolicyRuleId request) {
+ return stub.getPolicyRule(request);
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleId> setPolicyRule(policy.Policy.PolicyRuleBasic request) {
+ return stub.setPolicyRule(request);
+ }
+ @Override
+ public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> removePolicyRule(policy.Policy.PolicyRuleId request) {
+ return stub.removePolicyRule(request);
+ }
+
+}
\ No newline at end of file
diff --git a/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceGrpc.java b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceGrpc.java
new file mode 100644
index 0000000000000000000000000000000000000000..69735c34ce57d91725f81c7c23d94ad60da1db9b
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/ContextPolicyServiceGrpc.java
@@ -0,0 +1,586 @@
+package context_policy;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+@javax.annotation.Generated(
+ value = "by gRPC proto compiler (version 1.38.1)",
+ comments = "Source: context-policy.proto")
+public final class ContextPolicyServiceGrpc {
+
+ private ContextPolicyServiceGrpc() {}
+
+ public static final String SERVICE_NAME = "context_policy.ContextPolicyService";
+
+ // Static method descriptors that strictly reflect the proto.
+ private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleIdList> getListPolicyRuleIdsMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "ListPolicyRuleIds",
+ requestType = context.ContextOuterClass.Empty.class,
+ responseType = policy.Policy.PolicyRuleIdList.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleIdList> getListPolicyRuleIdsMethod() {
+ io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, policy.Policy.PolicyRuleIdList> getListPolicyRuleIdsMethod;
+ if ((getListPolicyRuleIdsMethod = ContextPolicyServiceGrpc.getListPolicyRuleIdsMethod) == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ if ((getListPolicyRuleIdsMethod = ContextPolicyServiceGrpc.getListPolicyRuleIdsMethod) == null) {
+ ContextPolicyServiceGrpc.getListPolicyRuleIdsMethod = getListPolicyRuleIdsMethod =
+ io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, policy.Policy.PolicyRuleIdList>newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListPolicyRuleIds"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ context.ContextOuterClass.Empty.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleIdList.getDefaultInstance()))
+ .setSchemaDescriptor(new ContextPolicyServiceMethodDescriptorSupplier("ListPolicyRuleIds"))
+ .build();
+ }
+ }
+ }
+ return getListPolicyRuleIdsMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleList> getListPolicyRulesMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "ListPolicyRules",
+ requestType = context.ContextOuterClass.Empty.class,
+ responseType = policy.Policy.PolicyRuleList.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleList> getListPolicyRulesMethod() {
+ io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, policy.Policy.PolicyRuleList> getListPolicyRulesMethod;
+ if ((getListPolicyRulesMethod = ContextPolicyServiceGrpc.getListPolicyRulesMethod) == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ if ((getListPolicyRulesMethod = ContextPolicyServiceGrpc.getListPolicyRulesMethod) == null) {
+ ContextPolicyServiceGrpc.getListPolicyRulesMethod = getListPolicyRulesMethod =
+ io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, policy.Policy.PolicyRuleList>newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListPolicyRules"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ context.ContextOuterClass.Empty.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleList.getDefaultInstance()))
+ .setSchemaDescriptor(new ContextPolicyServiceMethodDescriptorSupplier("ListPolicyRules"))
+ .build();
+ }
+ }
+ }
+ return getListPolicyRulesMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId,
+ policy.Policy.PolicyRuleBasic> getGetPolicyRuleMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "GetPolicyRule",
+ requestType = policy.Policy.PolicyRuleId.class,
+ responseType = policy.Policy.PolicyRuleBasic.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId,
+ policy.Policy.PolicyRuleBasic> getGetPolicyRuleMethod() {
+ io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId, policy.Policy.PolicyRuleBasic> getGetPolicyRuleMethod;
+ if ((getGetPolicyRuleMethod = ContextPolicyServiceGrpc.getGetPolicyRuleMethod) == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ if ((getGetPolicyRuleMethod = ContextPolicyServiceGrpc.getGetPolicyRuleMethod) == null) {
+ ContextPolicyServiceGrpc.getGetPolicyRuleMethod = getGetPolicyRuleMethod =
+ io.grpc.MethodDescriptor.<policy.Policy.PolicyRuleId, policy.Policy.PolicyRuleBasic>newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetPolicyRule"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleId.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleBasic.getDefaultInstance()))
+ .setSchemaDescriptor(new ContextPolicyServiceMethodDescriptorSupplier("GetPolicyRule"))
+ .build();
+ }
+ }
+ }
+ return getGetPolicyRuleMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor<policy.Policy.PolicyRuleBasic,
+ policy.Policy.PolicyRuleId> getSetPolicyRuleMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "SetPolicyRule",
+ requestType = policy.Policy.PolicyRuleBasic.class,
+ responseType = policy.Policy.PolicyRuleId.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor<policy.Policy.PolicyRuleBasic,
+ policy.Policy.PolicyRuleId> getSetPolicyRuleMethod() {
+ io.grpc.MethodDescriptor<policy.Policy.PolicyRuleBasic, policy.Policy.PolicyRuleId> getSetPolicyRuleMethod;
+ if ((getSetPolicyRuleMethod = ContextPolicyServiceGrpc.getSetPolicyRuleMethod) == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ if ((getSetPolicyRuleMethod = ContextPolicyServiceGrpc.getSetPolicyRuleMethod) == null) {
+ ContextPolicyServiceGrpc.getSetPolicyRuleMethod = getSetPolicyRuleMethod =
+ io.grpc.MethodDescriptor.<policy.Policy.PolicyRuleBasic, policy.Policy.PolicyRuleId>newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetPolicyRule"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleBasic.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleId.getDefaultInstance()))
+ .setSchemaDescriptor(new ContextPolicyServiceMethodDescriptorSupplier("SetPolicyRule"))
+ .build();
+ }
+ }
+ }
+ return getSetPolicyRuleMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId,
+ context.ContextOuterClass.Empty> getRemovePolicyRuleMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "RemovePolicyRule",
+ requestType = policy.Policy.PolicyRuleId.class,
+ responseType = context.ContextOuterClass.Empty.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+ public static io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId,
+ context.ContextOuterClass.Empty> getRemovePolicyRuleMethod() {
+ io.grpc.MethodDescriptor<policy.Policy.PolicyRuleId, context.ContextOuterClass.Empty> getRemovePolicyRuleMethod;
+ if ((getRemovePolicyRuleMethod = ContextPolicyServiceGrpc.getRemovePolicyRuleMethod) == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ if ((getRemovePolicyRuleMethod = ContextPolicyServiceGrpc.getRemovePolicyRuleMethod) == null) {
+ ContextPolicyServiceGrpc.getRemovePolicyRuleMethod = getRemovePolicyRuleMethod =
+ io.grpc.MethodDescriptor.<policy.Policy.PolicyRuleId, context.ContextOuterClass.Empty>newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemovePolicyRule"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ policy.Policy.PolicyRuleId.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ context.ContextOuterClass.Empty.getDefaultInstance()))
+ .setSchemaDescriptor(new ContextPolicyServiceMethodDescriptorSupplier("RemovePolicyRule"))
+ .build();
+ }
+ }
+ }
+ return getRemovePolicyRuleMethod;
+ }
+
+ /**
+ * Creates a new async stub that supports all call types for the service
+ */
+ public static ContextPolicyServiceStub newStub(io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceStub> factory =
+ new io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceStub>() {
+ @java.lang.Override
+ public ContextPolicyServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceStub(channel, callOptions);
+ }
+ };
+ return ContextPolicyServiceStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+ */
+ public static ContextPolicyServiceBlockingStub newBlockingStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceBlockingStub> factory =
+ new io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceBlockingStub>() {
+ @java.lang.Override
+ public ContextPolicyServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceBlockingStub(channel, callOptions);
+ }
+ };
+ return ContextPolicyServiceBlockingStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new ListenableFuture-style stub that supports unary calls on the service
+ */
+ public static ContextPolicyServiceFutureStub newFutureStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceFutureStub> factory =
+ new io.grpc.stub.AbstractStub.StubFactory<ContextPolicyServiceFutureStub>() {
+ @java.lang.Override
+ public ContextPolicyServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceFutureStub(channel, callOptions);
+ }
+ };
+ return ContextPolicyServiceFutureStub.newStub(factory, channel);
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static abstract class ContextPolicyServiceImplBase implements io.grpc.BindableService {
+
+ /**
+ */
+ public void listPolicyRuleIds(context.ContextOuterClass.Empty request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleIdList> responseObserver) {
+ io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListPolicyRuleIdsMethod(), responseObserver);
+ }
+
+ /**
+ */
+ public void listPolicyRules(context.ContextOuterClass.Empty request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleList> responseObserver) {
+ io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListPolicyRulesMethod(), responseObserver);
+ }
+
+ /**
+ */
+ public void getPolicyRule(policy.Policy.PolicyRuleId request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleBasic> responseObserver) {
+ io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetPolicyRuleMethod(), responseObserver);
+ }
+
+ /**
+ */
+ public void setPolicyRule(policy.Policy.PolicyRuleBasic request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleId> responseObserver) {
+ io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetPolicyRuleMethod(), responseObserver);
+ }
+
+ /**
+ */
+ public void removePolicyRule(policy.Policy.PolicyRuleId request,
+ io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+ io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRemovePolicyRuleMethod(), responseObserver);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ getListPolicyRuleIdsMethod(),
+ io.grpc.stub.ServerCalls.asyncUnaryCall(
+ new MethodHandlers<
+ context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleIdList>(
+ this, METHODID_LIST_POLICY_RULE_IDS)))
+ .addMethod(
+ getListPolicyRulesMethod(),
+ io.grpc.stub.ServerCalls.asyncUnaryCall(
+ new MethodHandlers<
+ context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleList>(
+ this, METHODID_LIST_POLICY_RULES)))
+ .addMethod(
+ getGetPolicyRuleMethod(),
+ io.grpc.stub.ServerCalls.asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleId,
+ policy.Policy.PolicyRuleBasic>(
+ this, METHODID_GET_POLICY_RULE)))
+ .addMethod(
+ getSetPolicyRuleMethod(),
+ io.grpc.stub.ServerCalls.asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleBasic,
+ policy.Policy.PolicyRuleId>(
+ this, METHODID_SET_POLICY_RULE)))
+ .addMethod(
+ getRemovePolicyRuleMethod(),
+ io.grpc.stub.ServerCalls.asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleId,
+ context.ContextOuterClass.Empty>(
+ this, METHODID_REMOVE_POLICY_RULE)))
+ .build();
+ }
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static final class ContextPolicyServiceStub extends io.grpc.stub.AbstractAsyncStub<ContextPolicyServiceStub> {
+ private ContextPolicyServiceStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected ContextPolicyServiceStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceStub(channel, callOptions);
+ }
+
+ /**
+ */
+ public void listPolicyRuleIds(context.ContextOuterClass.Empty request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleIdList> responseObserver) {
+ io.grpc.stub.ClientCalls.asyncUnaryCall(
+ getChannel().newCall(getListPolicyRuleIdsMethod(), getCallOptions()), request, responseObserver);
+ }
+
+ /**
+ */
+ public void listPolicyRules(context.ContextOuterClass.Empty request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleList> responseObserver) {
+ io.grpc.stub.ClientCalls.asyncUnaryCall(
+ getChannel().newCall(getListPolicyRulesMethod(), getCallOptions()), request, responseObserver);
+ }
+
+ /**
+ */
+ public void getPolicyRule(policy.Policy.PolicyRuleId request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleBasic> responseObserver) {
+ io.grpc.stub.ClientCalls.asyncUnaryCall(
+ getChannel().newCall(getGetPolicyRuleMethod(), getCallOptions()), request, responseObserver);
+ }
+
+ /**
+ */
+ public void setPolicyRule(policy.Policy.PolicyRuleBasic request,
+ io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleId> responseObserver) {
+ io.grpc.stub.ClientCalls.asyncUnaryCall(
+ getChannel().newCall(getSetPolicyRuleMethod(), getCallOptions()), request, responseObserver);
+ }
+
+ /**
+ */
+ public void removePolicyRule(policy.Policy.PolicyRuleId request,
+ io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+ io.grpc.stub.ClientCalls.asyncUnaryCall(
+ getChannel().newCall(getRemovePolicyRuleMethod(), getCallOptions()), request, responseObserver);
+ }
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static final class ContextPolicyServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ContextPolicyServiceBlockingStub> {
+ private ContextPolicyServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected ContextPolicyServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceBlockingStub(channel, callOptions);
+ }
+
+ /**
+ */
+ public policy.Policy.PolicyRuleIdList listPolicyRuleIds(context.ContextOuterClass.Empty request) {
+ return io.grpc.stub.ClientCalls.blockingUnaryCall(
+ getChannel(), getListPolicyRuleIdsMethod(), getCallOptions(), request);
+ }
+
+ /**
+ */
+ public policy.Policy.PolicyRuleList listPolicyRules(context.ContextOuterClass.Empty request) {
+ return io.grpc.stub.ClientCalls.blockingUnaryCall(
+ getChannel(), getListPolicyRulesMethod(), getCallOptions(), request);
+ }
+
+ /**
+ */
+ public policy.Policy.PolicyRuleBasic getPolicyRule(policy.Policy.PolicyRuleId request) {
+ return io.grpc.stub.ClientCalls.blockingUnaryCall(
+ getChannel(), getGetPolicyRuleMethod(), getCallOptions(), request);
+ }
+
+ /**
+ */
+ public policy.Policy.PolicyRuleId setPolicyRule(policy.Policy.PolicyRuleBasic request) {
+ return io.grpc.stub.ClientCalls.blockingUnaryCall(
+ getChannel(), getSetPolicyRuleMethod(), getCallOptions(), request);
+ }
+
+ /**
+ */
+ public context.ContextOuterClass.Empty removePolicyRule(policy.Policy.PolicyRuleId request) {
+ return io.grpc.stub.ClientCalls.blockingUnaryCall(
+ getChannel(), getRemovePolicyRuleMethod(), getCallOptions(), request);
+ }
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static final class ContextPolicyServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ContextPolicyServiceFutureStub> {
+ private ContextPolicyServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected ContextPolicyServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new ContextPolicyServiceFutureStub(channel, callOptions);
+ }
+
+ /**
+ */
+ public com.google.common.util.concurrent.ListenableFuture<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(
+ context.ContextOuterClass.Empty request) {
+ return io.grpc.stub.ClientCalls.futureUnaryCall(
+ getChannel().newCall(getListPolicyRuleIdsMethod(), getCallOptions()), request);
+ }
+
+ /**
+ */
+ public com.google.common.util.concurrent.ListenableFuture<policy.Policy.PolicyRuleList> listPolicyRules(
+ context.ContextOuterClass.Empty request) {
+ return io.grpc.stub.ClientCalls.futureUnaryCall(
+ getChannel().newCall(getListPolicyRulesMethod(), getCallOptions()), request);
+ }
+
+ /**
+ */
+ public com.google.common.util.concurrent.ListenableFuture<policy.Policy.PolicyRuleBasic> getPolicyRule(
+ policy.Policy.PolicyRuleId request) {
+ return io.grpc.stub.ClientCalls.futureUnaryCall(
+ getChannel().newCall(getGetPolicyRuleMethod(), getCallOptions()), request);
+ }
+
+ /**
+ */
+ public com.google.common.util.concurrent.ListenableFuture<policy.Policy.PolicyRuleId> setPolicyRule(
+ policy.Policy.PolicyRuleBasic request) {
+ return io.grpc.stub.ClientCalls.futureUnaryCall(
+ getChannel().newCall(getSetPolicyRuleMethod(), getCallOptions()), request);
+ }
+
+ /**
+ */
+ public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> removePolicyRule(
+ policy.Policy.PolicyRuleId request) {
+ return io.grpc.stub.ClientCalls.futureUnaryCall(
+ getChannel().newCall(getRemovePolicyRuleMethod(), getCallOptions()), request);
+ }
+ }
+
+ private static final int METHODID_LIST_POLICY_RULE_IDS = 0;
+ private static final int METHODID_LIST_POLICY_RULES = 1;
+ private static final int METHODID_GET_POLICY_RULE = 2;
+ private static final int METHODID_SET_POLICY_RULE = 3;
+ private static final int METHODID_REMOVE_POLICY_RULE = 4;
+
+ private static final class MethodHandlers<Req, Resp> implements
+ io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+ private final ContextPolicyServiceImplBase serviceImpl;
+ private final int methodId;
+
+ MethodHandlers(ContextPolicyServiceImplBase serviceImpl, int methodId) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+ switch (methodId) {
+ case METHODID_LIST_POLICY_RULE_IDS:
+ serviceImpl.listPolicyRuleIds((context.ContextOuterClass.Empty) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleIdList>) responseObserver);
+ break;
+ case METHODID_LIST_POLICY_RULES:
+ serviceImpl.listPolicyRules((context.ContextOuterClass.Empty) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleList>) responseObserver);
+ break;
+ case METHODID_GET_POLICY_RULE:
+ serviceImpl.getPolicyRule((policy.Policy.PolicyRuleId) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleBasic>) responseObserver);
+ break;
+ case METHODID_SET_POLICY_RULE:
+ serviceImpl.setPolicyRule((policy.Policy.PolicyRuleBasic) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleId>) responseObserver);
+ break;
+ case METHODID_REMOVE_POLICY_RULE:
+ serviceImpl.removePolicyRule((policy.Policy.PolicyRuleId) request,
+ (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver<Req> invoke(
+ io.grpc.stub.StreamObserver<Resp> responseObserver) {
+ switch (methodId) {
+ default:
+ throw new AssertionError();
+ }
+ }
+ }
+
+ private static abstract class ContextPolicyServiceBaseDescriptorSupplier
+ implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+ ContextPolicyServiceBaseDescriptorSupplier() {}
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+ return context_policy.ContextPolicy.getDescriptor();
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+ return getFileDescriptor().findServiceByName("ContextPolicyService");
+ }
+ }
+
+ private static final class ContextPolicyServiceFileDescriptorSupplier
+ extends ContextPolicyServiceBaseDescriptorSupplier {
+ ContextPolicyServiceFileDescriptorSupplier() {}
+ }
+
+ private static final class ContextPolicyServiceMethodDescriptorSupplier
+ extends ContextPolicyServiceBaseDescriptorSupplier
+ implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+ private final String methodName;
+
+ ContextPolicyServiceMethodDescriptorSupplier(String methodName) {
+ this.methodName = methodName;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+ return getServiceDescriptor().findMethodByName(methodName);
+ }
+ }
+
+ private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+ io.grpc.ServiceDescriptor result = serviceDescriptor;
+ if (result == null) {
+ synchronized (ContextPolicyServiceGrpc.class) {
+ result = serviceDescriptor;
+ if (result == null) {
+ serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+ .setSchemaDescriptor(new ContextPolicyServiceFileDescriptorSupplier())
+ .addMethod(getListPolicyRuleIdsMethod())
+ .addMethod(getListPolicyRulesMethod())
+ .addMethod(getGetPolicyRuleMethod())
+ .addMethod(getSetPolicyRuleMethod())
+ .addMethod(getRemovePolicyRuleMethod())
+ .build();
+ }
+ }
+ }
+ return result;
+ }
+}
diff --git a/src/policy/target/generated-sources/grpc/context_policy/MutinyContextPolicyServiceGrpc.java b/src/policy/target/generated-sources/grpc/context_policy/MutinyContextPolicyServiceGrpc.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e6e29c0468afe5656d537cd0fe79e7b9ede7bad
--- /dev/null
+++ b/src/policy/target/generated-sources/grpc/context_policy/MutinyContextPolicyServiceGrpc.java
@@ -0,0 +1,224 @@
+package context_policy;
+
+import static context_policy.ContextPolicyServiceGrpc.getServiceDescriptor;
+import static io.grpc.stub.ServerCalls.asyncUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: context-policy.proto")
+public final class MutinyContextPolicyServiceGrpc implements io.quarkus.grpc.runtime.MutinyGrpc {
+ private MutinyContextPolicyServiceGrpc() {}
+
+ public static MutinyContextPolicyServiceStub newMutinyStub(io.grpc.Channel channel) {
+ return new MutinyContextPolicyServiceStub(channel);
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static final class MutinyContextPolicyServiceStub extends io.grpc.stub.AbstractStub<MutinyContextPolicyServiceStub> implements io.quarkus.grpc.runtime.MutinyStub {
+ private ContextPolicyServiceGrpc.ContextPolicyServiceStub delegateStub;
+
+ private MutinyContextPolicyServiceStub(io.grpc.Channel channel) {
+ super(channel);
+ delegateStub = ContextPolicyServiceGrpc.newStub(channel);
+ }
+
+ private MutinyContextPolicyServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ delegateStub = ContextPolicyServiceGrpc.newStub(channel).build(channel, callOptions);
+ }
+
+ @Override
+ protected MutinyContextPolicyServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new MutinyContextPolicyServiceStub(channel, callOptions);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(context.ContextOuterClass.Empty request) {
+ return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::listPolicyRuleIds);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleList> listPolicyRules(context.ContextOuterClass.Empty request) {
+ return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::listPolicyRules);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleBasic> getPolicyRule(policy.Policy.PolicyRuleId request) {
+ return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::getPolicyRule);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleId> setPolicyRule(policy.Policy.PolicyRuleBasic request) {
+ return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::setPolicyRule);
+ }
+
+
+ public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> removePolicyRule(policy.Policy.PolicyRuleId request) {
+ return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::removePolicyRule);
+ }
+
+ }
+
+ /**
+ * <pre>
+ * created as a separate service to prevent import-loops in context and policy
+ * </pre>
+ */
+ public static abstract class ContextPolicyServiceImplBase implements io.grpc.BindableService {
+
+ private String compression;
+ /**
+ * Set whether the server will try to use a compressed response.
+ *
+ * @param compression the compression, e.g {@code gzip}
+ */
+ public ContextPolicyServiceImplBase withCompression(String compression) {
+ this.compression = compression;
+ return this;
+ }
+
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleIdList> listPolicyRuleIds(context.ContextOuterClass.Empty request) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleList> listPolicyRules(context.ContextOuterClass.Empty request) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleBasic> getPolicyRule(policy.Policy.PolicyRuleId request) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+
+
+ public io.smallrye.mutiny.Uni<policy.Policy.PolicyRuleId> setPolicyRule(policy.Policy.PolicyRuleBasic request) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+
+
+ public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> removePolicyRule(policy.Policy.PolicyRuleId request) {
+ throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ context_policy.ContextPolicyServiceGrpc.getListPolicyRuleIdsMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleIdList>(
+ this, METHODID_LIST_POLICY_RULE_IDS, compression)))
+ .addMethod(
+ context_policy.ContextPolicyServiceGrpc.getListPolicyRulesMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ context.ContextOuterClass.Empty,
+ policy.Policy.PolicyRuleList>(
+ this, METHODID_LIST_POLICY_RULES, compression)))
+ .addMethod(
+ context_policy.ContextPolicyServiceGrpc.getGetPolicyRuleMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleId,
+ policy.Policy.PolicyRuleBasic>(
+ this, METHODID_GET_POLICY_RULE, compression)))
+ .addMethod(
+ context_policy.ContextPolicyServiceGrpc.getSetPolicyRuleMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleBasic,
+ policy.Policy.PolicyRuleId>(
+ this, METHODID_SET_POLICY_RULE, compression)))
+ .addMethod(
+ context_policy.ContextPolicyServiceGrpc.getRemovePolicyRuleMethod(),
+ asyncUnaryCall(
+ new MethodHandlers<
+ policy.Policy.PolicyRuleId,
+ context.ContextOuterClass.Empty>(
+ this, METHODID_REMOVE_POLICY_RULE, compression)))
+ .build();
+ }
+ }
+
+ private static final int METHODID_LIST_POLICY_RULE_IDS = 0;
+ private static final int METHODID_LIST_POLICY_RULES = 1;
+ private static final int METHODID_GET_POLICY_RULE = 2;
+ private static final int METHODID_SET_POLICY_RULE = 3;
+ private static final int METHODID_REMOVE_POLICY_RULE = 4;
+
+ private static final class MethodHandlers<Req, Resp> implements
+ io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+ private final ContextPolicyServiceImplBase serviceImpl;
+ private final int methodId;
+ private final String compression;
+
+ MethodHandlers(ContextPolicyServiceImplBase serviceImpl, int methodId, String compression) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ this.compression = compression;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+ switch (methodId) {
+ case METHODID_LIST_POLICY_RULE_IDS:
+ io.quarkus.grpc.runtime.ServerCalls.oneToOne((context.ContextOuterClass.Empty) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleIdList>) responseObserver,
+ compression,
+ serviceImpl::listPolicyRuleIds);
+ break;
+ case METHODID_LIST_POLICY_RULES:
+ io.quarkus.grpc.runtime.ServerCalls.oneToOne((context.ContextOuterClass.Empty) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleList>) responseObserver,
+ compression,
+ serviceImpl::listPolicyRules);
+ break;
+ case METHODID_GET_POLICY_RULE:
+ io.quarkus.grpc.runtime.ServerCalls.oneToOne((policy.Policy.PolicyRuleId) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleBasic>) responseObserver,
+ compression,
+ serviceImpl::getPolicyRule);
+ break;
+ case METHODID_SET_POLICY_RULE:
+ io.quarkus.grpc.runtime.ServerCalls.oneToOne((policy.Policy.PolicyRuleBasic) request,
+ (io.grpc.stub.StreamObserver<policy.Policy.PolicyRuleId>) responseObserver,
+ compression,
+ serviceImpl::setPolicyRule);
+ break;
+ case METHODID_REMOVE_POLICY_RULE:
+ io.quarkus.grpc.runtime.ServerCalls.oneToOne((policy.Policy.PolicyRuleId) request,
+ (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver,
+ compression,
+ serviceImpl::removePolicyRule);
+ break;
+ default:
+ throw new java.lang.AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver<Req> invoke(io.grpc.stub.StreamObserver<Resp> responseObserver) {
+ switch (methodId) {
+ default:
+ throw new java.lang.AssertionError();
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/policy/target/kubernetes/kubernetes.yml b/src/policy/target/kubernetes/kubernetes.yml
index b692aa34084ad96b958019be1c9087ef0db9ded5..06068f0f5983b4ef385ee60b8a6cb5d812cab253 100644
--- a/src/policy/target/kubernetes/kubernetes.yml
+++ b/src/policy/target/kubernetes/kubernetes.yml
@@ -3,20 +3,20 @@ apiVersion: v1
kind: Service
metadata:
annotations:
- app.quarkus.io/commit-id: 342ed841a2fd5a8c0ab65464b4e178bc63981fb3
- app.quarkus.io/build-timestamp: 2022-07-22 - 09:19:09 +0000
+ app.quarkus.io/commit-id: 1d77cb00ae8f577885de32f01f4740f865853863
+ app.quarkus.io/build-timestamp: 2022-07-26 - 10:46:55 +0000
labels:
app.kubernetes.io/name: policyservice
app: policyservice
name: policyservice
spec:
ports:
- - name: grpc
- port: 6060
- targetPort: 6060
- name: http
port: 8080
targetPort: 8080
+ - name: grpc
+ port: 6060
+ targetPort: 6060
selector:
app.kubernetes.io/name: policyservice
type: ClusterIP
@@ -25,8 +25,8 @@ apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
- app.quarkus.io/commit-id: 342ed841a2fd5a8c0ab65464b4e178bc63981fb3
- app.quarkus.io/build-timestamp: 2022-07-22 - 09:19:09 +0000
+ app.quarkus.io/commit-id: 1d77cb00ae8f577885de32f01f4740f865853863
+ app.quarkus.io/build-timestamp: 2022-07-26 - 10:46:55 +0000
labels:
app: policyservice
app.kubernetes.io/name: policyservice
@@ -39,8 +39,8 @@ spec:
template:
metadata:
annotations:
- app.quarkus.io/commit-id: 342ed841a2fd5a8c0ab65464b4e178bc63981fb3
- app.quarkus.io/build-timestamp: 2022-07-22 - 09:19:09 +0000
+ app.quarkus.io/commit-id: 1d77cb00ae8f577885de32f01f4740f865853863
+ app.quarkus.io/build-timestamp: 2022-07-26 - 10:46:55 +0000
labels:
app: policyservice
app.kubernetes.io/name: policyservice
@@ -51,12 +51,12 @@ spec:
valueFrom:
fieldRef:
fieldPath: metadata.namespace
+ - name: SERVICE_SERVICE_HOST
+ value: serviceservice
- name: MONITORING_SERVICE_HOST
value: monitoringservice
- name: CONTEXT_SERVICE_HOST
value: contextservice
- - name: SERVICE_SERVICE_HOST
- value: serviceservice
image: registry.gitlab.com/teraflow-h2020/controller/policy:0.1.0
imagePullPolicy: Always
livenessProbe:
@@ -71,12 +71,12 @@ spec:
timeoutSeconds: 10
name: policyservice
ports:
- - containerPort: 6060
- name: grpc
- protocol: TCP
- containerPort: 8080
name: http
protocol: TCP
+ - containerPort: 6060
+ name: grpc
+ protocol: TCP
readinessProbe:
failureThreshold: 3
httpGet: