diff --git a/example/main-java/src/main/java/org/finos/vuu/person/PersonRpcHandler.java b/example/main-java/src/main/java/org/finos/vuu/person/PersonRpcHandler.java index 1ac029200..8ea910094 100644 --- a/example/main-java/src/main/java/org/finos/vuu/person/PersonRpcHandler.java +++ b/example/main-java/src/main/java/org/finos/vuu/person/PersonRpcHandler.java @@ -19,10 +19,6 @@ public PersonRpcHandler(DataTable table, TableContainer tableContainer) { registerRpc("GetPeopleWithName", (params) -> processGetPeopleNameRpcRequest(params)); } - private void registerRpc(String functionName, Function1 handlerFunc) { - this.registerRpcMethodHandler(functionName, new RpcFunctionMethodHandler(handlerFunc)); - } - public RpcMethodCallResult processUpdateNameRpcRequest(RpcParams params) { updateName( params.namedParams().get("Id").get().toString(), //how to report error when expected param missing or fail to cast to right type diff --git a/vuu-java/src/test/java/org/finos/vuu/net/rpc/RpcMethodHandlerTest.java b/vuu-java/src/test/java/org/finos/vuu/net/rpc/RpcMethodHandlerTest.java index 2be463b9b..73123dd59 100644 --- a/vuu-java/src/test/java/org/finos/vuu/net/rpc/RpcMethodHandlerTest.java +++ b/vuu-java/src/test/java/org/finos/vuu/net/rpc/RpcMethodHandlerTest.java @@ -21,9 +21,7 @@ public class RpcMethodHandlerTest { public void should_wrap_and_call_java_function_in_method_handler() { final TestRpcService rpcService = new TestRpcService(); - final RpcMethodHandler handler = new RpcFunctionMethodHandler(rpcService::rpcFunction); - - final RpcMethodCallResult result = handler.call(new RpcParams(new Object[]{}, ScalaCollectionConverter.toScala(Collections.emptyMap()), null)); + final RpcMethodCallResult result = rpcService.rpcFunction(new RpcParams(new Object[]{}, ScalaCollectionConverter.toScala(Collections.emptyMap()), null)); assertThat(result) .isNotNull() @@ -34,10 +32,9 @@ public void should_wrap_and_call_java_function_in_method_handler() { @Test public void should_register_java_function_as_rpc_in_default_handler() { final TestRpcService rpcService = new TestRpcService(); - final RpcMethodHandler handler = new RpcFunctionMethodHandler(rpcService::rpcFunction); final DefaultRpcHandler defaultRpcHandler = new DefaultRpcHandler(); - defaultRpcHandler.registerRpcMethodHandler("helloWorld", handler); + defaultRpcHandler.registerRpc("helloWorld", rpcService::rpcFunction); RpcCall call = new RpcCall("service", "helloWorld", new Object[]{}, ScalaCollectionConverter.toScala(Collections.emptyMap())); Option response = defaultRpcHandler.processRpcCall(createRandomViewServerMessage(new LoginRequest("token", "user")), call, ViewPortTestUtils.requestContext()); diff --git a/vuu/src/main/scala/org/finos/vuu/net/rpc/DefaultRpcHandler.scala b/vuu/src/main/scala/org/finos/vuu/net/rpc/DefaultRpcHandler.scala index 329284b67..a40268238 100644 --- a/vuu/src/main/scala/org/finos/vuu/net/rpc/DefaultRpcHandler.scala +++ b/vuu/src/main/scala/org/finos/vuu/net/rpc/DefaultRpcHandler.scala @@ -8,20 +8,23 @@ import java.util.concurrent.ConcurrentHashMap class DefaultRpcHandler extends RpcHandler with StrictLogging { - private val methodHandlers = new ConcurrentHashMap[String, RpcMethodHandler]() + type RpcFunction = RpcParams => RpcMethodCallResult + + private val rpcHandlerMap = new ConcurrentHashMap[String, RpcFunction]() /** - * Register a handler for a given rpc method + * Register a handler for a given rpc function * - * @param methodName name of the rpc method - * @param handler RpcMethodHandler - * @return + * @param functionName name of the rpc function + * @param handlerFunc handler function that takes RpcParams and return RpcMethodCallResult */ - def registerRpcMethodHandler(methodName: String, handler: RpcMethodHandler): RpcMethodHandler = { - if (methodHandlers.containsKey(methodName)) { - throw new IllegalArgumentException(s"Method $methodName already registered") + + def registerRpc(functionName: String, handlerFunc: RpcFunction): Unit = { + + if (rpcHandlerMap.containsKey(functionName)) { + throw new IllegalArgumentException(s"Function $functionName already registered") } - methodHandlers.put(methodName, handler) + rpcHandlerMap.put(functionName, handlerFunc) } override def processViewPortRpcCall(methodName: String, params: Array[Any], namedParams: Map[String, Any])(ctx: RequestContext): ViewPortAction = { @@ -45,10 +48,10 @@ class DefaultRpcHandler extends RpcHandler with StrictLogging { } private def processRpcMethodHandler(methodName: String, params: Array[Any], namedParams: Map[String, Any], ctx: RequestContext) = { - if (methodHandlers.containsKey(methodName)) { + if (rpcHandlerMap.containsKey(methodName)) { try { - val handler = methodHandlers.get(methodName) - handler.call(new RpcParams(params, namedParams, ctx)) + val handler = rpcHandlerMap.get(methodName) + handler(new RpcParams(params, namedParams, ctx)) } catch { case e: Exception => logger.error(s"Error processing rpc method $methodName", e) diff --git a/vuu/src/main/scala/org/finos/vuu/net/rpc/RpcMethodHandler.scala b/vuu/src/main/scala/org/finos/vuu/net/rpc/RpcMethodHandler.scala index 9cca84f84..bf11ae59b 100644 --- a/vuu/src/main/scala/org/finos/vuu/net/rpc/RpcMethodHandler.scala +++ b/vuu/src/main/scala/org/finos/vuu/net/rpc/RpcMethodHandler.scala @@ -2,14 +2,6 @@ package org.finos.vuu.net.rpc import org.finos.vuu.net.RequestContext -trait RpcMethodHandler { - def call(rpcParams: RpcParams): RpcMethodCallResult -} - -class RpcFunctionMethodHandler(handler: RpcParams => RpcMethodCallResult) extends RpcMethodHandler { - override def call(rpcParams: RpcParams): RpcMethodCallResult = handler(rpcParams) -} - class RpcParams(val params: Array[Any], val namedParams: Map[String, Any], ctx: RequestContext) trait RpcMethodCallResult {} diff --git a/vuu/src/test/scala/org/finos/vuu/net/TestVuuClient.scala b/vuu/src/test/scala/org/finos/vuu/net/TestVuuClient.scala index 1e052f2ae..a222856f9 100644 --- a/vuu/src/test/scala/org/finos/vuu/net/TestVuuClient.scala +++ b/vuu/src/test/scala/org/finos/vuu/net/TestVuuClient.scala @@ -25,8 +25,6 @@ class TestVuuClient(vsClient: ViewServerClient) { def awaitForMsgWithBody[T <: AnyRef](implicit t: ClassTag[T]): Option[T] = awaitForMsg.map(msg => msg.body.asInstanceOf[T]) - - def awaitForMsg[T <: AnyRef](implicit t: ClassTag[T]): Option[ViewServerMessage] = { failAfter(timeout){ val msg = vsClient.awaitMsg diff --git a/vuu/src/test/scala/org/finos/vuu/net/rpc/DefaultRpcHandlerTest.scala b/vuu/src/test/scala/org/finos/vuu/net/rpc/DefaultRpcHandlerTest.scala index 349bfbd8b..82dec0f1e 100644 --- a/vuu/src/test/scala/org/finos/vuu/net/rpc/DefaultRpcHandlerTest.scala +++ b/vuu/src/test/scala/org/finos/vuu/net/rpc/DefaultRpcHandlerTest.scala @@ -17,25 +17,22 @@ class DefaultRpcHandlerTest extends AnyFeatureSpec with Matchers with BeforeAndA Feature("Default Rpc Handler") { Scenario("Register Rpc Method Handler for a method") { - val rpcFunctionMethodHandler = new RpcFunctionMethodHandler(_ => RpcMethodSuccess("result")) - - handler.registerRpcMethodHandler("myMethod", rpcFunctionMethodHandler) + handler.registerRpc("myMethod", _ => RpcMethodSuccess("result")) handler.processViewPortRpcCall("myMethod", Array("param1"), Map("namedParam1" -> "value1"))(null) should be(ViewPortRpcSuccess()) } Scenario("Throw exception when registering a function under already registered name") { - val rpcFunctionMethodHandler = new RpcFunctionMethodHandler(_ => RpcMethodSuccess("result")) - handler.registerRpcMethodHandler("myMethod", rpcFunctionMethodHandler) + handler.registerRpc("myMethod", _ => RpcMethodSuccess("result1")) assertThrows[IllegalArgumentException] { - handler.registerRpcMethodHandler("myMethod", rpcFunctionMethodHandler) + handler.registerRpc("myMethod", _ => RpcMethodSuccess("result2")) } } Scenario("ProcessViewPortRpcCall method with null params should return ViewPortRpcSuccess when the rpc method is successful") { - handler.registerRpcMethodHandler("myMethod", _ => RpcMethodSuccess("result")) + handler.registerRpc("myMethod", _ => RpcMethodSuccess("result")) val result = handler.processViewPortRpcCall("myMethod", null, null)(null) @@ -43,7 +40,7 @@ class DefaultRpcHandlerTest extends AnyFeatureSpec with Matchers with BeforeAndA } Scenario("The processViewPortRpcCall method with null params should return ViewPortRpcFailure when the rpc method fails") { - handler.registerRpcMethodHandler("myMethod", _ => RpcMethodFailure(1, "error", new Exception("exception"))) + handler.registerRpc("myMethod", _ => RpcMethodFailure(1, "error", new Exception("exception"))) val result = handler.processViewPortRpcCall("myMethod", null, null)(null) @@ -51,7 +48,7 @@ class DefaultRpcHandlerTest extends AnyFeatureSpec with Matchers with BeforeAndA } Scenario("The processRpcCall method should return Some(ViewServerMessage) when the rpc method is successful") { - handler.registerRpcMethodHandler("myMethod", _ => RpcMethodSuccess("result")) + handler.registerRpc("myMethod", _ => RpcMethodSuccess("result")) val rpcCall = RpcCall("myService", "myMethod", Array("param1"), Map("namedParam1" -> "value1")) @@ -61,7 +58,7 @@ class DefaultRpcHandlerTest extends AnyFeatureSpec with Matchers with BeforeAndA } Scenario("The processRpcCall method should return Some(ViewServerMessage) when the rpc method fails") { - handler.registerRpcMethodHandler("myMethod", _ => RpcMethodFailure(1, "error", new Exception("exception"))) + handler.registerRpc("myMethod", _ => RpcMethodFailure(1, "error", new Exception("exception"))) val rpcCall = RpcCall("myService", "myMethod", Array("param1"), Map("namedParam1" -> "value1"))