package rpc2

Import Path
	github.com/cenkalti/rpc2 (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package

Involved Source Files

	  d client.go
		Package rpc2 provides bi-directional RPC client and server similar to net/rpc.

	    codec.go
	    debug.go
	    server.go
	    state.go
Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type Call (struct)
		Call represents an active RPC.

		Fields (total 5)
			Args interface{}
				// The argument to the function (*struct).

			Done chan *Call
				// Strobes when call is complete.

			Error error
				// After completion, the error status.

			Method string
				// The name of the service and method to call.

			Reply interface{}
				// The reply from the function (*struct).

		As Outputs Of (at least one exported)
			func (*Client).Go(method string, args interface{}, reply interface{}, done chan *Call) *Call
		As Inputs Of (at least one exported)
			func (*Client).Go(method string, args interface{}, reply interface{}, done chan *Call) *Call

	 type Client (struct)
		Client represents an RPC Client.
		There may be multiple outstanding Calls associated
		with a single Client, and a Client may be used by
		multiple goroutines simultaneously.

		Fields (only one)
			State *State
				// additional information to associate with client

		Methods (total 9)
			(*Client) Call(method string, args interface{}, reply interface{}) error
				Call invokes the named function, waits for it to complete, and returns its error status.

			(*Client) CallWithContext(ctx context.Context, method string, args interface{}, reply interface{}) error
				CallWithContext invokes the named function, waits for it to complete, and
				returns its error status, or an error from Context timeout.

			(*Client) Close() error
				Close waits for active calls to finish and closes the codec.

			(*Client) DisconnectNotify() chan struct{}
				DisconnectNotify returns a channel that is closed
				when the client connection has gone away.

			(*Client) Go(method string, args interface{}, reply interface{}, done chan *Call) *Call
				Go invokes the function asynchronously.  It returns the Call structure representing
				the invocation.  The done channel will signal when the call is complete by returning
				the same Call object.  If done is nil, Go will allocate a new channel.
				If non-nil, done must be buffered or Go will deliberately crash.

			(*Client) Handle(method string, handlerFunc interface{})
				Handle registers the handler function for the given method. If a handler already exists for method, Handle panics.

			(*Client) Notify(method string, args interface{}) error
				Notify sends a request to the receiver but does not wait for a return value.

			(*Client) Run()
				Run the client's read loop.
				You must run this method before calling any methods on the server.

			(*Client) SetBlocking(blocking bool)
				SetBlocking puts the client in blocking mode.
				In blocking mode, received requests are processes synchronously.
				If you have methods that may take a long time, other subsequent requests may time out.

		Implements (at least 3)
			*Client : github.com/prometheus/common/expfmt.Closer
			*Client : github.com/robfig/cron/v3.Job
			*Client : io.Closer
		As Outputs Of (at least 2)
			func NewClient(conn io.ReadWriteCloser) *Client
			func NewClientWithCodec(codec Codec) *Client
		As Inputs Of (at least 15)
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemoteBye(_ *Client, _ *rpc.Empty, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemotePushAllTicks(_ *Client, clocks []rpc.PushAllTicks, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemoteSchemaChange(_ *Client, msg *rpc.RespHandshake, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemoteSendingPayload(_ *Client, payload *rpc.ArgsPayload, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemoteSendPayload(_ *Client, payload *rpc.ArgsPayload, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Client).RemoteSetClock(_ *Client, clock *rpc.ClockMsg, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteAdd(_ *Client, args *rpc.ArgsMut, resp *rpc.RespResult) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteAddNS(_ *Client, args *rpc.ArgsMut, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteBye(_ *Client, _ *rpc.Empty, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteHandshake(client *Client, id *string, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteHello(client *Client, req *rpc.ArgsHello, resp *rpc.RespHandshake) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteRemove(_ *Client, args *rpc.ArgsMut, resp *rpc.RespResult) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteSet(_ *Client, args *rpc.ArgsMut, resp *rpc.RespResult) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteSetPushAllTicks(_ *Client, val bool, _ *rpc.Empty) error
			func github.com/pancsta/asyncmachine-go/pkg/rpc.(*Server).RemoteSync(_ *Client, sum uint64, resp *rpc.RespSync) error

	 type Codec (interface)
		A Codec implements reading and writing of RPC requests and responses.
		The client calls ReadHeader to read a message header.
		The implementation must populate either Request or Response argument.
		Depending on which argument is populated, ReadRequestBody or
		ReadResponseBody is called right after ReadHeader.
		ReadRequestBody and ReadResponseBody may be called with a nil
		argument to force the body to be read and then discarded.

		Methods (total 6)
			( Codec) Close() error
				Close is called when client/server finished with the connection.

			( Codec) ReadHeader(*Request, *Response) error
				ReadHeader must read a message and populate either the request
				or the response by inspecting the incoming message.

			( Codec) ReadRequestBody(interface{}) error
				ReadRequestBody into args argument of handler function.

			( Codec) ReadResponseBody(interface{}) error
				ReadResponseBody into reply argument of handler function.

			( Codec) WriteRequest(*Request, interface{}) error
				WriteRequest must be safe for concurrent use by multiple goroutines.

			( Codec) WriteResponse(*Response, interface{}) error
				WriteResponse must be safe for concurrent use by multiple goroutines.

		Implements (at least 2)
			 Codec : github.com/prometheus/common/expfmt.Closer
			 Codec : io.Closer
		As Outputs Of (at least one exported)
			func NewGobCodec(conn io.ReadWriteCloser) Codec
		As Inputs Of (at least 3)
			func NewClientWithCodec(codec Codec) *Client
			func (*Server).ServeCodec(codec Codec)
			func (*Server).ServeCodecWithState(codec Codec, state *State)

	 type Request (struct)
		Request is a header written before every RPC call.

		Fields (total 2)
			Method string
			Seq uint64
				// sequence number chosen by client

		As Inputs Of (at least 2)
			func Codec.ReadHeader(*Request, *Response) error
			func Codec.WriteRequest(*Request, interface{}) error

	 type Response (struct)
		Response is a header written before every RPC return.

		Fields (total 2)
			Error string
				// error, if any.

			Seq uint64
				// echoes that of the request

		As Inputs Of (at least 2)
			func Codec.ReadHeader(*Request, *Response) error
			func Codec.WriteResponse(*Response, interface{}) error

	 type Server (struct)
		Server responds to RPC requests made by Client.

		Methods (total 7)
			(*Server) Accept(lis net.Listener)
				Accept accepts connections on the listener and serves requests
				for each incoming connection.  Accept blocks; the caller typically
				invokes it in a go statement.

			(*Server) Handle(method string, handlerFunc interface{})
				Handle registers the handler function for the given method. If a handler already exists for method, Handle panics.

			(*Server) OnConnect(f func(*Client))
				OnConnect registers a function to run when a client connects.

			(*Server) OnDisconnect(f func(*Client))
				OnDisconnect registers a function to run when a client disconnects.

			(*Server) ServeCodec(codec Codec)
				ServeCodec is like ServeConn but uses the specified codec to
				decode requests and encode responses.

			(*Server) ServeCodecWithState(codec Codec, state *State)
				ServeCodecWithState is like ServeCodec but also gives the ability to
				associate a state variable with the client that persists across RPC calls.

			(*Server) ServeConn(conn io.ReadWriteCloser)
				ServeConn runs the server on a single connection.
				ServeConn blocks, serving the connection until the client hangs up.
				The caller typically invokes ServeConn in a go statement.
				ServeConn uses the gob wire format (see package gob) on the
				connection.  To use an alternate codec, use ServeCodec.

		As Outputs Of (at least one exported)
			func NewServer() *Server

	 type ServerError string (basic type)
		ServerError represents an error that has been returned from
		the remote side of the RPC connection.

		Methods (only one)
			( ServerError) Error() string
		Implements (at least one exported)
			 ServerError : error

	 type State (struct)

		Methods (total 2)
			(*State) Get(key string) (value interface{}, ok bool)
			(*State) Set(key string, value interface{})
		As Outputs Of (at least one exported)
			func NewState() *State
		As Inputs Of (at least one exported)
			func (*Server).ServeCodecWithState(codec Codec, state *State)


Package-Level Functions (total 5)

	 func NewClient(conn io.ReadWriteCloser) *Client
		NewClient returns a new Client to handle requests to the
		set of services at the other end of the connection.
		It adds a buffer to the write side of the connection so
		the header and payload are sent as a unit.

	 func NewClientWithCodec(codec Codec) *Client
		NewClientWithCodec is like NewClient but uses the specified
		codec to encode requests and decode responses.

	 func NewGobCodec(conn io.ReadWriteCloser) Codec
		NewGobCodec returns a new rpc2.Codec using gob encoding/decoding on conn.

	 func NewServer() *Server
		NewServer returns a new Server.

	 func NewState() *State
Package-Level Variables (total 2)

	  var DebugLog bool
		DebugLog controls the printing of internal and I/O errors.

	  var ErrShutdown error
		ErrShutdown is returned when the connection is closing or closed.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.