jrpc2: github.com/creachadair/jrpc2 Index | Examples | Files | Directories

package jrpc2

import "github.com/creachadair/jrpc2"

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. Handlers satisfy the jrpc2.Handler interface by exporting a Handle method with this signature:

Handle(ctx Context.Context, req *jrpc2.Request) (interface{}, error)

The handler package helps adapt existing functions to this interface. A server finds the handler for a request by looking up its method name in a jrpc2.Assigner provided when the server is set up.

For example, suppose we have defined the following Add function, and would like to export it as a JSON-RPC method:

// Add returns the sum of a slice of integers.
func Add(ctx context.Context, values []int) int {
   sum := 0
   for _, v := range values {
      sum += v
   return sum

To convert Add to a jrpc2.Handler, call the handler.New function, which uses reflection to lift its argument into the jrpc2.Handler interface:

h := handler.New(Add)  // h is a jrpc2.Handler that invokes Add

We will advertise this function under the name "Add". For static assignments we can use a handler.Map, which finds methods by looking them up in a Go map:

assigner := handler.Map{
   "Add": handler.New(Add),

Equipped with an Assigner we can now construct a Server:

srv := jrpc2.NewServer(assigner, nil)  // nil for default options

To serve requests, we will next need a channel.Channel. The channel package exports functions that can adapt various input and output streams. For this example, we'll use a channel that delimits messages by newlines, and communicates on os.Stdin and os.Stdout:

ch := channel.Line(os.Stdin, os.Stdout)

Once started, the running server will handle incoming requests until the channel closes, or until it is stopped explicitly by calling srv.Stop(). To wait for the server to finish, call:

err := srv.Wait()

This will report the error that led to the server exiting. A working implementation of this example can found in cmd/examples/adder/adder.go:

$ go run cmd/examples/adder/adder.go

You can interact with this server by typing JSON-RPC requests on stdin.


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 establish a client we first need a channel:

import "net"

conn, err := net.Dial("tcp", "localhost:8080")
ch := channel.RawJSON(conn, conn)
cli := jrpc2.NewClient(ch, nil)  // nil for default options

To send a single RPC, use the Call method:

rsp, err := cli.Call(ctx, "Add", []int{1, 3, 5, 7})

This blocks until the response is received. Any error returned by the server, including cancellation or deadline exceeded, has concrete type *jrpc2.Error.

To issue a batch of requests all at once, use the Batch method:

rsps, err := cli.Batch(ctx, []jrpc2.Spec{
   {Method: "Math.Add", Params: []int{1, 2, 3}},
   {Method: "Math.Mul", Params: []int{4, 5, 6}},
   {Method: "Math.Max", Params: []int{-1, 5, 3, 0, 1}},

The Batch method waits 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. The responses will be 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:

var result int
if err := rsp.UnmarshalResult(&result); err != nil {
   log.Fatalln("UnmarshalResult:", err)

To shut down a client and discard all its pending work, call cli.Close().


The JSON-RPC protocol also supports a kind of request called a notification. Notifications differ from ordinary calls in that they are one-way: The client sends them to the server, but the server does not reply.

A jrpc2.Client supports sending notifications as follows:

err := cli.Notify(ctx, "Alert", map[string]string{
   "message": "A fire is burning!",

Unlike ordinary requests, there are no responses for notifications; a notification is complete once it has been sent.

On the server side, notifications are identical to ordinary requests, save that their 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:

if req.IsNotification() {
   return 0, nil  // ignore notifications


The *Client and *Server types support a non-standard cancellation protocol, that consists of a notification method "rpc.cancel" taking an array of request IDs to be cancelled. Upon receiving this notification, the server will cancel the context of each method handler whose ID is named.

When the context associated with a client request is cancelled, the client will send an "rpc.cancel" notification to the server for that request's ID. The "rpc.cancel" method is automatically handled (unless disabled) by the *Server implementation from this package.

Services with Multiple Methods

The examples above show a server with only one method using handler.New; you will often want to expose more than one. The handler.NewService function supports this by applying New to all the exported methods of a concrete value to produce a handler.Map for those methods:

type math struct{}

func (math) Add(ctx context.Context, vals ...int) int { ... }
func (math) Mul(ctx context.Context, vals []int) int { ... }

assigner := handler.NewService(math{})

This assigner maps the name "Add" to the Add method, and the name "Mul" to the Mul method, of the math value.

This may be further combined with the handler.Map type to allow different services to work together:

type status struct{}

func (status) Get(context.Context) (string, error) {
   return "all is well", nil

assigner := handler.ServiceMap{
   "Math":   handler.NewService(math{}),
   "Status": handler.NewService(status{}),

This assigner dispatches "Math.Add" and "Math.Mul" to the math value's methods, and "Status.Get" to the status value's method. A ServiceMap splits the method name on the first period ("."), and you may nest ServiceMaps more deeply if you require a more complex hierarchy.

Non-Standard Extension Methods

By default a jrpc2.Server exports the following built-in non-standard extension methods:

rpc.serverInfo(null) ⇒ jrpc2.ServerInfo
Returns a jrpc2.ServerInfo value giving server metrics.

rpc.cancel([]int)  [notification]
Request cancellation of the specified in-flight request IDs.

The rpc.cancel method works only as a notification, and will report an error if called as an ordinary method.

These extension methods are enabled by default, but may be disabled by setting the DisableBuiltin server option to true when constructing the server.

Server Notifications

The AllowPush option in jrpc2.ServerOptions enables the server to "push" notifications back to the client. This is a non-standard extension of JSON-RPC used by some applications such as the Language Server Protocol (LSP). The Push method sends a notification back to the client, if this feature is enabled:

if err := s.Push(ctx, "methodName", params); err == jrpc2.ErrNotifyUnsupported {
  // server notifications are not enabled

A method handler may use jrpc2.ServerPush to access this functionality. On the client side, the OnNotify option in jrpc2.ClientOptions provides a callback to which any server notifications are delivered if it is set.



Package Files

base.go client.go ctx.go doc.go error.go opts.go server.go special.go


const Version = "2.0"

Version is the version string for the JSON-RPC protocol understood by this implementation, defined at http://www.jsonrpc.org/specification.


var ErrConnClosed = errors.New("client connection is closed")

ErrConnClosed is returned by a server's Push method if it is called after the client connection is closed.

var ErrInvalidVersion = Errorf(code.InvalidRequest, "incorrect version marker")

ErrInvalidVersion is returned by ParseRequests if one or more of the requests in the input has a missing or invalid version marker.

var ErrNoData = errors.New("no data to unmarshal")

ErrNoData indicates that there are no data to unmarshal.

var ErrNotifyUnsupported = errors.New("server notifications are not enabled")

ErrNotifyUnsupported is returned by ServerPush if server notifications are not enabled in the specified context.

func CancelRequest Uses

func CancelRequest(ctx context.Context, id string)

CancelRequest requests the cancellation of the pending or in-flight request with the specified ID. If no request exists with that ID, this is a no-op without error.

func DataErrorf Uses

func DataErrorf(code code.Code, v interface{}, msg string, args ...interface{}) error

DataErrorf returns an error value of concrete type *Error having the specified code, error data, and formatted message string. If v == nil this behaves identically to Errorf(code, msg, args...).

func Errorf Uses

func Errorf(code code.Code, msg string, args ...interface{}) error

Errorf returns an error value of concrete type *Error having the specified code and formatted message string. It is shorthand for DataErrorf(code, nil, msg, args...)

func Network Uses

func Network(s string) string

Network guesses a network type for the specified address. The assignment of a network type uses the following heuristics:

If s does not have the form [host]:port, the network is assigned as "unix". The network "unix" is also assigned if port == "", port contains characters other than ASCII letters, digits, and "-", or if host contains a "/".

Otherwise, the network is assigned as "tcp". Note that this function does not verify whether the address is lexically valid.

func ServerMetrics Uses

func ServerMetrics(ctx context.Context) *metrics.M

ServerMetrics returns the server metrics collector associated with the given context, or nil if ctx does not have a collector attached. The context passed to a handler by *jrpc2.Server will include this value.

func ServerPush Uses

func ServerPush(ctx context.Context, method string, params interface{}) error

ServerPush posts a server notification to the client. If ctx does not contain a server notifier, this reports ErrNotifyUnsupported. The context passed to the handler by *jrpc2.Server will support notifications if the server was constructed with the AllowPush option set true.

type Assigner Uses

type Assigner interface {
    // Assign returns the handler for the named method, or nil.
    Assign(ctx context.Context, method string) Handler

    // Names returns a slice of all known method names for the assigner.  The
    // resulting slice is ordered lexicographically and contains no duplicates.
    Names() []string

An Assigner assigns a Handler to handle the specified method name, or nil if no method is available to handle the request.

type Client Uses

type Client struct {
    // contains filtered or unexported fields

A Client is a JSON-RPC 2.0 client. The client sends requests and receives responses on a channel.Channel provided by the caller.

func NewClient Uses

func NewClient(ch channel.Channel, opts *ClientOptions) *Client

NewClient returns a new client that communicates with the server via ch.

func (*Client) Batch Uses

func (c *Client) Batch(ctx context.Context, specs []Spec) ([]*Response, error)

Batch initiates a batch of concurrent requests, and blocks until all the responses return. The responses are returned in the same order as the original specs, omitting notifications.

Any error returned is from sending the batch; the caller must check each response for errors from the server.


// var cli = jrpc2.NewClient(cch, nil)
rsps, err := cli.Batch(ctx, []jrpc2.Spec{
    {Method: "Hello"},
    {Method: "Log", Params: Msg{"Sing it!"}, Notify: true},
if err != nil {
    log.Fatalf("Batch: %v", err)

fmt.Printf("len(rsps) = %d\n", len(rsps))
for i, rsp := range rsps {
    var msg string
    if err := rsp.UnmarshalResult(&msg); err != nil {
        log.Fatalf("Invalid result: %v", err)
    fmt.Printf("Response #%d: %s\n", i+1, msg)


Log: Sing it!
len(rsps) = 1
Response #1: Hello, world!

func (*Client) Call Uses

func (c *Client) Call(ctx context.Context, method string, params interface{}) (*Response, error)

Call initiates a single request and blocks until the response returns. If err != nil then rsp == nil, which also means that if rsp != nil then the request succeeded. Errors from the server have concrete type *jrpc2.Error.

rsp, err := c.Call(ctx, method, params)
if e, ok := err.(*jrpc2.Error); ok {
   log.Fatalf("Error from server: %v", err)
} else if err != nil {
   log.Fatalf("Call failed: %v", err)


// var cli = jrpc2.NewClient(cch, nil)
rsp, err := cli.Call(ctx, "Hello", nil)
if err != nil {
    log.Fatalf("Call: %v", err)
var msg string
if err := rsp.UnmarshalResult(&msg); err != nil {
    log.Fatalf("Decoding result: %v", err)


Hello, world!

func (*Client) CallResult Uses

func (c *Client) CallResult(ctx context.Context, method string, params, result interface{}) error

CallResult invokes Call with the given method and params. If it succeeds, the result is decoded into result. This is a convenient shorthand for Call followed by UnmarshalResult. It will panic if result == nil.


// var cli = jrpc2.NewClient(cch, nil)
var msg string
if err := cli.CallResult(ctx, "Hello", nil, &msg); err != nil {
    log.Fatalf("CallResult: %v", err)


Hello, world!

func (*Client) Close Uses

func (c *Client) Close() error

Close shuts down the client, abandoning any pending in-flight requests.

func (*Client) Notify Uses

func (c *Client) Notify(ctx context.Context, method string, params interface{}) error

Notify transmits a notification to the specified method and parameters. It blocks until the notification has been sent.

type ClientOptions Uses

type ClientOptions struct {
    // If not nil, send debug logs here.
    Logger *log.Logger

    // Instructs the client to tolerate responses that do not include the
    // required "jsonrpc" version marker.
    AllowV1 bool

    // Instructs the client not to send rpc.cancel notifications to the server
    // when the context for an in-flight request terminates.
    DisableCancel bool

    // If set, this function is called with the context, method name, and
    // encoded request parameters before the request is sent to the server.
    // Its return value replaces the request parameters. This allows the client
    // to send context metadata along with the request. If unset, the parameters
    // are unchanged.
    EncodeContext func(context.Context, string, json.RawMessage) (json.RawMessage, error)

    // If set, this function is called if a notification is received from the
    // server. If unset, server notifications are logged and discarded.  At
    // most one invocation of the callback will be active at a time.
    // Server notifications are a non-standard extension of JSON-RPC.
    OnNotify func(*Request)

ClientOptions control the behaviour of a client created by NewClient. A nil *ClientOptions provides sensible defaults.

type Error Uses

type Error struct {
    // contains filtered or unexported fields

Error is the concrete type of errors returned from RPC calls.

func (Error) Code Uses

func (e Error) Code() code.Code

Code returns the error code value associated with e.

func (Error) Error Uses

func (e Error) Error() string

Error renders e to a human-readable string for the error interface.

func (Error) HasData Uses

func (e Error) HasData() bool

HasData reports whether e has error data to unmarshal.

func (Error) MarshalJSON Uses

func (e Error) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface for Error values.

func (Error) Message Uses

func (e Error) Message() string

Message returns the message string associated with e.

func (Error) UnmarshalData Uses

func (e Error) UnmarshalData(v interface{}) error

UnmarshalData decodes the error data associated with e into v. It returns ErrNoData without modifying v if there was no data message attached to e.

func (*Error) UnmarshalJSON Uses

func (e *Error) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface for Error values.

type Handler Uses

type Handler interface {
    // Handle invokes the method with the specified request. The response value
    // must be JSON-marshalable or nil. In case of error, the handler can
    // return a value of type *jrpc2.Error to control the response code sent
    // back to the caller; otherwise the server will wrap the resulting value.
    // The context passed to the handler by a *jrpc2.Server includes two extra
    // values that the handler may extract.
    // To obtain a server metrics value, write:
    //    sm := jrpc2.ServerMetrics(ctx)
    // To obtain the inbound request message, write:
    //    req := jrpc2.InboundRequest(ctx)
    // The inbound request is the same value passed to the Handle method -- the
    // latter is primarily useful in handlers generated by handler.New, which do
    // not receive this value directly.
    Handle(context.Context, *Request) (interface{}, error)

A Handler handles a single request.

type RPCLogger Uses

type RPCLogger interface {
    // Called for each request received prior to invoking its handler.
    LogRequest(ctx context.Context, req *Request)

    // Called for each response produced by a handler, immediately prior to
    // sending it back to the client. The inbound request can be recovered from
    // the context using jrpc2.InboundRequest.
    LogResponse(ctx context.Context, rsp *Response)

An RPCLogger receives callbacks from a server to record the receipt of requests and the delivery of responses. These callbacks are invoked synchronously with the processing of the request.

type Request Uses

type Request struct {
    // contains filtered or unexported fields

A Request is a request message from a client to a server.

func InboundRequest Uses

func InboundRequest(ctx context.Context) *Request

InboundRequest returns the inbound request associated with the given context, or nil if ctx does not have an inbound request. The context passed to the handler by *jrpc2.Server will include this value.

This is mainly useful to wrapped server methods that do not have the request as an explicit parameter; for direct implementations of Handler.Handle the request value returned by InboundRequest will be the same value as was passed explicitly.

func ParseRequests Uses

func ParseRequests(msg []byte) ([]*Request, error)

ParseRequests parses a single request or a batch of requests from JSON. The result parameters are either nil or have concrete type json.RawMessage.

If any of the requests is missing or has an invalid JSON-RPC version, it returns ErrInvalidVersion along with the parsed results. Otherwise, no validation apart from basic structure is performed on the results.

func (*Request) HasParams Uses

func (r *Request) HasParams() bool

HasParams reports whether the request has non-empty parameters.

func (*Request) ID Uses

func (r *Request) ID() string

ID returns the request identifier for r, or "" if r is a notification.

func (*Request) IsNotification Uses

func (r *Request) IsNotification() bool

IsNotification reports whether the request is a notification, and thus does not require a value response.

func (*Request) Method Uses

func (r *Request) Method() string

Method reports the method name for the request.

func (*Request) ParamString Uses

func (r *Request) ParamString() string

ParamString returns the encoded request parameters of r as a string. If r has no parameters, it returns "".

func (*Request) UnmarshalParams Uses

func (r *Request) UnmarshalParams(v interface{}) error

UnmarshalParams decodes the request parameters of r into v. If r has empty parameters, it returns nil without modifying v. If r is invalid it returns an InvalidParams error.

By default, unknown keys are disallowed when unmarshaling into a v of struct type. The caller may override this, either by implementing json.Unmarshaler on the concrete type of v, or by unmarshaling into a json.RawMessage and explicitly decoding the result. The examples demonstrate how to do this.


const msg = `{"jsonrpc":"2.0", "id":101, "method":"M", "params":{"a":1, "b":2, "c":3}}`

reqs, err := jrpc2.ParseRequests([]byte(msg))
if err != nil {
    log.Fatalf("ParseRequests: %v", err)

var t, u struct {
    A   int `json:"a"`
    B   int `json:"b"`

// By default, unmarshaling prohibits unknown fields (here, "c").
err = reqs[0].UnmarshalParams(&t)
if code.FromError(err) != code.InvalidParams {
    log.Fatalf("Expected invalid parameters, got: %v", err)

// Solution 1: Decode explicitly.
var tmp json.RawMessage
if err := reqs[0].UnmarshalParams(&tmp); err != nil {
    log.Fatalf("UnmarshalParams: %v", err)
if err := json.Unmarshal(tmp, &t); err != nil {
    log.Fatalf("Unmarshal: %v", err)
fmt.Printf("t.A=%d, t.B=%d\n", t.A, t.B)

// Solution 2: Provide a type (here, "lax") that implements json.Unmarshaler.
if err := reqs[0].UnmarshalParams((*lax)(&u)); err != nil {
    log.Fatalf("UnmarshalParams: %v", err)
fmt.Printf("u.A=%d, u.B=%d\n", u.A, u.B)


t.A=1, t.B=2
u.A=1, u.B=2

type Response Uses

type Response struct {
    // contains filtered or unexported fields

A Response is a response message from a server to a client.

func (*Response) Error Uses

func (r *Response) Error() *Error

Error returns a non-nil *Error if the response contains an error.

func (*Response) ID Uses

func (r *Response) ID() string

ID returns the request identifier for r.

func (*Response) MarshalJSON Uses

func (r *Response) MarshalJSON() ([]byte, error)

MarshalJSON converts the response to equivalent JSON.

func (*Response) ResultString Uses

func (r *Response) ResultString() string

ResultString returns the encoded result message of r as a string. If r has no result, for example if r is an error response, it returns "".

func (*Response) SetID Uses

func (r *Response) SetID(id string)

SetID sets the request identifier for r. This is for use in proxies.

func (*Response) UnmarshalResult Uses

func (r *Response) UnmarshalResult(v interface{}) error

UnmarshalResult decodes the result message into v. If the request failed, UnmarshalResult returns the *Error value that would also be returned by r.Error(), and v is unmodified.

type Server Uses

type Server struct {
    // contains filtered or unexported fields

A Server is a JSON-RPC 2.0 server. The server receives requests and sends responses on a channel.Channel provided by the caller, and dispatches requests to user-defined Handlers.

func NewServer Uses

func NewServer(mux Assigner, opts *ServerOptions) *Server

NewServer returns a new unstarted server that will dispatch incoming JSON-RPC requests according to mux. To start serving, call Start.

N.B. It is only safe to modify mux after the server has been started if mux itself is safe for concurrent use by multiple goroutines.

This function will panic if mux == nil.


// Construct a new server with a single method "Hello".
s = jrpc2.NewServer(handler.Map{
    "Hello": handler.New(func(ctx context.Context) string {
        return "Hello, world!"
    "Log": handler.New(func(ctx context.Context, msg Msg) (bool, error) {
        fmt.Println("Log:", msg.Text)
        return true, nil
}, nil).Start(sch)

// We can query the server for its current status information, including a
// list of its methods.
si := s.ServerInfo()

fmt.Println(strings.Join(si.Methods, "\n"))



func (*Server) Push Uses

func (s *Server) Push(ctx context.Context, method string, params interface{}) error

Push posts a server-side notification to the client. This is a non-standard extension of JSON-RPC, and may not be supported by all clients. Unless s was constructed with the AllowPush option set true, this method will always report an error (ErrNotifyUnsupported) without sending anything. If Push is called after the client connection is closed, it returns ErrConnClosed.

func (*Server) ServerInfo Uses

func (s *Server) ServerInfo() *ServerInfo

ServerInfo returns an atomic snapshot of the current server info for s.

func (*Server) Start Uses

func (s *Server) Start(c channel.Channel) *Server

Start enables processing of requests from c. This function will panic if the server is already running.

func (*Server) Stop Uses

func (s *Server) Stop()

Stop shuts down the server. It is safe to call this method multiple times or from concurrent goroutines; it will only take effect once.

func (*Server) Wait Uses

func (s *Server) Wait() error

Wait blocks until the server terminates and returns the resulting error. It is equivalent to s.WaitStatus().Err.

func (*Server) WaitStatus Uses

func (s *Server) WaitStatus() ServerStatus

WaitStatus blocks until the server terminates, and returns the resulting status. After WaitStatus returns, whether or not there was an error, it is safe to call s.Start again to restart the server with a fresh channel.

type ServerInfo Uses

type ServerInfo struct {
    // The list of method names exported by this server.
    Methods []string `json:"methods,omitempty"`

    // Whether this server understands context wrappers.
    UsesContext bool `json:"usesContext"`

    // Metric values defined by the evaluation of methods.
    Counter  map[string]int64  `json:"counters,omitempty"`
    MaxValue map[string]int64  `json:"maxValue,omitempty"`
    Label    map[string]string `json:"labels,omitempty"`

    // When the server started.
    StartTime time.Time `json:"startTime,omitempty"`

ServerInfo is the concrete type of responses from the rpc.serverInfo method.

func RPCServerInfo Uses

func RPCServerInfo(ctx context.Context, cli *Client) (result *ServerInfo, err error)

RPCServerInfo calls the built-in rpc.serverInfo method exported by servers. It is a convenience wrapper for an invocation of cli.CallResult.

type ServerOptions Uses

type ServerOptions struct {
    // If not nil, send debug logs here.
    Logger *log.Logger

    // If not nil, the methods of this value are called to log each request
    // received and each response or error returned.
    RPCLog RPCLogger

    // Instructs the server to tolerate requests that do not include the
    // required "jsonrpc" version marker.
    AllowV1 bool

    // Instructs the server to allow server notifications, a non-standard
    // extension to the JSON-RPC protocol. If AllowPush is false, the Push
    // method of the server will report an error when called.
    AllowPush bool

    // Instructs the server to disable the built-in rpc.* handler methods.
    // By default, a server reserves all rpc.* methods, even if the given
    // assigner maps them. When this option is true, rpc.* methods are passed
    // along to the given assigner.
    DisableBuiltin bool

    // Allows up to the specified number of goroutines to execute concurrently
    // in request handlers. A value less than 1 uses runtime.NumCPU().
    Concurrency int

    // If set, this function is called with the method name and encoded request
    // parameters received from the client, before they are delivered to the
    // handler. Its return value replaces the context and argument values. This
    // allows the server to decode context metadata sent by the client.
    // If unset, ctx and params are used as given.
    DecodeContext func(context.Context, string, json.RawMessage) (context.Context, json.RawMessage, error)

    // If set, this function is called with the context and the client request
    // to be delivered to the handler. If CheckRequest reports a non-nil error,
    // the request fails with that error without invoking the handler.
    CheckRequest func(ctx context.Context, req *Request) error

    // If set, use this value to record server metrics. All servers created
    // from the same options will share the same metrics collector.  If none is
    // set, an empty collector will be created for each new server.
    Metrics *metrics.M

    // If nonzero this value as the server start time; otherwise, use the
    // current time when Start is called.
    StartTime time.Time

ServerOptions control the behaviour of a server created by NewServer. A nil *ServerOptions provides sensible defaults.

type ServerStatus Uses

type ServerStatus struct {
    Err error // the error that caused the server to stop (nil on success)
    // contains filtered or unexported fields

ServerStatus describes the status of a stopped server.

func (ServerStatus) Closed Uses

func (s ServerStatus) Closed() bool

Closed reports whether the server exited due to a channel close.

func (ServerStatus) Stopped Uses

func (s ServerStatus) Stopped() bool

Stopped reports whether the server exited due to Stop being called.

func (ServerStatus) Success Uses

func (s ServerStatus) Success() bool

Success reports whether the server exited without error.

type Spec Uses

type Spec struct {
    Method string
    Params interface{}
    Notify bool

A Spec combines a method name and parameter value. If the Notify field is true, the spec is sent as a notification instead of a request.


channelPackage channel defines a communications channel that can encode/transmit and decode/receive data records with a configurable framing discipline, and provides some simple framing implementations.
channel/chanutilPackage chanutil exports helper functions for working with channels and framing defined by the github.com/creachadair/jrpc2/channel package.
codePackage code defines error code values used by the jrpc2 package.
handlerPackage handler provides implementations of the jrpc2.Assigner interface, and support for adapting functions to the jrpc2.Handler interface.
jctxPackage jctx implements an encoder and decoder for request context values, allowing context metadata to be propagated through JSON-RPC.
jhttpPackage jhttp implements a bridge from HTTP to JSON-RPC.
metricsPackage metrics defines a concurrently-accessible metrics collector.
serverPackage server provides support routines for running jrpc2 servers.

Package jrpc2 imports 17 packages (graph) and is imported by 11 packages. Updated 2020-04-03. Refresh now. Tools for package owners.