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/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,47 @@
+#include "protobuf/meta_services/ServiceDiscoveryEcho.hpp"
+#include "echo/ServiceDiscovery.pb.hpp"
+
+namespace application
+{
+    void ServiceDiscoveryEcho::FindFirstServiceInRange(uint32_t startServiceId, uint32_t endServiceId)
+    {
+        infra::Optional<uint32_t> service;
+
+        for (auto id = startServiceId; id <= endServiceId; ++id)
+        {
+            if (AcceptsService(id))
+            {
+                service = id;
+                break;
+            }
+        }
+
+        service_discovery::ServiceDiscoveryResponseProxy::RequestSend([this, service]
+            {
+                if (service)
+                    FirstServiceSupported(*service);
+                else
+                    NoServiceSupported();
+            });
+
+        MethodDone();
+    }
+
+    bool ServiceDiscoveryEcho::AcceptsService(uint32_t serviceId) const
+    {
+        return service_discovery::ServiceDiscovery::AcceptsService(serviceId) 
+                || IsProxyServiceSupported(serviceId);
+    }
+
+    bool ServiceDiscoveryEcho::IsProxyServiceSupported(uint32_t& serviceId) const
+    {
+        auto serviceFound = false;
+        services::Echo::NotifyObservers([serviceId, &serviceFound](auto& observer)
+            {
+                if (observer.AcceptsService(serviceId))
+                    serviceFound = true;
+            });
+
+        return serviceFound;
+    }
+}

protobuf/meta_services/ServiceDiscoveryEcho.hpp

@@ -0,0 +1,50 @@
+#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;
+
+        void FindFirstServiceInRange(uint32_t startServiceId, uint32_t endServiceId) override;
+        void NotifyServiceChanges(bool value) override
+        {}
+
+        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;
+
+        void RequestSend(ServiceProxy& serviceProxy) override
+        {
+            service_discovery::ServiceDiscovery::Rpc().RequestSend(serviceProxy);
+        }
+
+        void ServiceDone() override
+        {
+            service_discovery::ServiceDiscovery::Rpc().ServiceDone();
+        }
+
+        services::MethodSerializerFactory& SerializerFactory() override
+        {
+            return service_discovery::ServiceDiscovery::Rpc().SerializerFactory();
+        }
+
+    protected:
+            bool IsProxyServiceSupported(uint32_t& serviceId) const;
+    };
+}
+
+#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
+)

protobuf/meta_services/test/TestServiceDiscoveryEcho.cpp

@@ -0,0 +1,134 @@
+#include "echo/ServiceDiscovery.pb.hpp"
+#include "infra/util/Optional.hpp"
+#include "protobuf/echo/Echo.hpp"
+#include "protobuf/echo/test_doubles/EchoSingleLoopback.hpp"
+#include "protobuf/echo/test_doubles/ServiceStub.hpp"
+#include "protobuf/meta_services/ServiceDiscoveryEcho.hpp"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <cstdint>
+#include <sys/types.h>
+
+namespace
+{
+    class ServiceDiscoveryResponseMock
+        : public service_discovery::ServiceDiscoveryResponse
+    {
+    public:
+        using service_discovery::ServiceDiscoveryResponse::ServiceDiscoveryResponse;
+        virtual ~ServiceDiscoveryResponseMock() = default;
+
+        void FirstServiceSupported(uint32_t value) override
+        {
+            FirstServiceSupportedMock(value);
+            MethodDone();
+        }
+
+        void NoServiceSupported() override
+        {
+            NoServiceSupportedMock();
+            MethodDone();
+        }
+
+        void ServicesChanged() override
+        {
+            ServicesChangedMock();
+            MethodDone();
+        }
+
+        MOCK_METHOD(void, FirstServiceSupportedMock, (uint32_t));
+        MOCK_METHOD(void, NoServiceSupportedMock, ());
+        MOCK_METHOD(void, ServicesChangedMock, ());
+    };
+
+    class ServiceStubWithCustomServiceId
+        : public services::ServiceStub
+    {
+    public:
+        ServiceStubWithCustomServiceId(services::Echo& echo, uint32_t serviceId)
+            : services::ServiceStub(echo)
+            , serviceId(serviceId)
+        {}
+
+        virtual ~ServiceStubWithCustomServiceId() = default;
+
+        bool AcceptsService(uint32_t serviceId) const override
+        {
+            return this->serviceId == serviceId;
+        }
+
+    private:
+        const uint32_t serviceId;
+    };
+};
+
+class ServiceDiscoveryTest
+    : public testing::Test
+{
+public:
+    services::MethodSerializerFactory::ForServices<service_discovery::ServiceDiscovery, service_discovery::ServiceDiscoveryResponse>::AndProxies<service_discovery::ServiceDiscoveryProxy> serializerFactory;
+    application::EchoSingleLoopback echo{ serializerFactory };
+    service_discovery::ServiceDiscoveryProxy proxy{ echo };
+    testing::StrictMock<ServiceDiscoveryResponseMock> serviceDiscoveryResponse{ echo };
+
+    application::ServiceDiscoveryEcho serviceDiscoveryEcho{ echo };
+};
+
+TEST_F(ServiceDiscoveryTest, return_no_service)
+{
+    ServiceStubWithCustomServiceId serviceMock{ serviceDiscoveryEcho, 5 };
+
+    EXPECT_CALL(serviceDiscoveryResponse, NoServiceSupportedMock);
+
+    proxy.RequestSend([this]
+        {
+            proxy.FindFirstServiceInRange(0, 4);
+        });
+}
+
+TEST_F(ServiceDiscoveryTest, return_service)
+{
+    ServiceStubWithCustomServiceId serviceMock{ serviceDiscoveryEcho, 5 };
+
+    EXPECT_CALL(serviceDiscoveryResponse, FirstServiceSupportedMock(5));
+
+    proxy.RequestSend([this]
+        {
+            proxy.FindFirstServiceInRange(0, 15);
+        });
+}
+
+TEST_F(ServiceDiscoveryTest, return_service_with_lowest_id)
+{
+    ServiceStubWithCustomServiceId serviceMock{ serviceDiscoveryEcho, 5 };
+    ServiceStubWithCustomServiceId serviceMock2{ serviceDiscoveryEcho, 6 };
+
+    EXPECT_CALL(serviceDiscoveryResponse, FirstServiceSupportedMock(5));
+
+    proxy.RequestSend([this]
+        {
+            proxy.FindFirstServiceInRange(0, 15);
+        });
+}
+
+TEST_F(ServiceDiscoveryTest, DISABLED_notify_service_change)
+{
+    proxy.RequestSend([this]
+        {
+            proxy.NotifyServiceChanges(true);
+        });
+
+    EXPECT_CALL(serviceDiscoveryResponse, ServicesChangedMock());
+
+    ServiceStubWithCustomServiceId serviceMock{ serviceDiscoveryEcho, 5 };
+}
+
+TEST_F(ServiceDiscoveryTest, find_own_service_id)
+{
+    EXPECT_CALL(serviceDiscoveryResponse, FirstServiceSupportedMock(service_discovery::ServiceDiscovery::serviceId));
+
+    proxy.RequestSend([this]
+        {
+            proxy.FindFirstServiceInRange(service_discovery::ServiceDiscovery::serviceId, service_discovery::ServiceDiscovery::serviceId);
+        });
+}