feat(policy): add context related domain models

src/policy/src/main/java/eu/teraflow/policy/context/model/Uuid.java → src/policy/src/main/java/eu/teraflow/policy/context/model/ConfigActionEnum.java

@@ -16,15 +16,8 @@
 
 package eu.teraflow.policy.context.model;
 
-public class Uuid {
-
-    private String id;
-
-    public Uuid(String id) {
-        this.id = id;
-    }
-
-    public String getId() {
-        return id;
-    }
+public enum ConfigActionEnum {
+    UNDEFINED,
+    SET,
+    DELETE
 }

src/policy/src/main/java/eu/teraflow/policy/context/model/ConfigRule.java

+/*
+* 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 class ConfigRule {
+
+    private final ConfigActionEnum action;
+    private final String resourceKey;
+    private final String resourceValue;
+
+    public ConfigRule(ConfigActionEnum action, String resourceKey, String resourceValue) {
+        this.action = action;
+        this.resourceKey = resourceKey;
+        this.resourceValue = resourceValue;
+    }
+
+    public ConfigActionEnum getAction() {
+        return action;
+    }
+
+    public String getResourceKey() {
+        return resourceKey;
+    }
+
+    public String getResourceValue() {
+        return resourceValue;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{action:\"%s\", resourceKey:\"%s\", resourceValue:\"%s\"}",
+                getClass().getSimpleName(), action.toString(), resourceKey, resourceValue);
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/Constraint.java

+/*
+* 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 class Constraint {
+
+    private final String constraintType;
+    private final String constraintValue;
+
+    public Constraint(String constraintType, String constraintValue) {
+        this.constraintType = constraintType;
+        this.constraintValue = constraintValue;
+    }
+
+    public String getConstraintType() {
+        return constraintType;
+    }
+
+    public String getConstraintValue() {
+        return constraintValue;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{constraintType:\"%s\", constraintValue:\"%s\"}",
+                getClass().getSimpleName(), constraintType, constraintValue);
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/EndPointId.java

+/*
+* 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 class EndPointId {
+
+    private final TopologyId topologyId;
+    private final String deviceId;
+    private final String id;
+
+    public EndPointId(TopologyId topologyId, String deviceId, String id) {
+        this.topologyId = topologyId;
+        this.deviceId = deviceId;
+        this.id = id;
+    }
+
+    public TopologyId getTopologyId() {
+        return topologyId;
+    }
+
+    public String getDeviceId() {
+        return deviceId;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{%s, deviceId:\"%s\", id:\"%s\"}",
+                getClass().getSimpleName(), topologyId, deviceId, id);
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/Event.java

@@ -33,4 +33,11 @@ public class Event {
     public EventTypeEnum getEventTypeEnum() {
         return eventType;
     }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{timestamp:\"%f\", eventType:\"%s\"}",
+                getClass().getSimpleName(), timestamp, eventType.toString());
+    }
 }

src/policy/src/main/java/eu/teraflow/policy/context/model/Service.java

+/*
+* 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 java.util.List;
+import java.util.stream.Collectors;
+
+public class Service {
+
+    private final ServiceId serviceId;
+    private final ServiceTypeEnum serviceType;
+    private final List<EndPointId> serviceEndPointIds;
+    private final List<Constraint> serviceConstraints;
+    private final ServiceStatus serviceStatus;
+    private final ServiceConfig serviceConfig;
+
+    public Service(
+            ServiceId serviceId,
+            ServiceTypeEnum serviceType,
+            List<EndPointId> serviceEndPointIds,
+            List<Constraint> serviceConstraints,
+            ServiceStatus serviceStatus,
+            ServiceConfig serviceConfig) {
+        this.serviceId = serviceId;
+        this.serviceType = serviceType;
+        this.serviceEndPointIds = serviceEndPointIds;
+        this.serviceConstraints = serviceConstraints;
+        this.serviceStatus = serviceStatus;
+        this.serviceConfig = serviceConfig;
+    }
+
+    public ServiceId getServiceId() {
+        return serviceId;
+    }
+
+    public ServiceTypeEnum getServiceType() {
+        return serviceType;
+    }
+
+    public List<EndPointId> getServiceEndPointIds() {
+        return serviceEndPointIds;
+    }
+
+    public List<Constraint> getServiceConstraints() {
+        return serviceConstraints;
+    }
+
+    public ServiceStatus getServiceStatus() {
+        return serviceStatus;
+    }
+
+    public ServiceConfig getServiceConfig() {
+        return serviceConfig;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{%s, serviceType:\"%s\", [%s], [%s], %s, %s}",
+                getClass().getSimpleName(),
+                serviceId,
+                serviceType.toString(),
+                toString(serviceEndPointIds),
+                toString(serviceConstraints),
+                serviceStatus,
+                serviceConfig);
+    }
+
+    private <T> String toString(List<T> list) {
+        return list.stream().map(T::toString).collect(Collectors.joining(", "));
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/ServiceConfig.java

+/*
+* 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 java.util.List;
+import java.util.stream.Collectors;
+
+public class ServiceConfig {
+
+    private final List<ConfigRule> configRules;
+
+    public ServiceConfig(List<ConfigRule> configRules) {
+        this.configRules = configRules;
+    }
+
+    public List<ConfigRule> getConfigRules() {
+        return configRules;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{configRules:[%s]}", getClass().getSimpleName(), toString(configRules));
+    }
+
+    private <T> String toString(List<T> list) {
+        return list.stream().map(T::toString).collect(Collectors.joining(", "));
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/ServiceId.java

@@ -18,20 +18,26 @@ package eu.teraflow.policy.context.model;
 
 public class ServiceId {
 
-    private final ContextId contextId;
-    private final Uuid serviceUuid;
+    private final String contextId;
+    private final String id;
 
-    public ServiceId(ContextId contextId, Uuid serviceUuid) {
+    public ServiceId(String contextId, String id) {
 
         this.contextId = contextId;
-        this.serviceUuid = serviceUuid;
+        this.id = id;
     }
 
-    public ContextId getContextId() {
+    public String getContextId() {
         return contextId;
     }
 
-    public Uuid getServiceUuid() {
-        return serviceUuid;
+    public String getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{contextId:\"%s\", id:\"%s\"}", getClass().getSimpleName(), contextId, id);
     }
 }

src/policy/src/main/java/eu/teraflow/policy/context/model/ServiceStatus.java

+/*
+* 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 class ServiceStatus {
+
+    private final ServiceStatusEnum status;
+
+    public ServiceStatus(ServiceStatusEnum status) {
+        this.status = status;
+    }
+
+    public ServiceStatusEnum getServiceStatus() {
+        return status;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s:{serviceStatus:\"%s\"}", getClass().getSimpleName(), status);
+    }
+}

src/policy/src/main/java/eu/teraflow/policy/context/model/DeviceId.java → src/policy/src/main/java/eu/teraflow/policy/context/model/ServiceStatusEnum.java

@@ -16,15 +16,9 @@
 
 package eu.teraflow.policy.context.model;
 
-public class DeviceId {
-
-    private final Uuid deviceId;
-
-    public DeviceId(Uuid deviceId) {
-        this.deviceId = deviceId;
-    }
-
-    public Uuid getDeviceId() {
-        return deviceId;
-    }
+public enum ServiceStatusEnum {
+    UNDEFINED,
+    PLANNED,
+    ACTIVE,
+    PENDING_REMOVAL
 }

src/policy/src/main/java/eu/teraflow/policy/context/model/ContextId.java → src/policy/src/main/java/eu/teraflow/policy/context/model/ServiceTypeEnum.java

@@ -16,15 +16,9 @@
 
 package eu.teraflow.policy.context.model;
 
-public class ContextId {
-
-    private final Uuid contextId;
-
-    public ContextId(Uuid contextId) {
-        this.contextId = contextId;
-    }
-
-    public Uuid getContextId() {
-        return contextId;
-    }
+public enum ServiceTypeEnum {
+    UNKNOWN,
+    L3NM,
+    L2NM,
+    TAPI_CONNECTIVITY_SERVICE
 }

src/policy/src/main/java/eu/teraflow/policy/context/model/TopologyId.java

+/*
+* 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 class TopologyId {
+
+    private final String contextId;
+    private final String id;
+
+    public TopologyId(String contextId, String id) {
+
+        this.contextId = contextId;
+        this.id = id;
+    }
+
+    public String getContextId() {
+        return contextId;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    @Override
+    public String toString() {
+        return String.format(
+                "%s:{contextId:\"%s\", id:\"%s\"}", getClass().getSimpleName(), contextId, id);
+    }
+}

src/policy/target/generated-sources/grpc/service/MutinyServiceServiceGrpc.java

+package service;
+
+import static service.ServiceServiceGrpc.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: service.proto")
+public final class MutinyServiceServiceGrpc implements io.quarkus.grpc.runtime.MutinyGrpc {
+    private MutinyServiceServiceGrpc() {}
+
+    public static MutinyServiceServiceStub newMutinyStub(io.grpc.Channel channel) {
+        return new MutinyServiceServiceStub(channel);
+    }
+
+    
+    public static final class MutinyServiceServiceStub extends io.grpc.stub.AbstractStub<MutinyServiceServiceStub> implements io.quarkus.grpc.runtime.MutinyStub {
+        private ServiceServiceGrpc.ServiceServiceStub delegateStub;
+
+        private MutinyServiceServiceStub(io.grpc.Channel channel) {
+            super(channel);
+            delegateStub = ServiceServiceGrpc.newStub(channel);
+        }
+
+        private MutinyServiceServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            super(channel, callOptions);
+            delegateStub = ServiceServiceGrpc.newStub(channel).build(channel, callOptions);
+        }
+
+        @Override
+        protected MutinyServiceServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            return new MutinyServiceServiceStub(channel, callOptions);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> createService(context.ContextOuterClass.Service request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::createService);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> updateService(context.ContextOuterClass.Service request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::updateService);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> deleteService(context.ContextOuterClass.ServiceId request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::deleteService);
+        }
+
+    }
+
+    
+    public static abstract class ServiceServiceImplBase 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 ServiceServiceImplBase withCompression(String compression) {
+        this.compression = compression;
+        return this;
+        }
+
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> createService(context.ContextOuterClass.Service request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> updateService(context.ContextOuterClass.Service request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> deleteService(context.ContextOuterClass.ServiceId 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(
+                            service.ServiceServiceGrpc.getCreateServiceMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            context.ContextOuterClass.Service,
+                                            context.ContextOuterClass.ServiceId>(
+                                            this, METHODID_CREATE_SERVICE, compression)))
+                    .addMethod(
+                            service.ServiceServiceGrpc.getUpdateServiceMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            context.ContextOuterClass.Service,
+                                            context.ContextOuterClass.ServiceId>(
+                                            this, METHODID_UPDATE_SERVICE, compression)))
+                    .addMethod(
+                            service.ServiceServiceGrpc.getDeleteServiceMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            context.ContextOuterClass.ServiceId,
+                                            context.ContextOuterClass.Empty>(
+                                            this, METHODID_DELETE_SERVICE, compression)))
+                    .build();
+        }
+    }
+
+    private static final int METHODID_CREATE_SERVICE = 0;
+    private static final int METHODID_UPDATE_SERVICE = 1;
+    private static final int METHODID_DELETE_SERVICE = 2;
+
+    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 ServiceServiceImplBase serviceImpl;
+        private final int methodId;
+        private final String compression;
+
+        MethodHandlers(ServiceServiceImplBase 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_CREATE_SERVICE:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((context.ContextOuterClass.Service) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId>) responseObserver,
+                            compression,
+                            serviceImpl::createService);
+                    break;
+                case METHODID_UPDATE_SERVICE:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((context.ContextOuterClass.Service) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId>) responseObserver,
+                            compression,
+                            serviceImpl::updateService);
+                    break;
+                case METHODID_DELETE_SERVICE:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((context.ContextOuterClass.ServiceId) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver,
+                            compression,
+                            serviceImpl::deleteService);
+                    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

src/policy/target/generated-sources/grpc/service/Service.java

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: service.proto
+
+package service;
+
+public final class Service {
+  private Service() {}
+  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\rservice.proto\022\007service\032\rcontext.proto2" +
+      "\271\001\n\016ServiceService\0227\n\rCreateService\022\020.co" +
+      "ntext.Service\032\022.context.ServiceId\"\000\0227\n\rU" +
+      "pdateService\022\020.context.Service\032\022.context" +
+      ".ServiceId\"\000\0225\n\rDeleteService\022\022.context." +
+      "ServiceId\032\016.context.Empty\"\000b\006proto3"
+    };
+    descriptor = com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+          context.ContextOuterClass.getDescriptor(),
+        });
+    context.ContextOuterClass.getDescriptor();
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}

src/policy/target/generated-sources/grpc/service/ServiceService.java

+package service;
+
+import io.quarkus.grpc.runtime.MutinyService;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: service.proto")
+public interface ServiceService extends MutinyService {
+
+    
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> createService(context.ContextOuterClass.Service request);
+    
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> updateService(context.ContextOuterClass.Service request);
+    
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> deleteService(context.ContextOuterClass.ServiceId request);
+    
+    
+    
+
+}
\ No newline at end of file

src/policy/target/generated-sources/grpc/service/ServiceServiceBean.java

+package service;
+
+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: service.proto")
+public class ServiceServiceBean extends MutinyServiceServiceGrpc.ServiceServiceImplBase implements BindableService, MutinyBean {
+
+    private final ServiceService delegate;
+
+    ServiceServiceBean(@GrpcService ServiceService delegate) {
+       this.delegate = delegate;
+    }
+
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> createService(context.ContextOuterClass.Service request) {
+       try {
+         return delegate.createService(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> updateService(context.ContextOuterClass.Service request) {
+       try {
+         return delegate.updateService(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> deleteService(context.ContextOuterClass.ServiceId request) {
+       try {
+         return delegate.deleteService(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+
+}
\ No newline at end of file

src/policy/target/generated-sources/grpc/service/ServiceServiceClient.java

+package service;
+
+import java.util.function.BiFunction;
+
+import io.quarkus.grpc.runtime.MutinyClient;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: service.proto")
+public class ServiceServiceClient implements ServiceService, MutinyClient<MutinyServiceServiceGrpc.MutinyServiceServiceStub> {
+
+    private final MutinyServiceServiceGrpc.MutinyServiceServiceStub stub;
+
+    public ServiceServiceClient(String name, io.grpc.Channel channel, BiFunction<String, MutinyServiceServiceGrpc.MutinyServiceServiceStub, MutinyServiceServiceGrpc.MutinyServiceServiceStub> stubConfigurator) {
+       this.stub = stubConfigurator.apply(name,MutinyServiceServiceGrpc.newMutinyStub(channel));
+    }
+
+    @Override
+    public MutinyServiceServiceGrpc.MutinyServiceServiceStub getStub() {
+       return stub;
+    }
+
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> createService(context.ContextOuterClass.Service request) {
+       return stub.createService(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.ServiceId> updateService(context.ContextOuterClass.Service request) {
+       return stub.updateService(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> deleteService(context.ContextOuterClass.ServiceId request) {
+       return stub.deleteService(request);
+    }
+
+}
\ No newline at end of file

src/policy/target/generated-sources/grpc/service/ServiceServiceGrpc.java

+package service;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@javax.annotation.Generated(
+    value = "by gRPC proto compiler (version 1.38.1)",
+    comments = "Source: service.proto")
+public final class ServiceServiceGrpc {
+
+  private ServiceServiceGrpc() {}
+
+  public static final String SERVICE_NAME = "service.ServiceService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Service,
+      context.ContextOuterClass.ServiceId> getCreateServiceMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "CreateService",
+      requestType = context.ContextOuterClass.Service.class,
+      responseType = context.ContextOuterClass.ServiceId.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Service,
+      context.ContextOuterClass.ServiceId> getCreateServiceMethod() {
+    io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getCreateServiceMethod;
+    if ((getCreateServiceMethod = ServiceServiceGrpc.getCreateServiceMethod) == null) {
+      synchronized (ServiceServiceGrpc.class) {
+        if ((getCreateServiceMethod = ServiceServiceGrpc.getCreateServiceMethod) == null) {
+          ServiceServiceGrpc.getCreateServiceMethod = getCreateServiceMethod =
+              io.grpc.MethodDescriptor.<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateService"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.Service.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.ServiceId.getDefaultInstance()))
+              .setSchemaDescriptor(new ServiceServiceMethodDescriptorSupplier("CreateService"))
+              .build();
+        }
+      }
+    }
+    return getCreateServiceMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Service,
+      context.ContextOuterClass.ServiceId> getUpdateServiceMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UpdateService",
+      requestType = context.ContextOuterClass.Service.class,
+      responseType = context.ContextOuterClass.ServiceId.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Service,
+      context.ContextOuterClass.ServiceId> getUpdateServiceMethod() {
+    io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getUpdateServiceMethod;
+    if ((getUpdateServiceMethod = ServiceServiceGrpc.getUpdateServiceMethod) == null) {
+      synchronized (ServiceServiceGrpc.class) {
+        if ((getUpdateServiceMethod = ServiceServiceGrpc.getUpdateServiceMethod) == null) {
+          ServiceServiceGrpc.getUpdateServiceMethod = getUpdateServiceMethod =
+              io.grpc.MethodDescriptor.<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateService"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.Service.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.ServiceId.getDefaultInstance()))
+              .setSchemaDescriptor(new ServiceServiceMethodDescriptorSupplier("UpdateService"))
+              .build();
+        }
+      }
+    }
+    return getUpdateServiceMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId,
+      context.ContextOuterClass.Empty> getDeleteServiceMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "DeleteService",
+      requestType = context.ContextOuterClass.ServiceId.class,
+      responseType = context.ContextOuterClass.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId,
+      context.ContextOuterClass.Empty> getDeleteServiceMethod() {
+    io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty> getDeleteServiceMethod;
+    if ((getDeleteServiceMethod = ServiceServiceGrpc.getDeleteServiceMethod) == null) {
+      synchronized (ServiceServiceGrpc.class) {
+        if ((getDeleteServiceMethod = ServiceServiceGrpc.getDeleteServiceMethod) == null) {
+          ServiceServiceGrpc.getDeleteServiceMethod = getDeleteServiceMethod =
+              io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteService"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.ServiceId.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new ServiceServiceMethodDescriptorSupplier("DeleteService"))
+              .build();
+        }
+      }
+    }
+    return getDeleteServiceMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ServiceServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServiceServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServiceServiceStub>() {
+        @java.lang.Override
+        public ServiceServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServiceServiceStub(channel, callOptions);
+        }
+      };
+    return ServiceServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ServiceServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServiceServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServiceServiceBlockingStub>() {
+        @java.lang.Override
+        public ServiceServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServiceServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ServiceServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ServiceServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServiceServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServiceServiceFutureStub>() {
+        @java.lang.Override
+        public ServiceServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServiceServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ServiceServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public static abstract class ServiceServiceImplBase implements io.grpc.BindableService {
+
+    /**
+     */
+    public void createService(context.ContextOuterClass.Service request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateServiceMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public void updateService(context.ContextOuterClass.Service request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateServiceMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public void deleteService(context.ContextOuterClass.ServiceId request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteServiceMethod(), responseObserver);
+    }
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+          .addMethod(
+            getCreateServiceMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                context.ContextOuterClass.Service,
+                context.ContextOuterClass.ServiceId>(
+                  this, METHODID_CREATE_SERVICE)))
+          .addMethod(
+            getUpdateServiceMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                context.ContextOuterClass.Service,
+                context.ContextOuterClass.ServiceId>(
+                  this, METHODID_UPDATE_SERVICE)))
+          .addMethod(
+            getDeleteServiceMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                context.ContextOuterClass.ServiceId,
+                context.ContextOuterClass.Empty>(
+                  this, METHODID_DELETE_SERVICE)))
+          .build();
+    }
+  }
+
+  /**
+   */
+  public static final class ServiceServiceStub extends io.grpc.stub.AbstractAsyncStub<ServiceServiceStub> {
+    private ServiceServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServiceServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServiceServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void createService(context.ContextOuterClass.Service request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCreateServiceMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void updateService(context.ContextOuterClass.Service request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUpdateServiceMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void deleteService(context.ContextOuterClass.ServiceId request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getDeleteServiceMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   */
+  public static final class ServiceServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<ServiceServiceBlockingStub> {
+    private ServiceServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServiceServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServiceServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public context.ContextOuterClass.ServiceId createService(context.ContextOuterClass.Service request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCreateServiceMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public context.ContextOuterClass.ServiceId updateService(context.ContextOuterClass.Service request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUpdateServiceMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public context.ContextOuterClass.Empty deleteService(context.ContextOuterClass.ServiceId request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getDeleteServiceMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   */
+  public static final class ServiceServiceFutureStub extends io.grpc.stub.AbstractFutureStub<ServiceServiceFutureStub> {
+    private ServiceServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServiceServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServiceServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.ServiceId> createService(
+        context.ContextOuterClass.Service request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCreateServiceMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.ServiceId> updateService(
+        context.ContextOuterClass.Service request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUpdateServiceMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> deleteService(
+        context.ContextOuterClass.ServiceId request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getDeleteServiceMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_CREATE_SERVICE = 0;
+  private static final int METHODID_UPDATE_SERVICE = 1;
+  private static final int METHODID_DELETE_SERVICE = 2;
+
+  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 ServiceServiceImplBase serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(ServiceServiceImplBase 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_CREATE_SERVICE:
+          serviceImpl.createService((context.ContextOuterClass.Service) request,
+              (io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId>) responseObserver);
+          break;
+        case METHODID_UPDATE_SERVICE:
+          serviceImpl.updateService((context.ContextOuterClass.Service) request,
+              (io.grpc.stub.StreamObserver<context.ContextOuterClass.ServiceId>) responseObserver);
+          break;
+        case METHODID_DELETE_SERVICE:
+          serviceImpl.deleteService((context.ContextOuterClass.ServiceId) 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 ServiceServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ServiceServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return service.Service.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ServiceService");
+    }
+  }
+
+  private static final class ServiceServiceFileDescriptorSupplier
+      extends ServiceServiceBaseDescriptorSupplier {
+    ServiceServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class ServiceServiceMethodDescriptorSupplier
+      extends ServiceServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final String methodName;
+
+    ServiceServiceMethodDescriptorSupplier(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 (ServiceServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ServiceServiceFileDescriptorSupplier())
+              .addMethod(getCreateServiceMethod())
+              .addMethod(getUpdateServiceMethod())
+              .addMethod(getDeleteServiceMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}