feat: add meta proto service for service discovery

protobuf/CMakeLists.txt

@@ -3,3 +3,4 @@ add_subdirectory(echo)
 add_subdirectory(protoc_echo_plugin)
 add_subdirectory(protoc_echo_plugin_csharp)
 add_subdirectory(protoc_echo_plugin_java)
+add_subdirectory(meta_services)

protobuf/echo/test_doubles/ServiceStub.cpp

@@ -1,4 +1,5 @@
 #include "protobuf/echo/test_doubles/ServiceStub.hpp"
+#include <cstdint>
 
 namespace services
 {
@@ -26,8 +27,9 @@ namespace services
         return value;
     }
 
-    ServiceStub::ServiceStub(Echo& echo)
+    ServiceStub::ServiceStub(Echo& echo, uint32_t serviceId)
         : Service(echo)
+        , serviceId(serviceId)
     {}
 
     bool ServiceStub::AcceptsService(uint32_t id) const
@@ -55,8 +57,9 @@ namespace services
         }
     }
 
-    ServiceStubProxy::ServiceStubProxy(services::Echo& echo)
+    ServiceStubProxy::ServiceStubProxy(services::Echo& echo, uint32_t serviceId)
         : services::ServiceProxy(echo, maxMessageSize)
+        , serviceId(serviceId)
     {}
 
     void ServiceStubProxy::Method(uint32_t value)

protobuf/echo/test_doubles/ServiceStub.hpp

@@ -3,6 +3,7 @@
 
 #include "protobuf/echo/Echo.hpp"
 #include "gmock/gmock.h"
+#include <cstdint>
 
 namespace services
 {
@@ -37,7 +38,7 @@ namespace services
         : public services::Service
     {
     public:
-        ServiceStub(Echo& echo);
+        ServiceStub(Echo& echo, uint32_t serviceId = defaultServiceId);
 
         bool AcceptsService(uint32_t id) const override;
 
@@ -48,33 +49,39 @@ namespace services
         infra::SharedPtr<MethodDeserializer> StartMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy) override;
 
     public:
-        static const uint32_t serviceId = 1;
+        static constexpr uint32_t defaultServiceId = 1;
         static const uint32_t idMethod = 1;
         static const uint32_t idMethodNoParameter = 3;
         static const uint32_t maxMessageSize = 18;
 
     public:
         using MethodTypeList = infra::List<Message, EmptyMessage>;
+
+    private:
+        const uint32_t serviceId;
     };
 
     class ServiceStubProxy
         : public services::ServiceProxy
     {
     public:
-        ServiceStubProxy(services::Echo& echo);
+        ServiceStubProxy(services::Echo& echo, uint32_t serviceId = defaultServiceId);
 
     public:
         void Method(uint32_t value);
         void MethodNoParameter();
 
     public:
-        static constexpr uint32_t serviceId = 1;
+        static constexpr uint32_t defaultServiceId = 1;
         static constexpr uint32_t idMethod = 1;
         static const uint32_t idMethodNoParameter = 3;
         static constexpr uint32_t maxMessageSize = 18;
 
     public:
         using MethodTypeList = infra::List<Message, EmptyMessage>;
+
+    private:
+        const uint32_t serviceId;
     };
 }
 

protobuf/meta_services/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_library(protobuf.meta_services ${EMIL_EXCLUDE_FROM_ALL} STATIC)
+
+protocol_buffer_csharp(protobuf.meta_services ServiceDiscovery.proto)
+protocol_buffer_java(protobuf.meta_services ServiceDiscovery.proto)
+protocol_buffer_echo_all(protobuf.meta_services ServiceDiscovery.proto)
+
+target_sources(protobuf.meta_services PRIVATE
+    ServiceDiscoveryEcho.cpp
+    ServiceDiscoveryEcho.hpp
+)
+
+add_subdirectory(test)
+

protobuf/meta_services/ServiceDiscovery.proto

@@ -0,0 +1,40 @@
+syntax = "proto3";
+
+import "EchoAttributes.proto";
+
+package service_discovery;
+option java_package = "com.philips.emil.protobufEcho";
+option java_outer_classname = "ServiceDiscoveryProto";
+
+message Uint32Value {
+    uint32 value = 1;
+}
+
+message BoolValue
+{
+    bool value = 1;
+}
+
+message ServiceRange
+{
+    uint32 startServiceId = 1;
+    uint32 endServiceId = 2;
+}
+
+service ServiceDiscovery
+{
+    option (service_id) = 1000;
+
+    rpc FindFirstServiceInRange(ServiceRange) returns (Nothing) { option (method_id) = 1; }
+    rpc NotifyServiceChanges(BoolValue) returns (Nothing)  { option (method_id) = 2; } 
+}
+
+service ServiceDiscoveryResponse
+{
+    option (service_id) = 1001;
+
+    rpc FirstServiceSupported(Uint32Value) returns (Nothing) { option (method_id) = 1; }
+    rpc NoServiceSupported(Nothing) returns (Nothing) { option (method_id) = 2; }
+    rpc ServicesChanged(Nothing) returns (Nothing) { option (method_id) = 3; }
+}
+

protobuf/meta_services/ServiceDiscoveryEcho.cpp

@@ -0,0 +1,127 @@
+#include "protobuf/meta_services/ServiceDiscoveryEcho.hpp"
+#include "echo/ServiceDiscovery.pb.hpp"
+#include "infra/util/Optional.hpp"
+#include "protobuf/echo/Echo.hpp"
+#include <cstdint>
+#include <tuple>
+
+namespace application
+{
+    void ServiceDiscoveryEcho::FindFirstServiceInRange(uint32_t startServiceId, uint32_t endServiceId)
+    {
+        auto service = FirstSupportedServiceId(startServiceId, endServiceId);
+
+        service_discovery::ServiceDiscoveryResponseProxy::RequestSend([this, service]
+            {
+                if (service)
+                    FirstServiceSupported(*service);
+                else
+                    NoServiceSupported();
+            });
+
+        MethodDone();
+    }
+
+    infra::Optional<uint32_t> ServiceDiscoveryEcho::FirstSupportedServiceId(uint32_t startServiceId, uint32_t endServiceId)
+    {
+        for (auto id = startServiceId; id <= endServiceId; ++id)
+            if (AcceptsService(id))
+                return infra::MakeOptional(id);
+
+        return infra::none;
+    }
+
+    void ServiceDiscoveryEcho::NotifyServiceChanges(bool value)
+    {
+        notifyServiceChanges = value;
+
+        MethodDone();
+    }
+
+    bool ServiceDiscoveryEcho::AcceptsService(uint32_t serviceId) const
+    {
+        return service_discovery::ServiceDiscovery::AcceptsService(serviceId) 
+                || IsProxyServiceSupported(serviceId);
+    }
+
+    infra::SharedPtr<services::MethodDeserializer> ServiceDiscoveryEcho::StartMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy)
+    {
+        if (service_discovery::ServiceDiscovery::AcceptsService(serviceId))
+            return service_discovery::ServiceDiscovery::StartMethod(serviceId, methodId, size, errorPolicy);
+        else
+            return StartProxyServiceMethod(serviceId, methodId, size, errorPolicy);
+    }
+
+    infra::SharedPtr<services::MethodDeserializer> ServiceDiscoveryEcho::StartProxyServiceMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy)
+    {
+        infra::SharedPtr<services::MethodDeserializer> methodSerializer;
+
+        auto startMethodArgs = std::tie(serviceId, methodId, size, errorPolicy);
+        NotifyObservers([&methodSerializer, &startMethodArgs](auto& obs)
+            {
+                if(obs.AcceptsService(std::get<0>(startMethodArgs)))
+                {
+                    methodSerializer = obs.StartMethod(std::get<0>(startMethodArgs), std::get<1>(startMethodArgs), std::get<2>(startMethodArgs), std::get<3>(startMethodArgs));
+                    return true;
+                }
+
+                return false;
+            });
+
+        return methodSerializer;
+    }
+
+    bool ServiceDiscoveryEcho::IsProxyServiceSupported(uint32_t serviceId) const
+    {
+        return services::Echo::NotifyObservers([serviceId](auto& observer)
+            {
+                if (observer.AcceptsService(serviceId))
+                    return true;
+                else
+                    return false;
+            });
+    }
+
+    void ServiceDiscoveryEcho::RequestSend(ServiceProxy& serviceProxy)
+    {
+        UpstreamRpc().RequestSend(serviceProxy);
+    }
+
+    void ServiceDiscoveryEcho::ServiceDone()
+    {
+        UpstreamRpc().ServiceDone();
+    }
+
+    services::MethodSerializerFactory& ServiceDiscoveryEcho::SerializerFactory()
+    {
+        return UpstreamRpc().SerializerFactory();
+    }
+
+    services::Echo& ServiceDiscoveryEcho::UpstreamRpc()
+    {
+        return service_discovery::ServiceDiscovery::Rpc();
+    }
+
+    void ServiceDiscoveryEcho::RegisterObserver(infra::Observer<Service, Echo>* observer)
+    {
+        services::Echo::RegisterObserver(observer);
+
+        ServicesChangeNotification();
+    }
+
+    void ServiceDiscoveryEcho::UnregisterObserver(infra::Observer<Service, Echo>* observer)
+    {
+        services::Echo::UnregisterObserver(observer);
+
+        ServicesChangeNotification();
+    }
+
+    void ServiceDiscoveryEcho::ServicesChangeNotification()
+    {
+        if (notifyServiceChanges)
+            service_discovery::ServiceDiscoveryResponseProxy::RequestSend([this]
+                {
+                    ServicesChanged();
+                });
+    }
+}

protobuf/meta_services/ServiceDiscoveryEcho.hpp

@@ -0,0 +1,51 @@
+#ifndef PROTOBUF_ECHO_SERVICE_DISCOVERY_HPP
+#define PROTOBUF_ECHO_SERVICE_DISCOVERY_HPP
+
+#include "generated/echo/ServiceDiscovery.pb.hpp"
+#include "protobuf/echo/Echo.hpp"
+#include <cstdint>
+
+namespace application
+{
+    class ServiceDiscoveryEcho
+        : public service_discovery::ServiceDiscovery
+        , public service_discovery::ServiceDiscoveryResponseProxy
+        , public services::Echo
+    {
+    public:
+        explicit ServiceDiscoveryEcho(services::Echo& echo)
+            : service_discovery::ServiceDiscovery(echo)
+            , service_discovery::ServiceDiscoveryResponseProxy(echo)
+        {}
+
+        virtual ~ServiceDiscoveryEcho() = default;
+
+        //Implementation of services::ServiceDiscovery
+        void FindFirstServiceInRange(uint32_t startServiceId, uint32_t endServiceId) override;
+        void NotifyServiceChanges(bool value) override;
+
+        //Implementation of services::Service
+        bool AcceptsService(uint32_t id) const override;
+        infra::SharedPtr<services::MethodDeserializer> StartMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy) override;
+
+        //Implementation of services::Echo
+        void RequestSend(ServiceProxy& serviceProxy) override;
+        void ServiceDone() override;
+        services::MethodSerializerFactory& SerializerFactory() override;
+
+    private:
+        void RegisterObserver(infra::Observer<Service, Echo>* observer) override;
+        void UnregisterObserver(infra::Observer<Service, Echo>* observer) override;
+
+        infra::Optional<uint32_t> FirstSupportedServiceId(uint32_t startServiceId, uint32_t endServiceId);
+        bool IsProxyServiceSupported(uint32_t serviceId) const;
+        infra::SharedPtr<services::MethodDeserializer> StartProxyServiceMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy);
+        services::Echo& UpstreamRpc();
+        void ServicesChangeNotification();
+
+    private:
+        bool notifyServiceChanges = false;
+    };
+}
+
+#endif

protobuf/meta_services/test/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_executable(protobuf.meta_services_test)
+emil_build_for(protobuf.meta_services_test BOOL EMIL_BUILD_TESTS)
+emil_add_test(protobuf.meta_services_test)
+
+target_sources(protobuf.meta_services_test PRIVATE
+    TestServiceDiscoveryEcho.cpp
+)
+
+target_link_libraries(protobuf.meta_services_test PUBLIC
+    gmock_main
+    protobuf.test_doubles
+    protobuf.meta_services
+)