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/Echo.cpp

@@ -2,6 +2,20 @@
 
 namespace services
 {
+    ServiceId::ServiceId(uint32_t id)
+        : id(id)
+    {}
+
+    Service::Service(Echo& echo, uint32_t serviceId)
+        : ServiceId(serviceId)
+        , infra::Observer<Service, Echo>(echo)
+    {}
+
+    uint32_t ServiceIdAccess::GetId(const ServiceId& serviceId)
+    {
+        return serviceId.id;
+    }
+
     void Service::MethodDone()
     {
         Rpc().ServiceDone();

protobuf/echo/Echo.hpp

@@ -10,20 +10,43 @@
 #include "protobuf/echo/EchoErrorPolicy.hpp"
 #include "protobuf/echo/Proto.hpp"
 #include "protobuf/echo/Serialization.hpp"
+#include <cstdint>
 
 namespace services
 {
     class Echo;
+    class ServiceId;
     class Service;
     class ServiceProxy;
 
-    class Service
-        : public infra::Observer<Service, Echo>
+    class ServiceIdAccess
     {
     public:
-        using infra::Observer<Service, Echo>::Observer;
+        static uint32_t GetId(const ServiceId& serviceId);
+    };
+
+    class ServiceId
+    {
+        friend class ServiceIdAccess;
+
+    public:
+        ServiceId(uint32_t id);
+
+        virtual bool AcceptsService(uint32_t id) const
+        {
+            return id == this->id;
+        }
 
-        virtual bool AcceptsService(uint32_t id) const = 0;
+    private:
+        const uint32_t id;
+    };
+
+    class Service
+        : public ServiceId
+        , public infra::Observer<Service, Echo>
+    {
+    public:
+        Service(Echo& echo, uint32_t serviceId);
 
         void MethodDone();
         virtual infra::SharedPtr<MethodDeserializer> StartMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const EchoErrorPolicy& errorPolicy) = 0;

protobuf/echo/ServiceForwarder.cpp

@@ -3,7 +3,7 @@
 namespace services
 {
     ServiceForwarderBase::ServiceForwarderBase(Echo& echo, Echo& forwardTo)
-        : Service(echo)
+        : Service(echo, 0)
         , ServiceProxy(forwardTo, 0)
     {}
 

protobuf/echo/test_doubles/ServiceStub.cpp

@@ -1,4 +1,5 @@
 #include "protobuf/echo/test_doubles/ServiceStub.hpp"
+#include <cstdint>
 
 namespace services
 {
@@ -26,15 +27,10 @@ namespace services
         return value;
     }
 
-    ServiceStub::ServiceStub(Echo& echo)
-        : Service(echo)
+    ServiceStub::ServiceStub(Echo& echo, uint32_t serviceId)
+        : Service(echo, serviceId)
     {}
 
-    bool ServiceStub::AcceptsService(uint32_t id) const
-    {
-        return id == serviceId;
-    }
-
     infra::SharedPtr<MethodDeserializer> ServiceStub::StartMethod(uint32_t serviceId, uint32_t methodId, uint32_t size, const services::EchoErrorPolicy& errorPolicy)
     {
         switch (methodId)
@@ -55,8 +51,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,9 +38,7 @@ namespace services
         : public services::Service
     {
     public:
-        ServiceStub(Echo& echo);
-
-        bool AcceptsService(uint32_t id) const override;
+        ServiceStub(Echo& echo, uint32_t serviceId = defaultServiceId);
 
         MOCK_METHOD(void, Method, (uint32_t value));
         MOCK_METHOD(void, MethodNoParameter, ());
@@ -48,7 +47,7 @@ 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;
@@ -61,20 +60,23 @@ namespace services
         : 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,20 @@
+add_library(protobuf.meta_services ${EMIL_EXCLUDE_FROM_ALL} STATIC)
+
+target_include_directories(protobuf.meta_services PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/../..>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+
+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
+    PeerServiceDiscoverer.cpp
+    PeerServiceDiscoverer.hpp
+    ServiceDiscoveryEcho.cpp
+    ServiceDiscoveryEcho.hpp
+)
+
+add_subdirectory(test)
+

protobuf/meta_services/PeerServiceDiscoverer.cpp

@@ -0,0 +1,92 @@
+#include "protobuf/meta_services/PeerServiceDiscoverer.hpp"
+#include "infra/event/EventDispatcher.hpp"
+#include "infra/util/Function.hpp"
+#include <cstdint>
+#include <limits>
+
+namespace application
+{
+    PeerServiceDiscovererEcho::PeerServiceDiscovererEcho(services::Echo& echo)
+        : service_discovery::ServiceDiscoveryProxy(echo)
+        , service_discovery::ServiceDiscoveryResponse(echo)
+    {
+        DiscoverPeerServices();
+    }
+
+    void PeerServiceDiscovererEcho::NoServiceSupported()
+    {
+        NotifyObservers([this](auto& observer)
+            {
+                observer.ServicesDiscovered(services.range());
+            });
+
+        MethodDone();
+    }
+
+    void PeerServiceDiscovererEcho::FirstServiceSupported(uint32_t id)
+    {
+        services.push_back(id);
+
+        if (id == SearchRangeEnd())
+            NotifyObservers([this](auto& observer)
+                {
+                    observer.ServicesDiscovered(services.range());
+                });
+        else
+            RequestSend([this]
+                {
+                    FindFirstServiceInRange(services.back() + 1, SearchRangeEnd());
+                });
+
+        MethodDone();
+    }
+
+    void PeerServiceDiscovererEcho::ServicesChanged(uint32_t startServiceId, uint32_t endServiceId)
+    {
+        searchRange = ServiceRange{ startServiceId, endServiceId };
+
+        StartDiscovery();
+
+        MethodDone();
+    }
+
+    void PeerServiceDiscovererEcho::DiscoverPeerServices()
+    {
+        searchRange = serviceRangeMax;
+
+        RequestSend([this]
+            {
+                NotifyServiceChanges(true);
+                StartDiscovery();
+            });
+    }
+
+    void PeerServiceDiscovererEcho::ClearUpdatedServices()
+    {
+        services.erase(std::remove_if(services.begin(), services.end(), [this](uint32_t serviceId)
+                           {
+                               return serviceId >= SearchRangeBegin() && serviceId <= SearchRangeEnd();
+                           }),
+            services.end());
+    }
+
+    void PeerServiceDiscovererEcho::StartDiscovery()
+    {
+        ClearUpdatedServices();
+
+        RequestSend([this]
+            {
+                FindFirstServiceInRange(SearchRangeBegin(), SearchRangeEnd());
+            });
+    }
+
+    uint32_t PeerServiceDiscovererEcho::SearchRangeBegin() const
+    {
+        return std::get<0>(searchRange);
+    }
+
+    uint32_t PeerServiceDiscovererEcho::SearchRangeEnd() const
+    {
+        return std::get<1>(searchRange);
+    }
+}

protobuf/meta_services/PeerServiceDiscoverer.hpp

@@ -0,0 +1,55 @@
+#ifndef PROTOBUF_ECHO_PEER_SERVICE_DISCOVERER_HPP
+#define PROTOBUF_ECHO_PEER_SERVICE_DISCOVERER_HPP
+
+#include "generated/echo/ServiceDiscovery.pb.hpp"
+#include "infra/syntax/CppFormatter.hpp"
+#include "infra/util/BoundedVector.hpp"
+#include "infra/util/MemoryRange.hpp"
+#include "infra/util/Observer.hpp"
+#include "protobuf/echo/Echo.hpp"
+#include <cstdint>
+#include <tuple>
+
+namespace application
+{
+    class PeerServiceDiscovererEcho;
+
+    class PeerServiceDiscoveryObserver
+        : public infra::SingleObserver<PeerServiceDiscoveryObserver, PeerServiceDiscovererEcho>
+    {
+    public:
+        using infra::SingleObserver<PeerServiceDiscoveryObserver, PeerServiceDiscovererEcho>::SingleObserver;
+
+        virtual void ServicesDiscovered(infra::MemoryRange<uint32_t> services) = 0;
+    };
+
+    class PeerServiceDiscovererEcho
+        : public service_discovery::ServiceDiscoveryProxy
+        , public service_discovery::ServiceDiscoveryResponse
+        , public infra::Subject<PeerServiceDiscoveryObserver>
+    {
+    public:
+        explicit PeerServiceDiscovererEcho(services::Echo& echo);
+
+        void NoServiceSupported() override;
+        void FirstServiceSupported(uint32_t id) override;
+        void ServicesChanged(uint32_t startServiceId, uint32_t endServiceId) override;
+
+    private:
+        using ServiceRange = std::tuple<uint32_t, uint32_t>;
+        static constexpr ServiceRange serviceRangeMax = std::make_tuple(0, std::numeric_limits<uint32_t>::max());
+
+    private:
+        void DiscoverPeerServices();
+        void StartDiscovery();
+        void ClearUpdatedServices();
+        uint32_t SearchRangeBegin() const;
+        uint32_t SearchRangeEnd() const;
+
+    private:
+        infra::BoundedVector<uint32_t>::WithMaxSize<10> services;
+        ServiceRange searchRange;
+    };
+}
+
+#endif

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(ServiceRange) returns (Nothing) { option (method_id) = 3; }
+}
+