net.corda.node.services.messaging

## Package net.corda.node.services.messaging

### Types

ArtemisMessagingComponent | `abstract class ArtemisMessagingComponent : SingletonSerializeAsToken` The base class for Artemis services that defines shared data structures and transport configuration
ArtemisMessagingServer | `class ArtemisMessagingServer : ArtemisMessagingComponent` This class configures and manages an Apache Artemis message queue broker.
ClientRPCRequestMessage | `data class ClientRPCRequestMessage` The contents of an RPC request message, separated from the MQ layer.
CordaRPCOps | `interface CordaRPCOps : RPCOps` RPC operations that the node exposes to clients using the Java client library. These can be called from client apps and are implemented by the node in the CordaRPCOpsImpl class.
MarshalledObservation | `data class MarshalledObservation` Used in the RPC wire protocol to wrap an observation with the handle of the observable its intended for.
NodeMessagingClient | `class NodeMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal` This class implements the MessagingService API using Apache Artemis, the successor to their ActiveMQ product. Artemis is a message queue broker and here we run a client connecting to the specified broker instance ArtemisMessagingServer. Its primarily concerned with peer-to-peer messaging.
ProtocolHandle | `data class ProtocolHandle<A>`
RPCDispatcher | `abstract class RPCDispatcher` Intended to service transient clients only (not p2p nodes) for short-lived, transient request/response pairs. If you need robustness, this is the wrong system. If you dont want a response, this is probably the wrong system (you could just send a message). If you want complex customisation of how requests/responses are handled, this is probably the wrong system.
RPCOps | `interface RPCOps` Base interface that all RPC servers must implement. Note: in Corda theres only one RPC interface. This base interface is here in case we split the RPC system out into a separate library one day.
StateMachineInfo | `data class StateMachineInfo`
StateMachineUpdate | `sealed class StateMachineUpdate`

### Annotations

RPCReturnsObservables | `annotation class RPCReturnsObservables` If an RPC is tagged with this annotation it may return one or more observables anywhere in its response graph. Calling such a method comes with consequences: its slower, and consumes server side resources as observations will buffer up on the server until theyre consumed by the client.
RPCSinceVersion | `annotation class RPCSinceVersion` Records the protocol version in which this RPC was added.

### Exceptions

PermissionException | `class PermissionException : RuntimeException`
RPCException | `open class RPCException : RuntimeException` Thrown to indicate a fatal error in the RPC system itself, as opposed to an error generated by the invoked method.

### Properties

CURRENT_RPC_USER | `val CURRENT_RPC_USER: ThreadLocal<User>` This is available to RPC implementations to query the validated User that is calling it. Each user has a set of permissions theyre entitled to which can be used to control access.
rpcLog | `val rpcLog: <ERROR CLASS>` Global RPC logger

### Functions

createRPCKryo | `fun createRPCKryo(observableSerializer: <ERROR CLASS><<ERROR CLASS><Any>>? = null): <ERROR CLASS>`
requirePermission | `fun requirePermission(permission: String): Unit` Helper method which checks that the current RPC user is entitled for the given permission. Throws a PermissionException otherwise.
startProtocol | `fun <T : Any, R : ProtocolLogic<T>> CordaRPCOps.startProtocol(protocolConstructor: () -> R): <ERROR CLASS>` These allow type safe invocations of protocols from Kotlin, e.g.: `fun <T : Any, A, R : ProtocolLogic<T>> CordaRPCOps.startProtocol(protocolConstructor: (A) -> R, arg0: A): <ERROR CLASS>` `fun <T : Any, A, B, R : ProtocolLogic<T>> CordaRPCOps.startProtocol(protocolConstructor: (A, B) -> R, arg0: A, arg1: B): <ERROR CLASS>` `fun <T : Any, A, B, C, R : ProtocolLogic<T>> CordaRPCOps.startProtocol(protocolConstructor: (A, B, C) -> R, arg0: A, arg1: B, arg2: C): <ERROR CLASS>` `fun <T : Any, A, B, C, D, R : ProtocolLogic<T>> CordaRPCOps.startProtocol(protocolConstructor: (A, B, C, D) -> R, arg0: A, arg1: B, arg2: C, arg3: D): <ERROR CLASS>`