mrpc

type Call ¶

type Call interface {
	Context() context.Context

	// Method returns the name of the RPC method being called
	Method() string

	// UnmarshalArgs takes in a pointer and unmarshals the RPC call's arguments
	// into it. The properties of the unmarshaling are dependent on the
	// underlying implementation of the codec types.
	UnmarshalArgs(interface{}) error
}

Call is passed into the ServeRPC method and contains all information about the incoming RPC call which is being made

func WithContext(c Call, ctx context.Context) Call

func WithMethod(c Call, method string) Call

type Client ¶

type Client interface {
	CallRPC(ctx context.Context, res interface{}, method string, args interface{}) error
}

Client is an entity which can perform RPC calls against a remote endpoint.

res should be a pointer into which the result of the RPC call will be unmarshaled according to Client's implementation. args will be marshaled and sent to the remote endpoint according to Client's implementation.

func ReflectClient(h Handler) Client

type ClientFunc ¶

type ClientFunc func(context.Context, interface{}, string, interface{}) error

ClientFunc can be used to wrap an individual function which fits the CallRPC signature, and use that function as a Client

func (cf ClientFunc) CallRPC(
	ctx context.Context,
	res interface{},
	method string,
	args interface{},
) error

type Handler ¶

type Handler interface {
	ServeRPC(Call) (interface{}, error)
}

Handler is a type which serves RPC calls. For each incoming Call the ServeRPC method is called, and the return from the method is used as the response. If an error is returned the response return is ignored.

type HandlerFunc ¶

type HandlerFunc func(Call) (interface{}, error)

HandlerFunc can be used to wrap an individual function which fits the ServeRPC signature, and use that function as a Handler

func (hf HandlerFunc) ServeRPC(c Call) (interface{}, error)