WIP on enhanced service registration for RESTful services

Author: artem-v

services-api/src/main/java/io/scalecube/services/Reflect.java

@@ -220,10 +220,29 @@ private static Map<String, String> transformArrayToMap(Tag[] array) {
    * @param serviceInterface with {@link Service} annotation
    * @return service name
    */
-  public static Map<String, Method> serviceMethods(Class<?> serviceInterface) {
-    return Arrays.stream(serviceInterface.getMethods())
-        .filter(method -> method.isAnnotationPresent(ServiceMethod.class))
-        .collect(Collectors.toMap(Reflect::methodName, Function.identity()));
+  public static Collection<Method> serviceMethods(Class<?> serviceInterface) {
+    final var methodList =
+        Arrays.stream(serviceInterface.getMethods())
+            .filter(method -> method.isAnnotationPresent(ServiceMethod.class))
+            .toList();
+
+    //noinspection unused
+    final var collect =
+        methodList.stream()
+            .collect(
+                Collectors.toMap(
+                    method ->
+                        String.join(":", Reflect.methodName(method), Reflect.restMethod(method)),
+                    Function.identity(),
+                    (method, duplicate) -> {
+                      throw new IllegalArgumentException(
+                          "Duplicate method found for method: "
+                              + method
+                              + ", duplicate: "
+                              + duplicate);
+                    }));
+
+    return methodList;
   }
 
   /**

services-api/src/test/java/io/scalecube/services/methods/ServiceMethodInvokerTest.java

@@ -368,7 +368,11 @@ private static Consumer<ServiceMessage> assertError(int errorCode, String errorM
   private static MethodInfo getMethodInfo(Object serviceInstance, String methodName) {
     final var serviceInstanceClass = serviceInstance.getClass();
     final Class<?> serviceInterface = Reflect.serviceInterfaces(serviceInstance).toList().get(0);
-    final var method = Reflect.serviceMethods(serviceInterface).get(methodName);
+    final var method =
+        Reflect.serviceMethods(serviceInterface).stream()
+            .filter(m -> m.getName().equals(methodName))
+            .findFirst()
+            .get();
 
     // get service instance method
     Method serviceMethod;

services-gateway/src/test/java/io/scalecube/services/gateway/rest/RestServiceDefinitionTest.java

@@ -0,0 +1,87 @@
+package io.scalecube.services.gateway.rest;
+
+import static io.scalecube.services.api.ServiceMessage.HEADER_REQUEST_METHOD;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.mock;
+
+import io.scalecube.services.Microservices;
+import io.scalecube.services.Microservices.Context;
+import io.scalecube.services.annotations.RestMethod;
+import io.scalecube.services.annotations.Service;
+import io.scalecube.services.annotations.ServiceMethod;
+import io.scalecube.services.api.ServiceMessage;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Mono;
+
+public class RestServiceDefinitionTest {
+
+  @Test
+  void registerInvalidService() {
+    try {
+      Microservices.start(new Context().services(mock(BadService.class)));
+      fail("Expected exception");
+    } catch (Exception e) {
+      assertInstanceOf(IllegalArgumentException.class, e, e::getMessage);
+      assertThat(e.getMessage(), Matchers.startsWith("Duplicate method found for method"));
+    }
+  }
+
+  @Test
+  void registerValidService() {
+    try (final var microservices =
+        Microservices.start(new Context().services(mock(GoodService.class)))) {
+      final var serviceRegistry = microservices.serviceRegistry();
+
+      final var foo = System.nanoTime();
+      final var methodInvokerWithoutRestMethod =
+          serviceRegistry.lookupInvoker(
+              ServiceMessage.builder().qualifier("v1/service/echo/" + foo).build());
+      assertNull(methodInvokerWithoutRestMethod);
+
+      final var methodInvokerByGet =
+          serviceRegistry.lookupInvoker(
+              ServiceMessage.builder()
+                  .header(HEADER_REQUEST_METHOD, "GET")
+                  .qualifier("v1/service/echo/" + foo)
+                  .build());
+      assertNotNull(methodInvokerByGet);
+
+      final var methodInvokerByPost =
+          serviceRegistry.lookupInvoker(
+              ServiceMessage.builder()
+                  .header(HEADER_REQUEST_METHOD, "POST")
+                  .qualifier("v1/service/echo/" + foo)
+                  .build());
+      assertNotNull(methodInvokerByPost);
+    }
+  }
+
+  @Service("v1/service")
+  interface BadService {
+
+    @RestMethod("GET")
+    @ServiceMethod("get/:foo")
+    Mono<SomeResponse> echo();
+
+    @RestMethod("GET")
+    @ServiceMethod("get/:foo")
+    Mono<SomeResponse> ping();
+  }
+
+  @Service("v1/service")
+  interface GoodService {
+
+    @RestMethod("GET")
+    @ServiceMethod("echo/:foo")
+    Mono<SomeResponse> echo();
+
+    @RestMethod("POST")
+    @ServiceMethod("echo/:foo")
+    Mono<SomeResponse> ping();
+  }
+}

services/src/main/java/io/scalecube/services/ServiceScanner.java

@@ -32,7 +32,7 @@ public static List<ServiceRegistration> toServiceRegistrations(ServiceInfo servi
               final var namespace = Reflect.serviceName(serviceInterface);
 
               final var methodDefinitions =
-                  Reflect.serviceMethods(serviceInterface).values().stream()
+                  Reflect.serviceMethods(serviceInterface).stream()
                       .map(
                           method -> {
                             // validate method
@@ -113,7 +113,7 @@ public static Collection<ServiceRoleDefinition> collectServiceRoles(
                   serviceInterface ->
                       Reflect.serviceMethods(serviceInterface)
                           .forEach(
-                              (key, method) -> {
+                              method -> {
                                 // validate method
                                 Reflect.validateMethodOrThrow(method);
 

services/src/main/java/io/scalecube/services/registry/ServiceRegistryImpl.java

@@ -152,7 +152,7 @@ public void registerService(
             serviceInterface ->
                 Reflect.serviceMethods(serviceInterface)
                     .forEach(
-                        (key, method) -> {
+                        method -> {
                           // validate method
                           Reflect.validateMethodOrThrow(method);