#1712 Add a vuu server ID to login success message (#1714)

* #1712 Add a vuu server ID to login success message

* #1712 Add a vuu server ID in vuu server

* #1712 revert

* #1712 fix test

Author: tanjjj

example/main-java/src/main/java/org/finos/vuu/VuuExampleMain.java

@@ -29,14 +29,12 @@
  * Example Java App using Vuu.
  *
  */
-public class VuuExampleMain
-{
+public class VuuExampleMain {
     /*
         //to allow self signed certs
         chrome://flags/#allow-insecure-localhost
     */
-    public static void main( String[] args )
-    {
+    public static void main(String[] args) {
         final MetricsProvider metrics = new MetricsProviderImpl();
         final Clock clock = new DefaultClock();
         final LifecycleContainer lifecycle = new LifecycleContainer(clock);

vuu/src/main/scala/org/finos/vuu/core/VuuServer.scala

@@ -20,13 +20,16 @@ import org.finos.vuu.plugin.PluginRegistry
 import org.finos.vuu.provider.{JoinTableProvider, JoinTableProviderImpl, Provider, ProviderContainer}
 import org.finos.vuu.viewport.{InMemViewPortTreeCallable, InMemViewPortTreeWorkItem, ViewPort, ViewPortAction, ViewPortActionMixin, ViewPortContainer}
 
+import java.util.UUID
 import java.util.concurrent.{Callable, FutureTask}
 
 /**
  * Vuu Server
  */
 class VuuServer(config: VuuServerConfig)(implicit lifecycle: LifecycleContainer, timeProvider: Clock, metricsProvider: MetricsProvider) extends LifecycleEnabled with StrictLogging with IVuuServer {
 
+  final val vuuServerId: String = UUID.randomUUID().toString
+
   final val serializer: Serializer[String, MessageBody] = JsonVsSerializer
 
   final val pluginRegistry: PluginRegistry = PluginRegistry()
@@ -58,7 +61,7 @@ class VuuServer(config: VuuServerConfig)(implicit lifecycle: LifecycleContainer,
 
   final val serverApi = new CoreServerApiHandler(viewPortContainer, tableContainer, providerContainer)
 
-  final val factory = new ViewServerHandlerFactoryImpl(authenticator, tokenValidator, sessionContainer, serverApi, JsonVsSerializer, moduleContainer, flowControllerFactory)
+  final val factory = new ViewServerHandlerFactoryImpl(authenticator, tokenValidator, sessionContainer, serverApi, JsonVsSerializer, moduleContainer, flowControllerFactory, vuuServerId)
 
   //order of creation here is important
   final val server = new WebSocketServer(config.wsOptions, factory)

vuu/src/main/scala/org/finos/vuu/net/LoginTokenValidator.scala

@@ -3,17 +3,17 @@ package org.finos.vuu.net
 import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap}
 
 trait LoginTokenValidator {
-  def login(msg: LoginRequest): Either[ViewServerMessage, String]
+  def login(msg: LoginRequest, vuuServerId: String): ViewServerMessage
 }
 
 class AlwaysHappyLoginValidator extends LoginTokenValidator {
 
-  override def login(msg: LoginRequest): Either[ViewServerMessage, String] = {
-    Left(JsonViewServerMessage("", "", msg.token, msg.user, LoginSuccess(msg.token)))
+  override def login(msg: LoginRequest, vuuServerId: String): ViewServerMessage = {
+    JsonViewServerMessage("", "", msg.token, msg.user, LoginSuccess(msg.token, vuuServerId))
   }
 }
 
-class ServerUserPrincipal(val token: String, val userName: String){
+class ServerUserPrincipal(val token: String, val userName: String) {
 }
 
 class LoggedInTokenValidator extends LoginTokenValidator {
@@ -24,11 +24,11 @@ class LoggedInTokenValidator extends LoginTokenValidator {
     tokenUserMap.put(token, userPrincipal)
   }
 
-  override def login(msg: LoginRequest): Either[ViewServerMessage, String] = {
-    if(tokenUserMap.containsKey(msg.token)){
-      Left(JsonViewServerMessage("", "", msg.token, msg.user, LoginSuccess(msg.token)))
-    }else{
-      Right("User token not found")
+  override def login(msg: LoginRequest, vuuServerId: String): ViewServerMessage = {
+    if (tokenUserMap.containsKey(msg.token)) {
+      JsonViewServerMessage("", "", msg.token, msg.user, LoginSuccess(msg.token, vuuServerId))
+    } else {
+      JsonViewServerMessage("", "", msg.token, msg.user, LoginFailure(msg.token, "User token not found"))
     }
   }
 }

vuu/src/main/scala/org/finos/vuu/net/Messages.scala

@@ -48,7 +48,7 @@ case class AuthenticateFailure(msg: String) extends MessageBody
 
 case class LoginRequest(token: String, user: String) extends MessageBody
 
-case class LoginSuccess(token: String) extends MessageBody
+case class LoginSuccess(token: String, vuuServerId: String) extends MessageBody
 
 case class LoginFailure(token: String, errorMsg: String) extends MessageBody
 

vuu/src/main/scala/org/finos/vuu/net/RequestProcessor.scala

@@ -23,29 +23,34 @@ class RequestProcessor(authenticator: Authenticator,
                        serializer: Serializer[String, MessageBody],
                        moduleContainer: ModuleContainer,
                        flowControllerFactory: FlowControllerFactory,
+                       vuuServerId: String
                       )(implicit timeProvider: Clock) extends StrictLogging {
 
   @volatile private var session: ClientSessionId = null
 
   def handle(msg: ViewServerMessage, channel: Channel): Option[ViewServerMessage] = {
 
-
     msg.body match {
       case body: AuthenticateRequest =>
         authenticator.authenticate(body.username, body.password)
       case body: LoginRequest =>
-        tokenValidator.login(body) match {
-          case Left(accept) =>
-            createSession(msg.requestId, body, clientSessionContainer, channel)
-          case Right(errorMsg) =>
-            handleMessageWithNoSession(errorMsg, channel)
+        tokenValidator.login(body, vuuServerId).body match {
+          case success: LoginSuccess =>
+            createSession(msg.requestId, body, clientSessionContainer, channel, vuuServerId)
+          case failure: LoginFailure =>
+            handleMessageWithNoSession(failure.errorMsg, channel)
             None
         }
       case body => handleViewServerMessage(msg, channel)
     }
   }
 
-  protected def createSession(requestId: String, request: LoginRequest, clientSessionContainer: ClientSessionContainer, channel: Channel): Option[ViewServerMessage] = {
+  protected def createSession(
+                               requestId: String,
+                               request: LoginRequest,
+                               clientSessionContainer: ClientSessionContainer,
+                               channel: Channel,
+                               vuuServerId: String): Option[ViewServerMessage] = {
 
     val session = SessionId.oneNew()
     val user = request.user
@@ -58,7 +63,7 @@ class RequestProcessor(authenticator: Authenticator,
 
     clientSessionContainer.register(id, handler)
 
-    Some(JsonViewServerMessage(requestId, session, request.token, request.user, LoginSuccess(request.token)))
+    Some(JsonViewServerMessage(requestId, session, request.token, request.user, LoginSuccess(request.token, vuuServerId)))
   }
 
 

vuu/src/main/scala/org/finos/vuu/net/ViewServerHandler.scala

@@ -18,9 +18,10 @@ class ViewServerHandlerFactoryImpl(authenticator: Authenticator,
                                    serverApi: ServerApi, jsonVsSerializer: Serializer[String, MessageBody],
                                    moduleContainer: ModuleContainer,
                                    flowControllerFactory: FlowControllerFactory,
+                                   vuuServerId: String,
                                   )(implicit val timeProvider: Clock) extends ViewServerHandlerFactory {
   override def create(): ViewServerHandler = {
-    val requestProcessor = new RequestProcessor(authenticator, tokenValidator, sessionContainer, serverApi, jsonVsSerializer, moduleContainer, flowControllerFactory)
+    val requestProcessor = new RequestProcessor(authenticator, tokenValidator, sessionContainer, serverApi, jsonVsSerializer, moduleContainer, flowControllerFactory, vuuServerId)
     new ViewServerHandler(jsonVsSerializer, requestProcessor)
   }
 }

vuu/src/test/scala/org/finos/vuu/json/JsonVsSerializerTest.scala

@@ -64,7 +64,7 @@ class JsonVsSerializerTest extends AnyFeatureSpec with Matchers{
       roundTrip(AuthenticateRequest("chris", "foobar"))
       roundTrip(AuthenticateSuccess("christoken"))
       roundTrip(LoginRequest("AAA11122233", "chris"))
-      roundTrip(LoginSuccess("AAA11122233"))
+      roundTrip(LoginSuccess("AAA11122233", "vuuServerId"))
       roundTrip(HeartBeat(123l))
       roundTrip(HeartBeatResponse(123l))
       roundTrip(RpcUpdate(ViewPortTable("orderEntry", "CORE"), "Foo", Map("Foo" -> 123, "Bar" -> true, "Whizzle" -> "TANG", "HooHa" -> 344567l)))

vuu/src/test/scala/org/finos/vuu/test/impl/TestVuuServerImpl.scala

@@ -23,10 +23,13 @@ import org.finos.vuu.test.{TestViewPort, TestVuuServer}
 import org.finos.vuu.util.OutboundRowPublishQueue
 import org.finos.vuu.viewport.{DefaultRange, ViewPort, ViewPortAction, ViewPortActionMixin, ViewPortContainer, ViewPortRange}
 
+import java.util.UUID
 import scala.reflect.classTag
 
 class TestVuuServerImpl(val modules: List[ViewServerModule])(implicit clock: Clock, lifecycle: LifecycleContainer, metrics: MetricsProvider) extends TestVuuServer with LifecycleEnabled with StrictLogging {
 
+  private final val vuuServerId: String = UUID.randomUUID().toString
+
   private val serializer: Serializer[String, MessageBody] = JsonVsSerializer
 
   JsonSubTypeRegistry.register(classOf[MessageBody], classOf[CoreJsonSerializationMixin])
@@ -58,7 +61,7 @@ class TestVuuServerImpl(val modules: List[ViewServerModule])(implicit clock: Clo
 
   val serverApi = new CoreServerApiHandler(viewPortContainer, tableContainer, providerContainer)
 
-  val factory = new ViewServerHandlerFactoryImpl(authenticator, tokenValidator, sessionContainer, serverApi, JsonVsSerializer, moduleContainer, flowControllerFactory)
+  val factory = new ViewServerHandlerFactoryImpl(authenticator, tokenValidator, sessionContainer, serverApi, JsonVsSerializer, moduleContainer, flowControllerFactory, vuuServerId)
 
   val queue = new OutboundRowPublishQueue()