Documentation

Overview

    Package server provides support routines for running jrpc2 servers.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func Loop

    func Loop(lst net.Listener, newService func() Service, opts *LoopOptions) error

      Loop obtains connections from lst and starts a server for each with the given service constructor and options, running in a new goroutine. If accept reports an error, the loop will terminate and the error will be reported once all the servers currently active have returned.

      TODO: Add options to support sensible rate-limitation.

      func NewStatic

      func NewStatic(assigner jrpc2.Assigner) func() Service

        NewStatic creates a static (singleton) service from the given assigner.

        Types

        type Local

        type Local struct {
        	Server *jrpc2.Server
        	Client *jrpc2.Client
        }

          Local represents a client and server connected by an in-memory pipe.

          func NewLocal

          func NewLocal(assigner jrpc2.Assigner, opts *LocalOptions) Local

            NewLocal constructs a *jrpc2.Server and a *jrpc2.Client connected to it via an in-memory pipe, using the specified assigner and options. If opts == nil, it behaves as if the client and server options are also nil.

            Example
            Output:
            
            Hello, world!
            

            func (Local) Close

            func (l Local) Close() error

              Close shuts down the client and waits for the server to exit, returning the result from the server's Wait method.

              type LocalOptions

              type LocalOptions struct {
              	Client *jrpc2.ClientOptions
              	Server *jrpc2.ServerOptions
              }

                LocalOptions control the behaviour of the server and client constructed by the NewLocal function.

                type LoopOptions

                type LoopOptions struct {
                	// If non-nil, this function is used to convert a stream connection to an
                	// RPC channel. If this field is nil, channel.RawJSON is used.
                	Framing channel.Framing
                
                	// If non-nil, these options are used when constructing the server to
                	// handle requests on an inbound connection.
                	ServerOptions *jrpc2.ServerOptions
                }

                  LoopOptions control the behaviour of the Loop function. A nil *LoopOptions provides default values as described.

                  type Service

                  type Service interface {
                  	// This method is called to create an assigner and initialize the service
                  	// for use.  If it reports an error, the server is not started.
                  	Assigner() (jrpc2.Assigner, error)
                  
                  	// This method is called when the server for this service has exited.
                  	Finish(jrpc2.ServerStatus)
                  }

                    Service is the interface used by the Loop function to start up a server.

                    type Simple

                    type Simple struct {
                    	// contains filtered or unexported fields
                    }

                      A Simple server manages execution of a server for a single service instance.

                      func NewSimple

                      func NewSimple(svc Service, opts *jrpc2.ServerOptions) *Simple

                        NewSimple constructs a new, unstarted *Simple instance for the given service. When run, the server will use the specified options.

                        Example
                        Output:
                        
                        SERVICE STARTED
                        Hello human
                        SERVICE FINISHED err=<nil>
                        

                        func (*Simple) Run

                        func (s *Simple) Run(ch channel.Channel) error

                          Run starts a server on the given channel, and blocks until it returns. The server exit status is reported to the service, and the error value returned. Once Run returns, it can be run again with a new channel.

                          If the caller does not need the error value and does not want to wait for the server to complete, call Run in a goroutine.