rpc

Overview ¶

Package rpc provides a proto RPC service.

A simple client example (based on the server below):

client, err := New(socketAddr, cred.UID.Int(), cred.GID.Int(), []os.FileMode{0770, 0771})
if err != nil {
	// Do something
}

ctx, cancel := context.WitheTimeout(5 * time.Second)
req := &pb.SumReq{Ints: 1, 2, 3}
resp := &pb.SumResp{}

retry:
	if err := client.Call(ctx, "/math/sum", req, resp); err != nil {
		if rpc.Retryable(err) {
			// Okay, so you probably should do this in a for loop, but I wanted to use
			// a label for the hell of it.
			goto retry
		}
		// Do something here, cause you have a non-retryable error.
	}
	if resp.Err != nil {
		// Do something with the internal error.
	}
	fmt.Printf("Sum of %#v = %d\n", req, resp.Sum)

A simple service works like:

type MathServer struct{}

func (m *MathServer) Sum(ctx context.Context, req []byte]) ([]byte, error) {
	request := &pb.SumReq{}
	if err := proto.Unmarshal(req, request); err != nil {
		return nil, rpc.Errorf(rpc.ETBadData, "request could not be unmarshalled into SumReq: %s", err)
	}

	response := &pb.SumResp{}
	for _, i := range request.Ints {
		response.Sum += i
	}
	b, err := proto.Marshal(response)
	if err != nil {
		return nil, rpc.Errorf(rpc.ETBadData, "request could not be unmarshalled into SumReq: %s", err)
	}
	return b, nil
}

func main() {
	cred, err := uds.Current()
	if err != nil {
		panic(err)
	}

	serv, err := NewServer("socketAddr", cred.UID.Int(), cred.GID.Int(), 0770)
	if err != nil {
		panic(err)
	}

	ms := MathServer{}

	serv.RegisterMethod("/math/sum", ms.Sum)

	if err := serv.Start(); err != nil {
		log.Fatal(err)
	}
}

Note: The server should only return errors to clients when something goes wrong with the RPC. This makes it predictable on the server side when the error is retryable. When the service has an error, I recommend returning the expected response, which should have a dict containing your custom error code and the error message. This allows your clients to decide if they should retry a request.