rpc

README

rpc

Files in this directory are derived from Go source code

• File: server.go is derived from the net/rpc/server.go module

  • This is stripped down to provide only the server registration system so as to allow compatability with the Go library RPC callback API.

• File: LICENSE is the original Go license for this file.

Documentation

Overview

Package rpc provides access to the exported methods of an object across a network or other I/O connection. A server registers an object, making it visible as a service with the name of the type of the object. After registration, exported methods of the object will be accessible remotely. A server may register multiple objects (services) of different types but it is an error to register multiple objects of the same type.

Only methods that satisfy these criteria will be made available for remote access; other methods will be ignored:

• the method is exported.
• the method has two arguments, both exported (or builtin) types.
• the method's second argument is a pointer.
• the method has return type error.

In effect, the method must look schematically like

func (t *T) MethodName(argType T1, replyType *T2) error

where T, T1 and T2 can be marshaled by encoding/gob. These requirements apply even if a different codec is used. (In the future, these requirements may soften for custom codecs.)

The method's first argument represents the arguments provided by the caller; the second argument represents the result parameters to be returned to the caller. The method's return value, if non-nil, is passed back as a string that the client sees as if created by errors.New. If an error is returned, the reply parameter will not be sent back to the client.

Here is a simple example. A server wishes to export an object of type Arith:

package server

type Args struct {
	A, B int
}

type Quotient struct {
	Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	quo.Quo = args.A / args.B
	quo.Rem = args.A % args.B
	return nil
}

The server calls:

arith := new(Arith)
rpc.Register(arith)

Index

• Variables
• type Server
  • func NewServer() *Server
  • func (server *Server) Call(ServiceMethod string, in *bytes.Buffer, out *bytes.Buffer, sender string) (err error)
  • func (server *Server) Register(rcvr interface{}) error
  • func (server *Server) RegisterName(name string, rcvr interface{}) error

Variables

var DefaultServer = NewServer()

DefaultServer is the default instance of *Server.

Types

type Server

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

Server represents an RPC Server.

func NewServer

func NewServer() *Server

NewServer returns a new Server.

func (*Server) Call

func (server *Server) Call(ServiceMethod string, in *bytes.Buffer, out *bytes.Buffer, sender string) (err error)

execute a server side call

func (*Server) Register

func (server *Server) Register(rcvr interface{}) error

Register publishes in the server the set of methods of the receiver value that satisfy the following conditions:

• exported method
• two arguments, both of exported type
• the second argument is a pointer
• one return value, of type error

It returns an error if the receiver is not an exported type or has no suitable methods. It also logs the error using package log. The client accesses each method using a string of the form "Type.Method", where Type is the receiver's concrete type.

func (*Server) RegisterName

func (server *Server) RegisterName(name string, rcvr interface{}) error

RegisterName is like Register but uses the provided name for the type instead of the receiver's concrete type.