protorpc

README

protorpc

██████╗ ██████╗  ██████╗ ████████╗ ██████╗       ██████╗ ██████╗  ██████╗
██╔══██╗██╔══██╗██╔═══██╗╚══██╔══╝██╔═══██╗      ██╔══██╗██╔══██╗██╔════╝
██████╔╝██████╔╝██║   ██║   ██║   ██║   ██║█████╗██████╔╝██████╔╝██║     
██╔═══╝ ██╔══██╗██║   ██║   ██║   ██║   ██║╚════╝██╔══██╗██╔═══╝ ██║     
██║     ██║  ██║╚██████╔╝   ██║   ╚██████╔╝      ██║  ██║██║     ╚██████╗
╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝       ╚═╝  ╚═╝╚═╝      ╚═════╝

Install

Install protorpc package:

1. go get github.com/xujiajun/protorpc
2. go run hello.go

Install protoc-gen-go plugin:

1. install protoc at first: http://github.com/google/protobuf/releases
2. go get github.com/xujiajun/protorpc/protoc-gen-go
3. go generate github.com/xujiajun/protorpc/examples/service.pb
4. go test github.com/xujiajun/protorpc/examples/service.pb

Examples

First, create echo.proto:

syntax = "proto3";

package service;

message EchoRequest {
	string msg = 1;
}

message EchoResponse {
	string msg = 1;
}

service EchoService {
	rpc Echo (EchoRequest) returns (EchoResponse);
	rpc EchoTwice (EchoRequest) returns (EchoResponse);
}

Second, generate echo.pb.go from echo.proto (we can use go generate to invoke this command, see proto.go).

protoc --go_out=plugins=protorpc:. echo.proto

Now, we can use the stub code like this:

package main

import (
	"fmt"
	"log"

	"github.com/xujiajun/protorpc"
	service "github.com/xujiajun/protorpc/examples/service.pb"
)

type Echo int

func (t *Echo) Echo(args *service.EchoRequest, reply *service.EchoResponse) error {
	reply.Msg = args.Msg
	return nil
}

func (t *Echo) EchoTwice(args *service.EchoRequest, reply *service.EchoResponse) error {
	reply.Msg = args.Msg + args.Msg
	return nil
}

func init() {
	go service.ListenAndServeEchoService("tcp", `127.0.0.1:9527`, new(Echo))
}

func main() {
	echoClient, err := service.DialEchoService("tcp", `127.0.0.1:9527`)
	if err != nil {
		log.Fatalf("service.DialEchoService: %v", err)
	}
	defer echoClient.Close()

	args := &service.EchoRequest{Msg: "你好, 世界!"}
	reply, err := echoClient.EchoTwice(args)
	if err != nil {
		log.Fatalf("echoClient.EchoTwice: %v", err)
	}
	fmt.Println(reply.Msg)

	// or use normal client
	client, err := protorpc.Dial("tcp", `127.0.0.1:9527`)
	if err != nil {
		log.Fatalf("protorpc.Dial: %v", err)
	}
	defer client.Close()

	echoClient1 := &service.EchoServiceClient{client}
	echoClient2 := &service.EchoServiceClient{client}
	reply, err = echoClient1.EchoTwice(args)
	reply, err = echoClient2.EchoTwice(args)
	_, _ = reply, err

	// Output:
	// 你好, 世界!你好, 世界!
}

More examples.

BUGS

Report bugs to me@xujiajun.cn.

Thanks!

Documentation

Overview

Package protorpc implements a Protobuf-RPC ClientCodec and ServerCodec for the rpc package.

To install it, you must first have Go (version 1) installed (see http://golang.org/doc/install). Next, install the standard protocol buffer implementation from http://github.com/google/protobuf/; you must be running version 2.3 or higher.

Finally run

go get github.com/xujiajun/protorpc
go get github.com/xujiajun/protorpc/protoc-gen-go

to install the support library and protocol compiler.

Here is a simple proto file("arith.pb/arith.proto"):

package arith;

message ArithRequest {
	optional int32 a = 1;
	optional int32 b = 2;
}

message ArithResponse {
	optional int32 val = 1;
	optional int32 quo = 2;
	optional int32 rem = 3;
}

service ArithService {
	rpc multiply (ArithRequest) returns (ArithResponse);
	rpc divide (ArithRequest) returns (ArithResponse);
}

Then use "protoc-gen-go" to generate "arith.pb.go" file(include rpc stub):

cd arith.pb && protoc --go_out=plugins=protorpc:. arith.proto

The server calls (for TCP service):

package server

import (
	"errors"

	"github.com/golang/protobuf/proto"

	"./arith.pb"
)

type Arith int

func (t *Arith) Multiply(args *arith.ArithRequest, reply *arith.ArithResponse) error {
	reply.Val = proto.Int32(args.GetA() * args.GetB())
	return nil
}

func (t *Arith) Divide(args *arith.ArithRequest, reply *arith.ArithResponse) error {
	if args.GetB() == 0 {
		return errors.New("divide by zero")
	}
	reply.Quo = proto.Int32(args.GetA() / args.GetB())
	reply.Rem = proto.Int32(args.GetA() % args.GetB())
	return nil
}

func main() {
	arith.ListenAndServeArithService("tcp", ":1984", new(Arith))
}

At this point, clients can see a service "Arith" with methods "ArithService.Multiply" and "ArithService.Divide". To invoke one, a client first dials the server:

stub, err := arith.DialArithService("tcp", "127.0.0.1:1984")
if err != nil {
	log.Fatal(`arith.DialArithService("tcp", "127.0.0.1:1984"):`, err)
}
defer stub.Close()

Then it can make a remote call with stub:

var args ArithRequest

args.A = proto.Int32(7)
args.B = proto.Int32(8)
reply, err := stub.Multiply(&args, &reply)
if err != nil {
	log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d", args.GetA(), args.GetB(), reply.GetVal())

More example:

go test github.com/xujiajun/protorpc/internal/service.pb

Report bugs to <chaishushan@gmail.com>.

Thanks!

Index

• func Dial(network, address string) (*rpc.Client, error)
• func DialTimeout(network, address string, timeout time.Duration) (*rpc.Client, error)
• func NewClient(conn io.ReadWriteCloser) *rpc.Client
• func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec
• func NewServerCodec(conn io.ReadWriteCloser) rpc.ServerCodec
• func ServeConn(conn io.ReadWriteCloser)

Functions

func Dial

func Dial(network, address string) (*rpc.Client, error)

Dial connects to a Protobuf-RPC server at the specified network address.

func DialTimeout

func DialTimeout(network, address string, timeout time.Duration) (*rpc.Client, error)

DialTimeout connects to a Protobuf-RPC server at the specified network address.

func NewClient

func NewClient(conn io.ReadWriteCloser) *rpc.Client

NewClient returns a new rpc.Client to handle requests to the set of services at the other end of the connection.

func NewClientCodec

func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec

NewClientCodec returns a new rpc.ClientCodec using Protobuf-RPC on conn.

func NewServerCodec

func NewServerCodec(conn io.ReadWriteCloser) rpc.ServerCodec

NewServerCodec returns a serverCodec that communicates with the ClientCodec on the other end of the given conn.

func ServeConn

func ServeConn(conn io.ReadWriteCloser)

ServeConn runs the Protobuf-RPC server on a single connection. ServeConn blocks, serving the connection until the client hangs up. The caller typically invokes ServeConn in a go statement.