Merge branch 'master' into wn-redo-node-conf-docs

.ci/api-current.txt

@@ -6572,10 +6572,6 @@ public final class net.corda.client.rpc.CordaRPCClient extends java.lang.Object
   public static final net.corda.client.rpc.CordaRPCClient$Companion Companion
 ##
 public static final class net.corda.client.rpc.CordaRPCClient$Companion extends java.lang.Object
-  @NotNull
-  public final net.corda.client.rpc.CordaRPCClient createWithSsl(java.util.List<net.corda.core.utilities.NetworkHostAndPort>, net.corda.core.messaging.ClientRpcSslOptions, net.corda.client.rpc.CordaRPCClientConfiguration)
-  @NotNull
-  public final net.corda.client.rpc.CordaRPCClient createWithSsl(net.corda.core.utilities.NetworkHostAndPort, net.corda.core.messaging.ClientRpcSslOptions, net.corda.client.rpc.CordaRPCClientConfiguration)
 ##
 public class net.corda.client.rpc.CordaRPCClientConfiguration extends java.lang.Object
   public <init>(java.time.Duration)

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt

@@ -1,6 +1,5 @@
 package net.corda.client.rpc
 
-import net.corda.client.rpc.internal.createCordaRPCClientWithSslAndClassLoader
 import net.corda.core.context.*
 import net.corda.core.contracts.FungibleAsset
 import net.corda.core.crypto.random63BitValue
@@ -269,7 +268,7 @@ class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance"), notaries =
             val address = NetworkHostAndPort.parse(args[0])
             val financeClassLoader = URLClassLoader(arrayOf(Paths.get(args[1]).toUri().toURL()))
             val rpcUser = CordaRPCClientTest.rpcUser
-            val client = createCordaRPCClientWithSslAndClassLoader(address, classLoader = financeClassLoader)
+            val client = CordaRPCClient(address, classLoader = financeClassLoader)
             val state = client.use(rpcUser.username, rpcUser.password) {
                 // financeClassLoader should be allowing the Cash.State to materialise
                 @Suppress("DEPRECATION")

client/rpc/src/main/kotlin/net/corda/client/rpc/CordaRPCClient.kt

@@ -3,11 +3,11 @@ package net.corda.client.rpc
 import com.github.benmanes.caffeine.cache.Caffeine
 import net.corda.client.rpc.internal.RPCClient
 import net.corda.client.rpc.internal.serialization.amqp.AMQPClientSerializationScheme
-import net.corda.core.internal.loadClassesImplementing
 import net.corda.core.context.Actor
 import net.corda.core.context.Trace
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.PLATFORM_VERSION
+import net.corda.core.internal.loadClassesImplementing
 import net.corda.core.messaging.ClientRpcSslOptions
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.serialization.SerializationCustomSerializer
@@ -22,7 +22,7 @@ import net.corda.serialization.internal.AMQP_RPC_CLIENT_CONTEXT
 import net.corda.serialization.internal.amqp.SerializationFactoryCacheKey
 import net.corda.serialization.internal.amqp.SerializerFactory
 import java.time.Duration
-import java.util.ServiceLoader
+import java.util.*
 
 /**
  * This class is essentially just a wrapper for an RPCConnection<CordaRPCOps> and can be treated identically.
@@ -244,58 +244,48 @@ open class CordaRPCClientConfiguration @JvmOverloads constructor(
  * @param configuration An optional configuration used to tweak client behaviour.
  * @param sslConfiguration An optional [ClientRpcSslOptions] used to enable secure communication with the server.
  * @param haAddressPool A list of [NetworkHostAndPort] representing the addresses of servers in HA mode.
+ * The client will attempt to connect to a live server by trying each address in the list. If the servers are not in
+ * HA mode, the client will round-robin from the beginning of the list and try all servers.
  * @param classLoader a classloader, which will be used (if provided) to discover available [SerializationCustomSerializer]s and [SerializationWhitelist]s
  * The client will attempt to connect to a live server by trying each address in the list. If the servers are not in
  * HA mode, the client will round-robin from the beginning of the list and try all servers.
  */
 class CordaRPCClient private constructor(
-        private val hostAndPort: NetworkHostAndPort,
+        private val hostAndPort: NetworkHostAndPort?,
+        private val haAddressPool: List<NetworkHostAndPort>,
         private val configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT,
         private val sslConfiguration: ClientRpcSslOptions? = null,
-        private val classLoader: ClassLoader? = null,
+        private val classLoader: ClassLoader? = null
-        private val haAddressPool: List<NetworkHostAndPort> = emptyList()
 ) {
     @JvmOverloads
-    constructor(hostAndPort: NetworkHostAndPort,
+    constructor(hostAndPort: NetworkHostAndPort, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT) : this(
-                configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT,
+            hostAndPort = hostAndPort, haAddressPool = emptyList(), configuration = configuration
-                classLoader: ClassLoader? = null)
+    )
-            : this(hostAndPort, configuration, null, classLoader = classLoader)
+
+    constructor(
+            hostAndPort: NetworkHostAndPort,
+            sslConfiguration: ClientRpcSslOptions? = null,
+            classLoader: ClassLoader? = null
+    ) : this(hostAndPort = hostAndPort, haAddressPool = emptyList(), sslConfiguration = sslConfiguration, classLoader = classLoader)
 
-    /**
-     * @param haAddressPool A list of [NetworkHostAndPort] representing the addresses of servers in HA mode.
-     * The client will attempt to connect to a live server by trying each address in the list. If the servers are not in
-     * HA mode, the client will round-robin from the beginning of the list and try all servers.
-     * @param configuration An optional configuration used to tweak client behaviour.
-     */
     @JvmOverloads
-    constructor(haAddressPool: List<NetworkHostAndPort>, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT) : this(haAddressPool.first(), configuration, null, null, haAddressPool)
+    constructor(
+            hostAndPort: NetworkHostAndPort,
+            configuration: CordaRPCClientConfiguration,
+            sslConfiguration: ClientRpcSslOptions?,
+            classLoader: ClassLoader? = null
+    ) : this(hostAndPort = hostAndPort, haAddressPool = emptyList(), configuration = configuration, sslConfiguration = sslConfiguration, classLoader = classLoader)
 
-    companion object {
+    @JvmOverloads
-        fun createWithSsl(
+    constructor(
-                hostAndPort: NetworkHostAndPort,
+            haAddressPool: List<NetworkHostAndPort>,
-                sslConfiguration: ClientRpcSslOptions,
+            configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT,
-                configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT
+            sslConfiguration: ClientRpcSslOptions? = null,
-        ): CordaRPCClient {
+            classLoader: ClassLoader? = null
-            return CordaRPCClient(hostAndPort, configuration, sslConfiguration)
+    ) : this(hostAndPort = null, haAddressPool = haAddressPool, configuration = configuration, sslConfiguration = sslConfiguration, classLoader = classLoader)
-        }
 
-        fun createWithSsl(
+    // Here to keep the keep ABI compatibility happy
-                haAddressPool: List<NetworkHostAndPort>,
+    companion object {}
-                sslConfiguration: ClientRpcSslOptions,
-                configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT
-        ): CordaRPCClient {
-            return CordaRPCClient(haAddressPool.first(), configuration, sslConfiguration, haAddressPool = haAddressPool)
-        }
-
-        internal fun createWithSslAndClassLoader(
-                hostAndPort: NetworkHostAndPort,
-                configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT,
-                sslConfiguration: ClientRpcSslOptions? = null,
-                classLoader: ClassLoader? = null
-        ): CordaRPCClient {
-            return CordaRPCClient(hostAndPort, configuration, sslConfiguration, classLoader = classLoader)
-        }
-    }
 
     init {
         try {
@@ -320,7 +310,7 @@ class CordaRPCClient private constructor(
         return when {
         // Client->RPC broker
             haAddressPool.isEmpty() -> RPCClient(
-                    rpcConnectorTcpTransport(hostAndPort, config = sslConfiguration),
+                    rpcConnectorTcpTransport(hostAndPort!!, config = sslConfiguration),
                     configuration,
                     if (classLoader != null) AMQP_RPC_CLIENT_CONTEXT.withClassLoader(classLoader) else AMQP_RPC_CLIENT_CONTEXT)
             else -> {

client/rpc/src/main/kotlin/net/corda/client/rpc/internal/CordaRPCClientUtils.kt

@@ -1,14 +0,0 @@
-package net.corda.client.rpc.internal
-
-import net.corda.client.rpc.CordaRPCClient
-import net.corda.client.rpc.CordaRPCClientConfiguration
-import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.core.messaging.ClientRpcSslOptions
-
-/** Utility which exposes the internal Corda RPC constructor to other internal Corda components */
-fun createCordaRPCClientWithSslAndClassLoader(
-        hostAndPort: NetworkHostAndPort,
-        configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT,
-        sslConfiguration: ClientRpcSslOptions? = null,
-        classLoader: ClassLoader? = null
-) = CordaRPCClient.createWithSslAndClassLoader(hostAndPort, configuration, sslConfiguration, classLoader)

docs/source/clientrpc.rst

@@ -440,8 +440,6 @@ Wire security
 ``CordaRPCClient`` has an optional constructor parameter of type ``ClientRpcSslOptions``, defaulted to ``null``, which allows
 communication with the node using SSL. Default ``null`` value means no SSL used in the context of RPC.
 
-To use this feature, the ``CordaRPCClient`` object provides a static factory method ``createWithSsl``.
-
 In order for this to work, the client needs to provide a truststore containing a certificate received from the node admin.
 (The Node does not expect the RPC client to present a certificate, as the client already authenticates using the mechanism described above.)
 

docs/source/contributing-philosophy.rst

@@ -44,8 +44,12 @@ Community maintainers
 ^^^^^^^^^^^^^^^^^^^^^
 Current community maintainers:
 
-* `Joel Dudley <https://github.com/joeldudleyr3>`_ - Contact via the `Corda Slack team <http://slack.corda.net/>`_, either in the
+* `Joel Dudley <https://github.com/joeldudleyr3>`_ - Contact me:
-  ``#community`` channel or via direct message using the handle ``@joel``
+
+    * On the `Corda Slack team <http://slack.corda.net/>`_, either in the ``#community`` channel or by direct message using the handle
+      ``@joel``
+
+    * By email: joel.dudley at r3.com
 
 We anticipate additional maintainers joining the project in the future from across the community.
 

docs/source/contributing.rst

@@ -3,6 +3,22 @@ How to contribute
 
 .. contents::
 
+Identifying an area to contribute
+---------------------------------
+There are several ways to identify an area where you can contribute to Corda:
+
+* The easiest is just to message one of the :ref:`Community Maintainers <community-maintainers>` saying "I want to help!". They'll work
+  with you to find an area for you to contribute
+
+* If you have a specific contribution in mind, confirm whether the contribution is appropriate first by reaching out in the
+  ``#contributing`` channel of the `Corda Slack <http://slack.corda.net/>`_ or contacting one of the
+  :ref:`Community Maintainers <community-maintainers>` directly
+
+* If you do not have a specific contribution in mind, you can also browse the issues labelled as ``help wanted`` on the
+  `Corda GitHub issues <https://github.com/corda/corda/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22>`_ page
+
+  * Issues that additionally have the ``good first issue`` label are considered ideal for first-timers
+
 Contribution guidelines
 -----------------------
 We believe one of the things that makes Corda special is its coherent design and we seek to retain this defining characteristic. From the
@@ -27,19 +43,6 @@ outset we defined some guidelines to ensure new contributions only ever enhance
   `our Jira work tracking system is public <https://r3-cev.atlassian.net/projects/CORDA/summary>`_. If in doubt, reach out to one of the
   :ref:`Community Maintainers <community-maintainers>`
 
-Identifying an area to contribute
----------------------------------
-There are two ways to identify an area where you can contribute to Corda:
-
-* If there is a specific contribution you would like to make, you should first confirm whether the contribution is appropriate by reaching
-  out in the ``#contributing`` channel of the `Corda Slack <http://slack.corda.net/>`_ or contacting one of the
-  :ref:`Community Maintainers <community-maintainers>` directly
-
-* If you do not have a specific contribution in mind, you can browse issues labelled as ``help wanted`` in the
-  `Corda GitHub Issues <https://github.com/corda/corda/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22>`_
-
-  * Issues that additionally have the ``good first issue`` label are considered ideal for first-timers
-
 Making the required changes
 ---------------------------
 You should make your changes as follows:

docs/source/index.rst

@@ -72,6 +72,23 @@ We look forward to seeing what you can do with Corda!
    release-notes.rst
    changelog.rst
 
+.. conditional-toctree::
+   :caption: Participate
+   :maxdepth: 2
+   :if_tag: htmlmode
+
+   contributing-index.rst
+   corda-repo-layout.rst
+   deterministic-modules.rst
+   changelog
+
+.. conditional-toctree::
+   :caption: Corda Network
+   :maxdepth: 2
+   :if_tag: htmlmode
+
+   corda-network/index.md
+
 .. conditional-toctree::
    :caption: Design docs
    :maxdepth: 2
@@ -91,20 +108,3 @@ We look forward to seeing what you can do with Corda!
    design/data-model-upgrades/signature-constraints.md
    design/data-model-upgrades/package-namespace-ownership.md
    design/targetversion/design.md
-
-.. conditional-toctree::
-   :caption: Participate
-   :maxdepth: 2
-   :if_tag: htmlmode
-
-   contributing-index.rst
-   corda-repo-layout.rst
-   deterministic-modules.rst
-   changelog
-
-.. conditional-toctree::
-   :caption: Corda Network
-   :maxdepth: 2
-   :if_tag: htmlmode
-
-   corda-network/index.md

node-api/src/main/kotlin/net/corda/nodeapi/internal/bridging/AMQPBridgeManager.kt

@@ -158,7 +158,7 @@ class AMQPBridgeManager(config: MutualSslConfiguration, maxMessageSize: Int,
                 logWarnWithMDC(msg)
                 bridgeMetricsService?.packetDropEvent(artemisMessage, msg)
                 // Ack the message to prevent same message being sent to us again.
-                artemisMessage.acknowledge()
+                artemisMessage.individualAcknowledge()
                 return
             }
             val data = ByteArray(artemisMessage.bodySize).apply { artemisMessage.bodyBuffer.readBytes(this) }
@@ -181,7 +181,7 @@ class AMQPBridgeManager(config: MutualSslConfiguration, maxMessageSize: Int,
                 logDebugWithMDC { "Bridge ACK ${sendableMessage.onComplete.get()}" }
                 lock.withLock {
                     if (sendableMessage.onComplete.get() == MessageStatus.Acknowledged) {
-                        artemisMessage.acknowledge()
+                        artemisMessage.individualAcknowledge()
                     } else {
                         logInfoWithMDC("Rollback rejected message uuid: ${artemisMessage.getObjectProperty("_AMQ_DUPL_ID")}")
                         // We need to commit any acknowledged messages before rolling back the failed

node/capsule/build.gradle

@@ -50,7 +50,7 @@ task buildCordaJAR(type: FatCapsule, dependsOn: project(':node').tasks.jar) {
         applicationVersion = corda_release_version
         applicationId = "net.corda.node.Corda"
         // See experimental/quasar-hook/README.md for how to generate.
-        def quasarExcludeExpression = "x(antlr**;bftsmart**;ch**;co.paralleluniverse**;com.codahale**;com.esotericsoftware**;com.fasterxml**;com.google**;com.ibm**;com.intellij**;com.jcabi**;com.nhaarman**;com.opengamma**;com.typesafe**;com.zaxxer**;de.javakaffee**;groovy**;groovyjarjarantlr**;groovyjarjarasm**;io.atomix**;io.github**;io.netty**;jdk**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**)"
+        def quasarExcludeExpression = "x(antlr**;bftsmart**;ch**;co.paralleluniverse**;com.codahale**;com.esotericsoftware**;com.fasterxml**;com.google**;com.ibm**;com.intellij**;com.jcabi**;com.nhaarman**;com.opengamma**;com.typesafe**;com.zaxxer**;de.javakaffee**;groovy**;groovyjarjarantlr**;groovyjarjarasm**;io.atomix**;io.github**;io.netty**;jdk**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**;com.lmax**;picocli**;liquibase**;com.github.benmanes**;org.json**;org.postgresql**;nonapi.io.github.classgraph**)"
         javaAgents = ["quasar-core-${quasar_version}-jdk8.jar=${quasarExcludeExpression}"]
         systemProperties['visualvm.display.name'] = 'Corda'
         minJavaVersion = '1.8.0'

node/src/integration-test/kotlin/net/corda/node/services/rpc/RpcSslTest.kt

@@ -47,7 +47,7 @@ class RpcSslTest {
 
         driver(DriverParameters(startNodesInProcess = true, notarySpecs = emptyList())) {
             val node = startNode(rpcUsers = listOf(user), customOverrides = brokerSslOptions.useSslRpcOverrides()).getOrThrow()
-            val client = CordaRPCClient.createWithSsl(node.rpcAddress, sslConfiguration = clientSslOptions)
+            val client = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions)
             val connection = client.start(user.username, user.password)
 
             connection.proxy.apply {
@@ -58,7 +58,7 @@ class RpcSslTest {
             connection.close()
 
             Assertions.assertThatThrownBy {
-                val connection2 = CordaRPCClient.createWithSsl(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, "wrong")
+                val connection2 = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, "wrong")
                 connection2.proxy.apply {
                     nodeInfo()
                     failedLogin = true
@@ -86,7 +86,7 @@ class RpcSslTest {
         driver(DriverParameters(startNodesInProcess = true, notarySpecs = emptyList())) {
             val node = startNode(rpcUsers = listOf(user), customOverrides = brokerSslOptions.useSslRpcOverrides()).getOrThrow()
             Assertions.assertThatThrownBy {
-                val connection = CordaRPCClient.createWithSsl(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, user.password)
+                val connection = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, user.password)
                 connection.proxy.apply {
                     nodeInfo()
                     successful = true
@@ -125,7 +125,7 @@ class RpcSslTest {
 
         driver(DriverParameters(startNodesInProcess = true, notarySpecs = emptyList())) {
             val node = startNode(customOverrides = brokerSslOptions.useSslRpcOverrides()).getOrThrow()
-            val client = CordaRPCClient.createWithSsl(node.rpcAddress, sslConfiguration = clientSslOptions)
+            val client = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions)
 
             Assertions.assertThatThrownBy {
                 client.start(NODE_RPC_USER, NODE_RPC_USER).use { connection ->
@@ -133,7 +133,7 @@ class RpcSslTest {
                 }
             }.isInstanceOf(ActiveMQException::class.java)
 
-            val clientAdmin = CordaRPCClient.createWithSsl(node.rpcAdminAddress, sslConfiguration = clientSslOptions)
+            val clientAdmin = CordaRPCClient(node.rpcAdminAddress, sslConfiguration = clientSslOptions)
 
             Assertions.assertThatThrownBy {
                 clientAdmin.start(NODE_RPC_USER, NODE_RPC_USER).use { connection ->

testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/DriverDSLImpl.kt

@@ -5,7 +5,8 @@ import com.typesafe.config.Config
 import com.typesafe.config.ConfigFactory
 import com.typesafe.config.ConfigRenderOptions
 import com.typesafe.config.ConfigValueFactory
-import net.corda.client.rpc.internal.createCordaRPCClientWithSslAndClassLoader
+import net.corda.client.rpc.CordaRPCClient
+import net.corda.client.rpc.CordaRPCClientConfiguration
 import net.corda.cliutils.CommonCliConstants.BASE_DIR
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.concurrent.firstOf
@@ -164,7 +165,7 @@ class DriverDSLImpl(
     private fun establishRpc(config: NodeConfig, processDeathFuture: CordaFuture<out Process>): CordaFuture<CordaRPCOps> {
         val rpcAddress = config.corda.rpcOptions.address
         val clientRpcSslOptions = clientSslOptionsCompatibleWith(config.corda.rpcOptions)
-        val client = createCordaRPCClientWithSslAndClassLoader(rpcAddress, sslConfiguration = clientRpcSslOptions)
+        val client = CordaRPCClient(rpcAddress, sslConfiguration = clientRpcSslOptions)
         val connectionFuture = poll(executorService, "RPC connection") {
             try {
                 config.corda.rpcUsers[0].run { client.start(username, password) }
@@ -754,7 +755,8 @@ class DriverDSLImpl(
                     "io.github**;io.netty**;jdk**;joptsimple**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;" +
                     "org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;" +
                     "org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;" +
-                    "org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**;)"
+                    "org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**;" +
+                    "com.lmax**;picocli**;liquibase**;com.github.benmanes**;org.json**;org.postgresql**;nonapi.io.github.classgraph**;)"
             val extraJvmArguments = systemProperties.removeResolvedClasspath().map { "-D${it.key}=${it.value}" } +
                     "-javaagent:$quasarJarPath=$excludePattern"
             val loggingLevel = if (debugPort == null) "INFO" else "DEBUG"

tools/shell/src/main/kotlin/net/corda/tools/shell/InteractiveShell.kt

@@ -8,10 +8,10 @@ import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
 import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator
 import net.corda.client.jackson.JacksonSupport
 import net.corda.client.jackson.StringToMethodCallParser
+import net.corda.client.rpc.CordaRPCClient
 import net.corda.client.rpc.CordaRPCClientConfiguration
 import net.corda.client.rpc.CordaRPCConnection
 import net.corda.client.rpc.PermissionException
-import net.corda.client.rpc.internal.createCordaRPCClientWithSslAndClassLoader
 import net.corda.core.CordaException
 import net.corda.core.concurrent.CordaFuture
 import net.corda.core.contracts.UniqueIdentifier
@@ -95,7 +95,7 @@ object InteractiveShell {
      */
     fun startShell(configuration: ShellConfiguration, classLoader: ClassLoader? = null) {
         rpcOps = { username: String, credentials: String ->
-            val client = createCordaRPCClientWithSslAndClassLoader(hostAndPort = configuration.hostAndPort,
+            val client = CordaRPCClient(hostAndPort = configuration.hostAndPort,
                     configuration = CordaRPCClientConfiguration.DEFAULT.copy(
                             maxReconnectAttempts = 1
                     ),

webserver/src/main/kotlin/net/corda/webserver/internal/NodeWebServer.kt

@@ -199,7 +199,7 @@ class NodeWebServer(val config: WebServerConfig) {
 
     private fun connectLocalRpcAsNodeUser(): CordaRPCOps {
         log.info("Connecting to node at ${config.rpcAddress} as ${config.runAs}")
-        val client = CordaRPCClient(config.rpcAddress, classLoader = javaClass.classLoader)
+        val client = CordaRPCClient(hostAndPort = config.rpcAddress, classLoader = javaClass.classLoader)
         val connection = client.start(config.runAs.username, config.runAs.password)
         return connection.proxy
     }