github.com/creachadair/jrpc2 (go): Package jrpc2 implements a server and a client for the JSON-RPC 2.0 protocol defined by http://www.jsonrpc.org/specification.  The *Server type implements a JSON-RPC server. A server communicates with a client over a channel.Channel, and dispatches client requests to user-defined method handlers.  Method handlers are functions with this signature:  A server finds the handler for a request by looking up its method name in a jrpc2.Assigner.  A Handler decodes request parameters using the UnmarshalParams method on the Request:  The handler package uses reflection to adapt functions that do not have this type to handlers.  For example, given:  call handler.New to convert Add to a handler function:  The handler package also provides handler.Map, which implements the Assigner interface with a Go map. To advertise this function under the name "Add":  Equipped with an Assigner we can now construct a Server:  To start the server, we need a channel.Channel. Implementations of the Channel interface handle the framing, transmission, and receipt of JSON messages.  The channel package implements some common framing disciplines for byte streams like pipes and sockets.  For this example, we'll use a channel that communicates over stdin and stdout, with messages delimited by newlines:  Now we can start the server:  The Start method does not block.  A server runs until its channel closes or it is stopped explicitly by calling srv.Stop(). To wait for the server to finish, call:  This reports the error that led to the server exiting.  The code for this example is available from tools/examples/adder/adder.go:  Interact with the server by sending JSON-RPC requests on stdin, such as for example:  The *Client type implements a JSON-RPC client. A client communicates with a server over a channel.Channel, and is safe for concurrent use by multiple goroutines. It supports batched requests and may have arbitrarily many pending requests in flight simultaneously.  To create a client we need a channel:  To send a single RPC, use the Call method:  Call blocks until the response is received. Errors returned by the server have concrete type *jrpc2.Error.  To issue a batch of concurrent requests, use the Batch method:  Batch blocks until all the responses are received.  An error from the Batch call reflects an error in sending the request: The caller must check each response separately for errors from the server. Responses are returned in the same order as the Spec values, save that notifications are omitted.  To decode the result from a successful response, use its UnmarshalResult method:  To close a client and discard all its pending work, call cli.Close().  A JSON-RPC notification is a one-way request: The client sends the request to the server, but the server does not reply. Use the Notify method of a client to send a notification:  A notification is complete once it has been sent. Notifications can also be sent as part of a batch request:  On the server, notifications are handled just like other requests, except that the return value is discarded once the handler returns. If a handler does not want to do anything for a notification, it can query the request:  The example above shows a server with one method.  A handler.Map works for any number of distinctly-named methods:  Maps may be combined with the handler.ServiceMap type to export multiple services from the same server:  This assigner dispatches "Math.Add" and "Math.Mul" to the arithmetic functions, and "Status.Get" to the getStatus function. A ServiceMap splits the method name on the first period ("."), and you may nest ServiceMaps more deeply if you require a more complex hierarchy.  A Server issues concurrent requests to handlers in parallel, up to the limit given by the Concurrency field in ServerOptions.  Two requests (either calls or notifications) are concurrent if they arrive as part of the same batch. In addition, two calls are concurrent if the time intervals between the arrival of the request objects and delivery of the response objects overlap.  The server may issue concurrent requests to their handlers in any order. Non-concurrent requests are processed in order of arrival. Notifications, in particular, can only be concurrent with other requests in the same batch.  This ensures a client that sends a notification can be sure its notification will be fully processed before any subsequent calls are issued to their handlers.  These rules imply that the client cannot rely on the execution order of calls that overlap in time: If the caller needs to ensure that call A completes before call B starts, it must wait for A to return before invoking B.  Per the JSON-RPC 2.0 spec, method names beginning with "rpc." are reserved by the implementation. By default, a server does not dispatch these methods to its assigner. In this configuration, the server exports a "rpc.serverInfo" method taking no parameters and returning a jrpc2.ServerInfo value.  Setting the DisableBuiltin server option to true removes special treatment of "rpc." method names, and disables the rpc.serverInfo handler.  When this option is true, method names beginning with "rpc." will be dispatched to the assigner like any other method.  The AllowPush server option allows handlers to "push" requests back to the client.  This is a non-standard extension of JSON-RPC used by some applications such as the Language Server Protocol (LSP). When this option is enabled, the server's Notify and Callback methods send requests back to the client. Otherwise, those methods will report an error:  A method handler may use jrpc2.ServerFromContext to access the server from its context, and then invoke these methods on it.  On the client side, the OnNotify and OnCallback options in jrpc2.ClientOptions provide hooks to which any server requests are delivered, if they are set.  Since not all clients support server push, handlers should set a timeout when using the server Callback method; otherwise the callback may block forever for a client response that will never arrive.
Keywords: go|golang|json-rpc|jsonrpc|jsonrpc2|rpc-library