tinyrpc

README

tinyrpc

      

tinyrpc is a high-performance RPC framework based on protocol buffer encoding. It is based on net/rpc and supports multiple compression formats (gzip, snappy, zlib).

Language  English | 中文

Install

• install protoc at first :http://github.com/google/protobuf/releases

• install protoc-gen-go and protoc-gen-tinyrpc:

go install github.com/golang/protobuf/protoc-gen-go
go install github.com/zehuamama/tinyrpc/protoc-gen-tinyrpc

Example

Fisrt, create a demo:

go mod init demo

create a protobuf file arith.proto:

syntax = "proto3";

package message;
option go_package="/message";

// ArithService Defining Computational Digital Services
service ArithService {
  // Add addition
  rpc Add(ArithRequest) returns (ArithResponse);
  // Sub subtraction
  rpc Sub(ArithRequest) returns (ArithResponse);
  // Mul multiplication
  rpc Mul(ArithRequest) returns (ArithResponse);
  // Div division
  rpc Div(ArithRequest) returns (ArithResponse);
}

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

message ArithResponse {
  int32 c = 1;
}

an arithmetic operation service is defined here, using protoc to generate code:

protoc --tinyrpc_out=. arith.proto --go_out=. arith.proto

at this time, two files will be generated in the directory message: arith.pb.go and arith.svr.go

the code of arith.svr.go is as follows:

// Code generated by protoc-gen-tinyrpc.

package message

// ArithService Defining Computational Digital Services
type ArithService struct{}

// Add addition
func (this *ArithService) Add(args *ArithRequest, reply *ArithResponse) error {
	// define your service ...
	return nil
}

// Sub subtraction
func (this *ArithService) Sub(args *ArithRequest, reply *ArithResponse) error {
	// define your service ...
	return nil
}

// Mul multiplication
func (this *ArithService) Mul(args *ArithRequest, reply *ArithResponse) error {
	// define your service ...
	return nil
}

// Div division
func (this *ArithService) Div(args *ArithRequest, reply *ArithResponse) error {
	// define your service ...
	return nil
}

We can define our services.

Server

Then create a tinyrpc server, the code is as follows:

package main

import (
	"demo/message"
	"log"
	"net"

	"github.com/zehuamama/tinyrpc"
)

func main() {
	lis, err := net.Listen("tcp", ":8082")
	if err != nil {
		log.Fatal(err)
	}

	server := tinyrpc.NewServer()
	server.RegisterName("ArithService", new(message.ArithService))
	server.Serve(lis)
}

Client

We can create a tinyrpc client and call it synchronously with the Add function:

conn, err := net.Dial("tcp", ":8082")
if err != nil {
	log.Fatal(err)
}
defer conn.Close()
client := tinyrpc.NewClient(conn)
resq := message.ArithRequest{A: 20, B: 5}
resp := message.ArithResponse{}
err = client.Call("ArithService.Add", &resq, &resp)

you can also call asynchronously, which will return *rpc.Call:

result := client.AsyncCall("ArithService.Add", &resq, &resp)
select {
case call := <-result:
	log.Printf("Arith.Add(%v, %v): %v ,Error: %v", resq.A, resq.B, resp.C, call.Error)
case <-time.After(100 * time.Microsecond):
	log.Fatal("time out")
}

of course, you can also compress the encoding, tinyrpc currently supports gzip, snappy, zlib:

import "github.com/zehuamama/tinyrpc/compressor"

// ...
client := tinyrpc.NewClient(conn, tinyrpc.WithCompress(compressor.Gzip))
resq := message.ArithRequest{A: 4, B: 15}
resp := message.ArithResponse{}
err = client.Call("ArithService.Mul", &resq, &resp)

Documentation

Index

• type Client
  • func NewClient(conn io.ReadWriteCloser, opts ...Option) *Client
  • func (c *Client) AsyncCall(serviceMethod string, args any, reply any) chan *rpc.Call
  • func (c *Client) Call(serviceMethod string, args any, reply any) error
• type Option
  • func WithCompress(c compressor.CompressType) Option
• type Server
  • func NewServer() *Server
  • func (s *Server) Register(rcvr ...any) error
  • func (s *Server) RegisterName(name string, rcvr any) error
  • func (s *Server) Serve(lis net.Listener)

Types

type Client

type Client struct {
	*rpc.Client
}

Client tinyrpc client based on net/rpc implementation

func NewClient

func NewClient(conn io.ReadWriteCloser, opts ...Option) *Client

NewClient Create a new tinyrpc client

func (*Client) AsyncCall

func (c *Client) AsyncCall(serviceMethod string, args any, reply any) chan *rpc.Call

AsyncCall asynchronously calls the tinyrpc function and returns a channel of *rpc.Call

func (*Client) Call

func (c *Client) Call(serviceMethod string, args any, reply any) error

Call synchronously calls the tinyrpc function

type Option

type Option interface {
	// contains filtered or unexported methods
}

Option provides options for tinyrpc client

func WithCompress

func WithCompress(c compressor.CompressType) Option

WithCompress set client compression format

type Server

type Server struct {
	*rpc.Server
}

Server tinyrpc server based on net/rpc implementation

func NewServer

func NewServer() *Server

NewServer Create a new tinyrpc server

func (*Server) Register

func (s *Server) Register(rcvr ...any) error

Register register rpc function

func (*Server) RegisterName

func (s *Server) RegisterName(name string, rcvr any) error

RegisterName register the rpc function with the specified name

func (*Server) Serve

func (s *Server) Serve(lis net.Listener)

Serve start service