fix: add missing proto files

src/automation/src/main/proto/kpi_sample_types.proto

+../../../../../proto/kpi_sample_types.proto
\ No newline at end of file

src/automation/src/main/proto/monitoring.proto

+../../../../../proto/monitoring.proto
\ No newline at end of file

src/automation/target/generated-sources/grpc/device/DeviceService.java

@@ -16,6 +16,8 @@ public interface DeviceService extends MutinyService {
     
     io.smallrye.mutiny.Uni<context.ContextOuterClass.DeviceConfig> getInitialConfig(context.ContextOuterClass.DeviceId request);
     
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorDeviceKpi(device.Device.MonitoringSettings request);
+    
     
     
 

src/automation/target/generated-sources/grpc/device/DeviceServiceBean.java

@@ -47,5 +47,13 @@ public class DeviceServiceBean extends MutinyDeviceServiceGrpc.DeviceServiceImpl
           throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }
     }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorDeviceKpi(device.Device.MonitoringSettings request) {
+       try {
+         return delegate.monitorDeviceKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
 
 }
\ No newline at end of file

src/automation/target/generated-sources/grpc/device/DeviceServiceClient.java

@@ -36,5 +36,9 @@ public class DeviceServiceClient implements DeviceService, MutinyClient<MutinyDe
     public io.smallrye.mutiny.Uni<context.ContextOuterClass.DeviceConfig> getInitialConfig(context.ContextOuterClass.DeviceId request) {
        return stub.getInitialConfig(request);
     }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorDeviceKpi(device.Device.MonitoringSettings request) {
+       return stub.monitorDeviceKpi(request);
+    }
 
 }
\ No newline at end of file

src/automation/target/generated-sources/grpc/device/DeviceServiceGrpc.java

@@ -138,6 +138,37 @@ public final class DeviceServiceGrpc {
     return getGetInitialConfigMethod;
   }
 
+  private static volatile io.grpc.MethodDescriptor<device.Device.MonitoringSettings,
+      context.ContextOuterClass.Empty> getMonitorDeviceKpiMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "MonitorDeviceKpi",
+      requestType = device.Device.MonitoringSettings.class,
+      responseType = context.ContextOuterClass.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<device.Device.MonitoringSettings,
+      context.ContextOuterClass.Empty> getMonitorDeviceKpiMethod() {
+    io.grpc.MethodDescriptor<device.Device.MonitoringSettings, context.ContextOuterClass.Empty> getMonitorDeviceKpiMethod;
+    if ((getMonitorDeviceKpiMethod = DeviceServiceGrpc.getMonitorDeviceKpiMethod) == null) {
+      synchronized (DeviceServiceGrpc.class) {
+        if ((getMonitorDeviceKpiMethod = DeviceServiceGrpc.getMonitorDeviceKpiMethod) == null) {
+          DeviceServiceGrpc.getMonitorDeviceKpiMethod = getMonitorDeviceKpiMethod =
+              io.grpc.MethodDescriptor.<device.Device.MonitoringSettings, context.ContextOuterClass.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "MonitorDeviceKpi"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  device.Device.MonitoringSettings.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  context.ContextOuterClass.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new DeviceServiceMethodDescriptorSupplier("MonitorDeviceKpi"))
+              .build();
+        }
+      }
+    }
+    return getMonitorDeviceKpiMethod;
+  }
+
   /**
    * Creates a new async stub that supports all call types for the service
    */
@@ -214,6 +245,13 @@ public final class DeviceServiceGrpc {
       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInitialConfigMethod(), responseObserver);
     }
 
+    /**
+     */
+    public void monitorDeviceKpi(device.Device.MonitoringSettings request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMonitorDeviceKpiMethod(), responseObserver);
+    }
+
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
       return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
           .addMethod(
@@ -244,6 +282,13 @@ public final class DeviceServiceGrpc {
                 context.ContextOuterClass.DeviceId,
                 context.ContextOuterClass.DeviceConfig>(
                   this, METHODID_GET_INITIAL_CONFIG)))
+          .addMethod(
+            getMonitorDeviceKpiMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                device.Device.MonitoringSettings,
+                context.ContextOuterClass.Empty>(
+                  this, METHODID_MONITOR_DEVICE_KPI)))
           .build();
     }
   }
@@ -293,6 +338,14 @@ public final class DeviceServiceGrpc {
       io.grpc.stub.ClientCalls.asyncUnaryCall(
           getChannel().newCall(getGetInitialConfigMethod(), getCallOptions()), request, responseObserver);
     }
+
+    /**
+     */
+    public void monitorDeviceKpi(device.Device.MonitoringSettings request,
+        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getMonitorDeviceKpiMethod(), getCallOptions()), request, responseObserver);
+    }
   }
 
   /**
@@ -336,6 +389,13 @@ public final class DeviceServiceGrpc {
       return io.grpc.stub.ClientCalls.blockingUnaryCall(
           getChannel(), getGetInitialConfigMethod(), getCallOptions(), request);
     }
+
+    /**
+     */
+    public context.ContextOuterClass.Empty monitorDeviceKpi(device.Device.MonitoringSettings request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getMonitorDeviceKpiMethod(), getCallOptions(), request);
+    }
   }
 
   /**
@@ -383,12 +443,21 @@ public final class DeviceServiceGrpc {
       return io.grpc.stub.ClientCalls.futureUnaryCall(
           getChannel().newCall(getGetInitialConfigMethod(), getCallOptions()), request);
     }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> monitorDeviceKpi(
+        device.Device.MonitoringSettings request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getMonitorDeviceKpiMethod(), getCallOptions()), request);
+    }
   }
 
   private static final int METHODID_ADD_DEVICE = 0;
   private static final int METHODID_CONFIGURE_DEVICE = 1;
   private static final int METHODID_DELETE_DEVICE = 2;
   private static final int METHODID_GET_INITIAL_CONFIG = 3;
+  private static final int METHODID_MONITOR_DEVICE_KPI = 4;
 
   private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
@@ -423,6 +492,10 @@ public final class DeviceServiceGrpc {
           serviceImpl.getInitialConfig((context.ContextOuterClass.DeviceId) request,
               (io.grpc.stub.StreamObserver<context.ContextOuterClass.DeviceConfig>) responseObserver);
           break;
+        case METHODID_MONITOR_DEVICE_KPI:
+          serviceImpl.monitorDeviceKpi((device.Device.MonitoringSettings) request,
+              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
+          break;
         default:
           throw new AssertionError();
       }
@@ -488,6 +561,7 @@ public final class DeviceServiceGrpc {
               .addMethod(getConfigureDeviceMethod())
               .addMethod(getDeleteDeviceMethod())
               .addMethod(getGetInitialConfigMethod())
+              .addMethod(getMonitorDeviceKpiMethod())
               .build();
         }
       }

src/automation/target/generated-sources/grpc/device/MutinyDeviceServiceGrpc.java

@@ -55,6 +55,11 @@ public final class MutinyDeviceServiceGrpc implements io.quarkus.grpc.runtime.Mu
             return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::getInitialConfig);
         }
 
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorDeviceKpi(device.Device.MonitoringSettings request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::monitorDeviceKpi);
+        }
+
     }
 
     
@@ -92,6 +97,11 @@ public final class MutinyDeviceServiceGrpc implements io.quarkus.grpc.runtime.Mu
             throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
         }
 
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorDeviceKpi(device.Device.MonitoringSettings 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(
@@ -122,6 +132,13 @@ public final class MutinyDeviceServiceGrpc implements io.quarkus.grpc.runtime.Mu
                                             context.ContextOuterClass.DeviceId,
                                             context.ContextOuterClass.DeviceConfig>(
                                             this, METHODID_GET_INITIAL_CONFIG, compression)))
+                    .addMethod(
+                            device.DeviceServiceGrpc.getMonitorDeviceKpiMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            device.Device.MonitoringSettings,
+                                            context.ContextOuterClass.Empty>(
+                                            this, METHODID_MONITOR_DEVICE_KPI, compression)))
                     .build();
         }
     }
@@ -130,6 +147,7 @@ public final class MutinyDeviceServiceGrpc implements io.quarkus.grpc.runtime.Mu
     private static final int METHODID_CONFIGURE_DEVICE = 1;
     private static final int METHODID_DELETE_DEVICE = 2;
     private static final int METHODID_GET_INITIAL_CONFIG = 3;
+    private static final int METHODID_MONITOR_DEVICE_KPI = 4;
 
     private static final class MethodHandlers<Req, Resp> implements
             io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
@@ -174,6 +192,12 @@ public final class MutinyDeviceServiceGrpc implements io.quarkus.grpc.runtime.Mu
                             compression,
                             serviceImpl::getInitialConfig);
                     break;
+                case METHODID_MONITOR_DEVICE_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((device.Device.MonitoringSettings) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver,
+                            compression,
+                            serviceImpl::monitorDeviceKpi);
+                    break;
                 default:
                     throw new java.lang.AssertionError();
             }

src/automation/target/generated-sources/grpc/kpi_sample_types/KpiSampleTypes.java

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: kpi_sample_types.proto
+
+package kpi_sample_types;
+
+public final class KpiSampleTypes {
+  private KpiSampleTypes() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  /**
+   * Protobuf enum {@code kpi_sample_types.KpiSampleType}
+   */
+  public enum KpiSampleType
+      implements com.google.protobuf.ProtocolMessageEnum {
+    /**
+     * <code>KPISAMPLETYPE_UNKNOWN = 0;</code>
+     */
+    KPISAMPLETYPE_UNKNOWN(0),
+    /**
+     * <code>KPISAMPLETYPE_PACKETS_TRANSMITTED = 101;</code>
+     */
+    KPISAMPLETYPE_PACKETS_TRANSMITTED(101),
+    /**
+     * <code>KPISAMPLETYPE_PACKETS_RECEIVED = 102;</code>
+     */
+    KPISAMPLETYPE_PACKETS_RECEIVED(102),
+    /**
+     * <code>KPISAMPLETYPE_BYTES_TRANSMITTED = 201;</code>
+     */
+    KPISAMPLETYPE_BYTES_TRANSMITTED(201),
+    /**
+     * <code>KPISAMPLETYPE_BYTES_RECEIVED = 202;</code>
+     */
+    KPISAMPLETYPE_BYTES_RECEIVED(202),
+    UNRECOGNIZED(-1),
+    ;
+
+    /**
+     * <code>KPISAMPLETYPE_UNKNOWN = 0;</code>
+     */
+    public static final int KPISAMPLETYPE_UNKNOWN_VALUE = 0;
+    /**
+     * <code>KPISAMPLETYPE_PACKETS_TRANSMITTED = 101;</code>
+     */
+    public static final int KPISAMPLETYPE_PACKETS_TRANSMITTED_VALUE = 101;
+    /**
+     * <code>KPISAMPLETYPE_PACKETS_RECEIVED = 102;</code>
+     */
+    public static final int KPISAMPLETYPE_PACKETS_RECEIVED_VALUE = 102;
+    /**
+     * <code>KPISAMPLETYPE_BYTES_TRANSMITTED = 201;</code>
+     */
+    public static final int KPISAMPLETYPE_BYTES_TRANSMITTED_VALUE = 201;
+    /**
+     * <code>KPISAMPLETYPE_BYTES_RECEIVED = 202;</code>
+     */
+    public static final int KPISAMPLETYPE_BYTES_RECEIVED_VALUE = 202;
+
+
+    public final int getNumber() {
+      if (this == UNRECOGNIZED) {
+        throw new java.lang.IllegalArgumentException(
+            "Can't get the number of an unknown enum value.");
+      }
+      return value;
+    }
+
+    /**
+     * @param value The numeric wire value of the corresponding enum entry.
+     * @return The enum associated with the given numeric wire value.
+     * @deprecated Use {@link #forNumber(int)} instead.
+     */
+    @java.lang.Deprecated
+    public static KpiSampleType valueOf(int value) {
+      return forNumber(value);
+    }
+
+    /**
+     * @param value The numeric wire value of the corresponding enum entry.
+     * @return The enum associated with the given numeric wire value.
+     */
+    public static KpiSampleType forNumber(int value) {
+      switch (value) {
+        case 0: return KPISAMPLETYPE_UNKNOWN;
+        case 101: return KPISAMPLETYPE_PACKETS_TRANSMITTED;
+        case 102: return KPISAMPLETYPE_PACKETS_RECEIVED;
+        case 201: return KPISAMPLETYPE_BYTES_TRANSMITTED;
+        case 202: return KPISAMPLETYPE_BYTES_RECEIVED;
+        default: return null;
+      }
+    }
+
+    public static com.google.protobuf.Internal.EnumLiteMap<KpiSampleType>
+        internalGetValueMap() {
+      return internalValueMap;
+    }
+    private static final com.google.protobuf.Internal.EnumLiteMap<
+        KpiSampleType> internalValueMap =
+          new com.google.protobuf.Internal.EnumLiteMap<KpiSampleType>() {
+            public KpiSampleType findValueByNumber(int number) {
+              return KpiSampleType.forNumber(number);
+            }
+          };
+
+    public final com.google.protobuf.Descriptors.EnumValueDescriptor
+        getValueDescriptor() {
+      if (this == UNRECOGNIZED) {
+        throw new java.lang.IllegalStateException(
+            "Can't get the descriptor of an unrecognized enum value.");
+      }
+      return getDescriptor().getValues().get(ordinal());
+    }
+    public final com.google.protobuf.Descriptors.EnumDescriptor
+        getDescriptorForType() {
+      return getDescriptor();
+    }
+    public static final com.google.protobuf.Descriptors.EnumDescriptor
+        getDescriptor() {
+      return kpi_sample_types.KpiSampleTypes.getDescriptor().getEnumTypes().get(0);
+    }
+
+    private static final KpiSampleType[] VALUES = values();
+
+    public static KpiSampleType valueOf(
+        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+      if (desc.getType() != getDescriptor()) {
+        throw new java.lang.IllegalArgumentException(
+          "EnumValueDescriptor is not for this type.");
+      }
+      if (desc.getIndex() == -1) {
+        return UNRECOGNIZED;
+      }
+      return VALUES[desc.getIndex()];
+    }
+
+    private final int value;
+
+    private KpiSampleType(int value) {
+      this.value = value;
+    }
+
+    // @@protoc_insertion_point(enum_scope:kpi_sample_types.KpiSampleType)
+  }
+
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n\026kpi_sample_types.proto\022\020kpi_sample_typ" +
+      "es*\276\001\n\rKpiSampleType\022\031\n\025KPISAMPLETYPE_UN" +
+      "KNOWN\020\000\022%\n!KPISAMPLETYPE_PACKETS_TRANSMI" +
+      "TTED\020e\022\"\n\036KPISAMPLETYPE_PACKETS_RECEIVED" +
+      "\020f\022$\n\037KPISAMPLETYPE_BYTES_TRANSMITTED\020\311\001" +
+      "\022!\n\034KPISAMPLETYPE_BYTES_RECEIVED\020\312\001b\006pro" +
+      "to3"
+    };
+    descriptor = com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}

src/automation/target/generated-sources/grpc/monitoring/MonitoringService.java

+package monitoring;
+
+import io.quarkus.grpc.runtime.MutinyService;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: monitoring.proto")
+public interface MonitoringService extends MutinyService {
+
+    
+    io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiId> createKpi(monitoring.Monitoring.KpiDescriptor request);
+    
+    io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(monitoring.Monitoring.KpiId request);
+    
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> includeKpi(monitoring.Monitoring.Kpi request);
+    
+    io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorKpi(monitoring.Monitoring.MonitorKpiRequest request);
+    
+    io.smallrye.mutiny.Uni<monitoring.Monitoring.Kpi> getInstantKpi(monitoring.Monitoring.KpiId request);
+    
+    
+    io.smallrye.mutiny.Multi<monitoring.Monitoring.Kpi> getStreamKpi(monitoring.Monitoring.KpiId request);
+    
+    
+
+}
\ No newline at end of file

src/automation/target/generated-sources/grpc/monitoring/MonitoringServiceBean.java

+package monitoring;
+
+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: monitoring.proto")
+public class MonitoringServiceBean extends MutinyMonitoringServiceGrpc.MonitoringServiceImplBase implements BindableService, MutinyBean {
+
+    private final MonitoringService delegate;
+
+    MonitoringServiceBean(@GrpcService MonitoringService delegate) {
+       this.delegate = delegate;
+    }
+
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiId> createKpi(monitoring.Monitoring.KpiDescriptor request) {
+       try {
+         return delegate.createKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(monitoring.Monitoring.KpiId request) {
+       try {
+         return delegate.getKpiDescriptor(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> includeKpi(monitoring.Monitoring.Kpi request) {
+       try {
+         return delegate.includeKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorKpi(monitoring.Monitoring.MonitorKpiRequest request) {
+       try {
+         return delegate.monitorKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.Kpi> getInstantKpi(monitoring.Monitoring.KpiId request) {
+       try {
+         return delegate.getInstantKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+
+    @Override
+    public io.smallrye.mutiny.Multi<monitoring.Monitoring.Kpi> getStreamKpi(monitoring.Monitoring.KpiId request) {
+       try {
+         return delegate.getStreamKpi(request);
+       } catch (UnsupportedOperationException e) {
+          throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+       }
+    }
+
+}
\ No newline at end of file

src/automation/target/generated-sources/grpc/monitoring/MonitoringServiceClient.java

+package monitoring;
+
+import java.util.function.BiFunction;
+
+import io.quarkus.grpc.runtime.MutinyClient;
+
+@javax.annotation.Generated(
+value = "by Mutiny Grpc generator",
+comments = "Source: monitoring.proto")
+public class MonitoringServiceClient implements MonitoringService, MutinyClient<MutinyMonitoringServiceGrpc.MutinyMonitoringServiceStub> {
+
+    private final MutinyMonitoringServiceGrpc.MutinyMonitoringServiceStub stub;
+
+    public MonitoringServiceClient(String name, io.grpc.Channel channel, BiFunction<String, MutinyMonitoringServiceGrpc.MutinyMonitoringServiceStub, MutinyMonitoringServiceGrpc.MutinyMonitoringServiceStub> stubConfigurator) {
+       this.stub = stubConfigurator.apply(name,MutinyMonitoringServiceGrpc.newMutinyStub(channel));
+    }
+
+    @Override
+    public MutinyMonitoringServiceGrpc.MutinyMonitoringServiceStub getStub() {
+       return stub;
+    }
+
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiId> createKpi(monitoring.Monitoring.KpiDescriptor request) {
+       return stub.createKpi(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(monitoring.Monitoring.KpiId request) {
+       return stub.getKpiDescriptor(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> includeKpi(monitoring.Monitoring.Kpi request) {
+       return stub.includeKpi(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorKpi(monitoring.Monitoring.MonitorKpiRequest request) {
+       return stub.monitorKpi(request);
+    }
+    @Override
+    public io.smallrye.mutiny.Uni<monitoring.Monitoring.Kpi> getInstantKpi(monitoring.Monitoring.KpiId request) {
+       return stub.getInstantKpi(request);
+    }
+
+    @Override
+    public io.smallrye.mutiny.Multi<monitoring.Monitoring.Kpi> getStreamKpi(monitoring.Monitoring.KpiId request) {
+       return stub.getStreamKpi(request);
+    }
+
+}
\ No newline at end of file

src/automation/target/generated-sources/grpc/monitoring/MutinyMonitoringServiceGrpc.java

+package monitoring;
+
+import static monitoring.MonitoringServiceGrpc.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: monitoring.proto")
+public final class MutinyMonitoringServiceGrpc implements io.quarkus.grpc.runtime.MutinyGrpc {
+    private MutinyMonitoringServiceGrpc() {}
+
+    public static MutinyMonitoringServiceStub newMutinyStub(io.grpc.Channel channel) {
+        return new MutinyMonitoringServiceStub(channel);
+    }
+
+    
+    public static final class MutinyMonitoringServiceStub extends io.grpc.stub.AbstractStub<MutinyMonitoringServiceStub> implements io.quarkus.grpc.runtime.MutinyStub {
+        private MonitoringServiceGrpc.MonitoringServiceStub delegateStub;
+
+        private MutinyMonitoringServiceStub(io.grpc.Channel channel) {
+            super(channel);
+            delegateStub = MonitoringServiceGrpc.newStub(channel);
+        }
+
+        private MutinyMonitoringServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            super(channel, callOptions);
+            delegateStub = MonitoringServiceGrpc.newStub(channel).build(channel, callOptions);
+        }
+
+        @Override
+        protected MutinyMonitoringServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            return new MutinyMonitoringServiceStub(channel, callOptions);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiId> createKpi(monitoring.Monitoring.KpiDescriptor request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::createKpi);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(monitoring.Monitoring.KpiId request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::getKpiDescriptor);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> includeKpi(monitoring.Monitoring.Kpi request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::includeKpi);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorKpi(monitoring.Monitoring.MonitorKpiRequest request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::monitorKpi);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.Kpi> getInstantKpi(monitoring.Monitoring.KpiId request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::getInstantKpi);
+        }
+
+        
+        public io.smallrye.mutiny.Multi<monitoring.Monitoring.Kpi> getStreamKpi(monitoring.Monitoring.KpiId request) {
+            return io.quarkus.grpc.runtime.ClientCalls.oneToMany(request, delegateStub::getStreamKpi);
+        }
+
+    }
+
+    
+    public static abstract class MonitoringServiceImplBase 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 MonitoringServiceImplBase withCompression(String compression) {
+        this.compression = compression;
+        return this;
+        }
+
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiId> createKpi(monitoring.Monitoring.KpiDescriptor request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(monitoring.Monitoring.KpiId request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> includeKpi(monitoring.Monitoring.Kpi request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<context.ContextOuterClass.Empty> monitorKpi(monitoring.Monitoring.MonitorKpiRequest request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Uni<monitoring.Monitoring.Kpi> getInstantKpi(monitoring.Monitoring.KpiId request) {
+            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
+        }
+
+        
+        public io.smallrye.mutiny.Multi<monitoring.Monitoring.Kpi> getStreamKpi(monitoring.Monitoring.KpiId 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(
+                            monitoring.MonitoringServiceGrpc.getCreateKpiMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.KpiDescriptor,
+                                            monitoring.Monitoring.KpiId>(
+                                            this, METHODID_CREATE_KPI, compression)))
+                    .addMethod(
+                            monitoring.MonitoringServiceGrpc.getGetKpiDescriptorMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.KpiId,
+                                            monitoring.Monitoring.KpiDescriptor>(
+                                            this, METHODID_GET_KPI_DESCRIPTOR, compression)))
+                    .addMethod(
+                            monitoring.MonitoringServiceGrpc.getIncludeKpiMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.Kpi,
+                                            context.ContextOuterClass.Empty>(
+                                            this, METHODID_INCLUDE_KPI, compression)))
+                    .addMethod(
+                            monitoring.MonitoringServiceGrpc.getMonitorKpiMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.MonitorKpiRequest,
+                                            context.ContextOuterClass.Empty>(
+                                            this, METHODID_MONITOR_KPI, compression)))
+                    .addMethod(
+                            monitoring.MonitoringServiceGrpc.getGetStreamKpiMethod(),
+                            asyncServerStreamingCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.KpiId,
+                                            monitoring.Monitoring.Kpi>(
+                                            this, METHODID_GET_STREAM_KPI, compression)))
+                    .addMethod(
+                            monitoring.MonitoringServiceGrpc.getGetInstantKpiMethod(),
+                            asyncUnaryCall(
+                                    new MethodHandlers<
+                                            monitoring.Monitoring.KpiId,
+                                            monitoring.Monitoring.Kpi>(
+                                            this, METHODID_GET_INSTANT_KPI, compression)))
+                    .build();
+        }
+    }
+
+    private static final int METHODID_CREATE_KPI = 0;
+    private static final int METHODID_GET_KPI_DESCRIPTOR = 1;
+    private static final int METHODID_INCLUDE_KPI = 2;
+    private static final int METHODID_MONITOR_KPI = 3;
+    private static final int METHODID_GET_STREAM_KPI = 4;
+    private static final int METHODID_GET_INSTANT_KPI = 5;
+
+    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 MonitoringServiceImplBase serviceImpl;
+        private final int methodId;
+        private final String compression;
+
+        MethodHandlers(MonitoringServiceImplBase 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_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((monitoring.Monitoring.KpiDescriptor) request,
+                            (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId>) responseObserver,
+                            compression,
+                            serviceImpl::createKpi);
+                    break;
+                case METHODID_GET_KPI_DESCRIPTOR:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((monitoring.Monitoring.KpiId) request,
+                            (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptor>) responseObserver,
+                            compression,
+                            serviceImpl::getKpiDescriptor);
+                    break;
+                case METHODID_INCLUDE_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((monitoring.Monitoring.Kpi) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver,
+                            compression,
+                            serviceImpl::includeKpi);
+                    break;
+                case METHODID_MONITOR_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((monitoring.Monitoring.MonitorKpiRequest) request,
+                            (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver,
+                            compression,
+                            serviceImpl::monitorKpi);
+                    break;
+                case METHODID_GET_STREAM_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToMany((monitoring.Monitoring.KpiId) request,
+                            (io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi>) responseObserver,
+                            compression,
+                            serviceImpl::getStreamKpi);
+                    break;
+                case METHODID_GET_INSTANT_KPI:
+                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((monitoring.Monitoring.KpiId) request,
+                            (io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi>) responseObserver,
+                            compression,
+                            serviceImpl::getInstantKpi);
+                    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/automation/target/kubernetes/kubernetes.yml

@@ -3,8 +3,8 @@ apiVersion: v1
 kind: Service
 metadata:
   annotations:
-    app.quarkus.io/commit-id: 6b96f471f66e6bb59357856c635f8d7e1ce98a5c
-    app.quarkus.io/build-timestamp: 2021-11-19 - 15:03:07 +0000
+    app.quarkus.io/commit-id: cb66db4bc415be2e94c17f4152e9805301b202b5
+    app.quarkus.io/build-timestamp: 2022-01-05 - 10:42:14 +0000
   labels:
     app.kubernetes.io/name: automationservice
     app.kubernetes.io/version: 0.0.1
@@ -12,12 +12,12 @@ metadata:
   name: automationservice
 spec:
   ports:
-    - name: http
-      port: 8080
-      targetPort: 8080
     - name: grpc-server
       port: 9999
       targetPort: 9999
+    - name: http
+      port: 8080
+      targetPort: 8080
   selector:
     app.kubernetes.io/name: automationservice
     app.kubernetes.io/version: 0.0.1
@@ -27,28 +27,28 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   annotations:
-    app.quarkus.io/commit-id: 6b96f471f66e6bb59357856c635f8d7e1ce98a5c
-    app.quarkus.io/build-timestamp: 2021-11-19 - 15:03:07 +0000
+    app.quarkus.io/commit-id: cb66db4bc415be2e94c17f4152e9805301b202b5
+    app.quarkus.io/build-timestamp: 2022-01-05 - 10:42:14 +0000
   labels:
     app: automationservice
-    app.kubernetes.io/name: automationservice
     app.kubernetes.io/version: 0.0.1
+    app.kubernetes.io/name: automationservice
   name: automationservice
 spec:
   replicas: 1
   selector:
     matchLabels:
-      app.kubernetes.io/name: automationservice
       app.kubernetes.io/version: 0.0.1
+      app.kubernetes.io/name: automationservice
   template:
     metadata:
       annotations:
-        app.quarkus.io/commit-id: 6b96f471f66e6bb59357856c635f8d7e1ce98a5c
-        app.quarkus.io/build-timestamp: 2021-11-19 - 15:03:07 +0000
+        app.quarkus.io/commit-id: cb66db4bc415be2e94c17f4152e9805301b202b5
+        app.quarkus.io/build-timestamp: 2022-01-05 - 10:42:14 +0000
       labels:
         app: automationservice
-        app.kubernetes.io/name: automationservice
         app.kubernetes.io/version: 0.0.1
+        app.kubernetes.io/name: automationservice
     spec:
       containers:
         - env:
@@ -74,12 +74,12 @@ spec:
             timeoutSeconds: 10
           name: automationservice
           ports:
-            - containerPort: 8080
-              name: http
-              protocol: TCP
             - containerPort: 9999
               name: grpc-server
               protocol: TCP
+            - containerPort: 8080
+              name: http
+              protocol: TCP
           readinessProbe:
             failureThreshold: 3
             httpGet: