Package net.corda.client.rpc

Class CordaRPCClient

  • All Implemented Interfaces:
    
public final 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 start returns an 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 net.corda.client.rpc.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 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 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 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 CouldNotStartFlowException.

    • Constructor Detail

      • CordaRPCClient

        CordaRPCClient(<Error class: unknown class> hostAndPort, <Error class: unknown class> sslConfiguration, ClassLoader classLoader)

      • CordaRPCClient

        CordaRPCClient(<Error class: unknown class> hostAndPort, CordaRPCClientConfiguration configuration, <Error class: unknown class> sslConfiguration, ClassLoader classLoader, Set<<Error class: unknown class><out <Error class: unknown class>, out <Error class: unknown class>>> customSerializers)

      • CordaRPCClient

        CordaRPCClient(List<<Error class: unknown class>> haAddressPool, CordaRPCClientConfiguration configuration, <Error class: unknown class> sslConfiguration, ClassLoader classLoader, Set<<Error class: unknown class><out <Error class: unknown class>, out <Error class: unknown class>>> customSerializers)

    • Method Detail

      • getRegisteredCustomSerializers

         final List<<Error class: unknown class><out <Error class: unknown class>, out <Error class: unknown class>>> getRegisteredCustomSerializers()

      • start

         final CordaRPCConnection ,.,.,net.corda.client.rpc.GracefulReconnect)>start(String username, String password, <Error class: unknown class> externalTrace, <Error class: unknown class> impersonatedActor, <Error class: unknown class> 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.

        Parameters:
        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 GracefulReconnect class containing callback logic when the RPC is dis/reconnected unexpectedly.

      • use

         final <A extends Any> A use(String username, String password, Function1<CordaRPCConnection, 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.