RPC client authentication using user/password from config file

client/src/integration-test/kotlin/com/r3corda/client/CordaRPCClientTest.kt

@@ -0,0 +1,62 @@
+package com.r3corda.client
+
+import com.r3corda.core.random63BitValue
+import com.r3corda.node.driver.driver
+import com.r3corda.node.services.config.configureTestSSL
+import com.r3corda.node.services.messaging.ArtemisMessagingComponent.Companion.toHostAndPort
+import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
+import org.assertj.core.api.Assertions.assertThatExceptionOfType
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import java.util.concurrent.CountDownLatch
+import kotlin.concurrent.thread
+
+class CordaRPCClientTest {
+
+    private val validUsername = "user1"
+    private val validPassword = "test"
+    private val stopDriver = CountDownLatch(1)
+    private var driverThread: Thread? = null
+    private lateinit var client: CordaRPCClient
+
+    @Before
+    fun start() {
+        val driverStarted = CountDownLatch(1)
+        driverThread = thread {
+            driver {
+                val nodeInfo = startNode().get()
+                client = CordaRPCClient(toHostAndPort(nodeInfo.address), configureTestSSL())
+                driverStarted.countDown()
+                stopDriver.await()
+            }
+        }
+        driverStarted.await()
+    }
+
+    @After
+    fun stop() {
+        stopDriver.countDown()
+        driverThread?.join()
+    }
+
+    @Test
+    fun `log in with valid username and password`() {
+        client.start(validUsername, validPassword)
+    }
+
+    @Test
+    fun `log in with unknown user`() {
+        assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy {
+            client.start(random63BitValue().toString(), validPassword)
+        }
+    }
+
+    @Test
+    fun `log in with incorrect password`() {
+        assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy {
+            client.start(validUsername, random63BitValue().toString())
+        }
+    }
+
+ }

client/src/integration-test/kotlin/com/r3corda/client/NodeMonitorModelTest.kt

@@ -1,6 +1,5 @@
 package com.r3corda.client
 
-import com.google.common.util.concurrent.SettableFuture
 import com.r3corda.client.model.NodeMonitorModel
 import com.r3corda.client.model.ProgressTrackingEvent
 import com.r3corda.core.bufferUntilSubscribed
@@ -14,9 +13,7 @@ import com.r3corda.core.protocols.StateMachineRunId
 import com.r3corda.core.serialization.OpaqueBytes
 import com.r3corda.core.transactions.SignedTransaction
 import com.r3corda.node.driver.driver
-import com.r3corda.node.services.config.NodeSSLConfiguration
-import com.r3corda.node.services.config.configureWithDevSSLCertificate
-import com.r3corda.node.services.messaging.NodeMessagingClient
+import com.r3corda.node.services.config.configureTestSSL
 import com.r3corda.node.services.messaging.StateMachineUpdate
 import com.r3corda.node.services.transactions.SimpleNotaryService
 import com.r3corda.testing.expect
@@ -27,18 +24,15 @@ import org.junit.Before
 import org.junit.Test
 import rx.Observable
 import rx.Observer
-import java.nio.file.Files
-import java.nio.file.Path
+import java.util.concurrent.CountDownLatch
 import kotlin.concurrent.thread
 
 class NodeMonitorModelTest {
 
     lateinit var aliceNode: NodeInfo
     lateinit var notaryNode: NodeInfo
-    lateinit var aliceClient: NodeMessagingClient
-    val driverStarted = SettableFuture.create<Unit>()
-    val stopDriver = SettableFuture.create<Unit>()
-    val driverStopped = SettableFuture.create<Unit>()
+    val stopDriver = CountDownLatch(1)
+    var driverThread: Thread? = null
 
     lateinit var stateMachineTransactionMapping: Observable<StateMachineTransactionMapping>
     lateinit var stateMachineUpdates: Observable<StateMachineUpdate>
@@ -51,7 +45,8 @@ class NodeMonitorModelTest {
 
     @Before
     fun start() {
-        thread {
+        val driverStarted = CountDownLatch(1)
+        driverThread = thread {
             driver {
                 val aliceNodeFuture = startNode("Alice")
                 val notaryNodeFuture = startNode("Notary", advertisedServices = setOf(ServiceInfo(SimpleNotaryService.type)))
@@ -61,16 +56,6 @@ class NodeMonitorModelTest {
                 newNode = { nodeName -> startNode(nodeName).get() }
                 val monitor = NodeMonitorModel()
 
-                val sslConfig = object : NodeSSLConfiguration {
-                    override val certificatesPath: Path = Files.createTempDirectory("certs")
-                    override val keyStorePassword = "cordacadevpass"
-                    override val trustStorePassword = "trustpass"
-
-                    init {
-                        configureWithDevSSLCertificate()
-                    }
-                }
-
                 stateMachineTransactionMapping = monitor.stateMachineTransactionMapping.bufferUntilSubscribed()
                 stateMachineUpdates = monitor.stateMachineUpdates.bufferUntilSubscribed()
                 progressTracking = monitor.progressTracking.bufferUntilSubscribed()
@@ -79,20 +64,18 @@ class NodeMonitorModelTest {
                 networkMapUpdates = monitor.networkMap.bufferUntilSubscribed()
                 clientToService = monitor.clientToService
 
-                monitor.register(aliceNode, sslConfig.certificatesPath)
-                driverStarted.set(Unit)
-                stopDriver.get()
-
+                monitor.register(aliceNode, configureTestSSL(), "user1", "test")
+                driverStarted.countDown()
+                stopDriver.await()
             }
-            driverStopped.set(Unit)
         }
-        driverStarted.get()
+        driverStarted.await()
     }
 
     @After
     fun stop() {
-        stopDriver.set(Unit)
-        driverStopped.get()
+        stopDriver.countDown()
+        driverThread?.join()
     }
 
     @Test

client/src/main/kotlin/com/r3corda/client/CordaRPCClient.kt

@@ -24,19 +24,12 @@ import kotlin.concurrent.thread
  * useful tasks. See the documentation for [proxy] or review the docsite to learn more about how this API works.
  */
 @ThreadSafe
-class CordaRPCClient(val host: HostAndPort, certificatesPath: Path) : Closeable, ArtemisMessagingComponent(sslConfig(certificatesPath)) {
+class CordaRPCClient(val host: HostAndPort, override val config: NodeSSLConfiguration) : Closeable, ArtemisMessagingComponent() {
     companion object {
         private val rpcLog = LoggerFactory.getLogger("com.r3corda.rpc")
-
-        private fun sslConfig(certificatesPath: Path): NodeSSLConfiguration = object : NodeSSLConfiguration {
-            override val certificatesPath: Path = certificatesPath
-            override val keyStorePassword = "cordacadevpass"
-            override val trustStorePassword = "trustpass"
-        }
     }
 
     // TODO: Certificate handling for clients needs more work.
-
     private inner class State {
         var running = false
         lateinit var sessionFactory: ClientSessionFactory
@@ -57,7 +50,7 @@ class CordaRPCClient(val host: HostAndPort, certificatesPath: Path) : Closeable,
 
     /** Opens the connection to the server and registers a JVM shutdown hook to cleanly disconnect. */
     @Throws(ActiveMQNotConnectedException::class)
-    fun start() {
+    fun start(username: String, password: String) {
         state.locked {
             check(!running)
             checkStorePasswords()  // Check the password.
@@ -66,7 +59,7 @@ class CordaRPCClient(val host: HostAndPort, certificatesPath: Path) : Closeable,
             sessionFactory = serverLocator.createSessionFactory()
             // We use our initial connection ID as the queue namespace.
             myID = sessionFactory.connection.id as Int and 0x000000FFFFFF
-            session = sessionFactory.createSession()
+            session = sessionFactory.createSession(username, password, false, true, true, serverLocator.isPreAcknowledge, serverLocator.ackBatchSize)
             session.start()
             clientImpl = CordaRPCClientImpl(session, state.lock, myAddressPrefix)
             running = true

client/src/main/kotlin/com/r3corda/client/model/NodeMonitorModel.kt

@@ -8,14 +8,14 @@ import com.r3corda.core.node.services.StateMachineTransactionMapping
 import com.r3corda.core.node.services.Vault
 import com.r3corda.core.protocols.StateMachineRunId
 import com.r3corda.core.transactions.SignedTransaction
-import com.r3corda.node.services.messaging.ArtemisMessagingComponent
+import com.r3corda.node.services.config.NodeSSLConfiguration
+import com.r3corda.node.services.messaging.ArtemisMessagingComponent.Companion.toHostAndPort
 import com.r3corda.node.services.messaging.CordaRPCOps
 import com.r3corda.node.services.messaging.StateMachineInfo
 import com.r3corda.node.services.messaging.StateMachineUpdate
 import javafx.beans.property.SimpleObjectProperty
 import rx.Observable
 import rx.subjects.PublishSubject
-import java.nio.file.Path
 
 data class ProgressTrackingEvent(val stateMachineId: StateMachineRunId, val message: String) {
     companion object {
@@ -54,14 +54,11 @@ class NodeMonitorModel {
 
     /**
      * Register for updates to/from a given vault.
-     * @param messagingService The messaging to use for communication.
-     * @param monitorNodeInfo the [Node] to connect to.
      * TODO provide an unsubscribe mechanism
      */
-    fun register(vaultMonitorNodeInfo: NodeInfo, certificatesPath: Path) {
-
-        val client = CordaRPCClient(ArtemisMessagingComponent.toHostAndPort(vaultMonitorNodeInfo.address), certificatesPath)
-        client.start()
+    fun register(vaultMonitorNodeInfo: NodeInfo, sslConfig: NodeSSLConfiguration, username: String, password: String) {
+        val client = CordaRPCClient(toHostAndPort(vaultMonitorNodeInfo.address), sslConfig)
+        client.start(username, password)
         val proxy = client.proxy()
 
         val (stateMachines, stateMachineUpdates) = proxy.stateMachinesAndUpdates()