public class CordaRPCClient
An RPC client connects to the specified server and allows you to make calls to the server that perform various useful tasks. Please see the Client RPC section of docs.corda.net to learn more about how this API works. A brief description is provided here.
Calling CordaRPCClient.start
returns an interface RPCConnection
containing a proxy that lets you invoke RPCs on the server. Calls on
it block, and if the server throws an exception then it will be rethrown on the client. Proxies are thread safe and
may be used to invoke multiple RPCs in parallel.
RPC sends and receives are logged on the net.corda.rpc logger.
The CordaRPCOps defines what client RPCs are available. If an RPC returns an rx.Observable anywhere in the object
graph returned then the server-side observable is transparently forwarded to the client side here.
You are expected to use it. The server will begin sending messages immediately that will be buffered on the
client, you are expected to drain by subscribing to the returned observer. You can opt-out of this by simply
calling the UtilsKt.notUsed
method on it.
You don't have to explicitly close the observable if you actually subscribe to it: it will close itself and free up the server-side resources either when the client or JVM itself is shutdown, or when there are no more subscribers to it. Once all the subscribers to a returned observable are unsubscribed or the observable completes successfully or with an error, the observable is closed and you can't then re-subscribe again: you'll have to re-request a fresh observable with another RPC.
In case of loss of connection to the server, the client will try to reconnect using the settings provided via
class CordaRPCClientConfiguration
. If the client was created using a list of hosts via haAddressPool, automatic failover will occur
(the servers have to be started in HA mode). While attempting failover, current and future RPC calls will throw
class RPCException
and previously returned observables will call onError().
If you want to enable a more graceful form of reconnection, you can make use of the gracefulReconnect argument of the CordaRPCClient.start
method.
If this is set to true, then:
The client will automatically reconnect, when the connection is broken regardless of whether you provided a single or multiple addresses.
Simple RPC calls that return data (e.g. CordaRPCOps.networkParameters) will block and return after the connection has been re-established and the node is up.
RPC calls that return rx.Observables (e.g. CordaRPCOps.vaultTrack) will automatically reconnect and keep sending events for the subscribed rx.Observables. Note: In this approach, some events might be lost during a re-connection and not sent in the subscribed rx.Observables.
RPC calls that invoke flows (e.g. CordaRPCOps.startFlowDynamic) will fail during a disconnection throwing
a class CouldNotStartFlowException
.
CordaRPCClient.start
,
interface RPCConnection
,
CordaRPCOps,
rx.Observable,
UtilsKt.notUsed
,
class CordaRPCClientConfiguration
,
class RPCException
,
CordaRPCClient.start
,
CordaRPCOps.networkParameters,
rx.Observable,
CordaRPCOps.vaultTrack,
rx.Observable,
rx.Observable,
CordaRPCOps.startFlowDynamic,
class CouldNotStartFlowException
Modifier and Type | Class and Description |
---|---|
static class |
CordaRPCClient.Companion |
Modifier and Type | Field and Description |
---|---|
static CordaRPCClient.Companion |
Companion |
Constructor and Description |
---|
CordaRPCClient(NonExistentClass hostAndPort,
CordaRPCClientConfiguration configuration) |
CordaRPCClient(NonExistentClass hostAndPort,
CordaRPCClientConfiguration configuration,
java.lang.ClassLoader classLoader) |
CordaRPCClient(NonExistentClass hostAndPort,
NonExistentClass sslConfiguration,
java.lang.ClassLoader classLoader) |
CordaRPCClient(NonExistentClass hostAndPort,
CordaRPCClientConfiguration configuration,
NonExistentClass sslConfiguration,
java.lang.ClassLoader classLoader) |
CordaRPCClient(java.util.List<? extends error.NonExistentClass> haAddressPool,
CordaRPCClientConfiguration configuration,
NonExistentClass sslConfiguration,
java.lang.ClassLoader classLoader) |
CordaRPCClient(NonExistentClass hostAndPort,
CordaRPCClientConfiguration configuration,
NonExistentClass sslConfiguration,
java.lang.ClassLoader classLoader,
java.util.Set<? extends error.NonExistentClass> customSerializers) |
CordaRPCClient(java.util.List<? extends error.NonExistentClass> haAddressPool,
CordaRPCClientConfiguration configuration,
NonExistentClass sslConfiguration,
java.lang.ClassLoader classLoader,
java.util.Set<? extends error.NonExistentClass> customSerializers) |
Modifier and Type | Method and Description |
---|---|
java.util.List<NonExistentClass> |
getRegisteredCustomSerializers() |
CordaRPCConnection |
start(java.lang.String username,
java.lang.String password,
GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose or RPCConnection.forceClose methods to dispose of the connection object
when done. |
CordaRPCConnection |
start(java.lang.String username,
java.lang.String password,
NonExistentClass targetLegalIdentity,
GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose or RPCConnection.forceClose methods to dispose of the connection object
when done. |
CordaRPCConnection |
start(java.lang.String username,
java.lang.String password,
NonExistentClass externalTrace,
NonExistentClass impersonatedActor,
GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose or RPCConnection.forceClose methods to dispose of the connection object
when done. |
CordaRPCConnection |
start(java.lang.String username,
java.lang.String password,
NonExistentClass externalTrace,
NonExistentClass impersonatedActor,
NonExistentClass targetLegalIdentity,
GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose or RPCConnection.forceClose methods to dispose of the connection object
when done. |
<A> A |
use(java.lang.String username,
java.lang.String password,
Function1<? super net.corda.client.rpc.CordaRPCConnection,? extends A> block)
A helper for Kotlin users that simply closes the connection after the block has executed. Be careful not to
over-use this, as setting up and closing connections takes time.
|
public static CordaRPCClient.Companion Companion
public CordaRPCClient(NonExistentClass hostAndPort, CordaRPCClientConfiguration configuration)
public CordaRPCClient(NonExistentClass hostAndPort, CordaRPCClientConfiguration configuration, java.lang.ClassLoader classLoader)
public CordaRPCClient(NonExistentClass hostAndPort, NonExistentClass sslConfiguration, java.lang.ClassLoader classLoader)
public CordaRPCClient(NonExistentClass hostAndPort, CordaRPCClientConfiguration configuration, NonExistentClass sslConfiguration, java.lang.ClassLoader classLoader)
public CordaRPCClient(java.util.List<? extends error.NonExistentClass> haAddressPool, CordaRPCClientConfiguration configuration, NonExistentClass sslConfiguration, java.lang.ClassLoader classLoader)
public CordaRPCClient(NonExistentClass hostAndPort, CordaRPCClientConfiguration configuration, NonExistentClass sslConfiguration, java.lang.ClassLoader classLoader, java.util.Set<? extends error.NonExistentClass> customSerializers)
public CordaRPCClient(java.util.List<? extends error.NonExistentClass> haAddressPool, CordaRPCClientConfiguration configuration, NonExistentClass sslConfiguration, java.lang.ClassLoader classLoader, java.util.Set<? extends error.NonExistentClass> customSerializers)
public java.util.List<NonExistentClass> getRegisteredCustomSerializers()
public CordaRPCConnection start(java.lang.String username, java.lang.String password, GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose
or RPCConnection.forceClose
methods to dispose of the connection object
when done.
username
- The username to authenticate with.password
- The password to authenticate with.gracefulReconnect
- a class GracefulReconnect
class containing callback logic when the RPC is dis/reconnected unexpectedlyRPCConnection.notifyServerAndClose
,
RPCConnection.forceClose
public CordaRPCConnection start(java.lang.String username, java.lang.String password, NonExistentClass targetLegalIdentity, GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose
or RPCConnection.forceClose
methods to dispose of the connection object
when done.
username
- The username to authenticate with.password
- The password to authenticate with.targetLegalIdentity
- in case of multi-identity RPC endpoint specific legal identity to which the calls must be addressed.gracefulReconnect
- a class GracefulReconnect
class containing callback logic when the RPC is dis/reconnected unexpectedlyRPCConnection.notifyServerAndClose
,
RPCConnection.forceClose
public CordaRPCConnection start(java.lang.String username, java.lang.String password, NonExistentClass externalTrace, NonExistentClass impersonatedActor, GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose
or RPCConnection.forceClose
methods to dispose of the connection object
when done.
username
- The username to authenticate with.password
- The password to authenticate with.externalTrace
- external Trace for correlation.impersonatedActor
- the actor on behalf of which all the invocations will be made.gracefulReconnect
- a class GracefulReconnect
class containing callback logic when the RPC is dis/reconnected unexpectedlyRPCConnection.notifyServerAndClose
,
RPCConnection.forceClose
public CordaRPCConnection start(java.lang.String username, java.lang.String password, NonExistentClass externalTrace, NonExistentClass impersonatedActor, NonExistentClass targetLegalIdentity, GracefulReconnect gracefulReconnect)
Logs in to the target server and returns an active connection. The returned connection is a java.io.Closeable
and can be used with a try-with-resources statement. If you don't use that, you should use the
RPCConnection.notifyServerAndClose
or RPCConnection.forceClose
methods to dispose of the connection object
when done.
username
- The username to authenticate with.password
- The password to authenticate with.externalTrace
- external Trace for correlation.impersonatedActor
- the actor on behalf of which all the invocations will be made.targetLegalIdentity
- in case of multi-identity RPC endpoint specific legal identity to which the calls must be addressed.gracefulReconnect
- a class GracefulReconnect
class containing callback logic when the RPC is dis/reconnected unexpectedly.
Note that when using graceful reconnect the values for CordaRPCClientConfiguration.connectionMaxRetryInterval and
CordaRPCClientConfiguration.maxReconnectAttempts will be overridden in order to mangage the reconnects.RPCConnection.notifyServerAndClose
,
RPCConnection.forceClose
public <A> A use(java.lang.String username, java.lang.String password, Function1<? super net.corda.client.rpc.CordaRPCConnection,? extends A> block)
A helper for Kotlin users that simply closes the connection after the block has executed. Be careful not to over-use this, as setting up and closing connections takes time.