drpc

package module
v0.0.0-...-80f3703 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 1, 2023 License: MIT Imports: 10 Imported by: 0

README

drpc

本仓库是drpc的go语言的实现。drpc需与 dgen 配合使用。

使用方法

首先,新建一个idl文件,然后根据IDL语法定义服务。

这里定义一个简单的服务:

message HelloRequest {
    seq=1 string name;
}

message HelloReply {
    optional seq=1 string reply;
}

service HelloWorld {
    SayHello(HelloRequest) return (HelloReply);
}

使用dgen工具,如dgen -f helloworld.idl -l go, 可以生成一个helloworld目录。目录下的hellowrold.go中定义了 HelloRequestHelloReply 和它们的序列化、反序列化方法,hellowrold.dprc.go中定义了包括服务注册在内的一些桩代码。用户只需要编写少量的服务端代码,客户端就可以实现调用。

server

type helloService struct {
}

func (h *helloService) SayHello(args *dgen.HelloRequest, reply *dgen.HelloReply) error {
	reply.Reply = fmt.Sprintf("Hello %s, welcome to drpc", args.Name)
	return nil
}

func main() {
	server := drpc.NewServer()
	dgen.RegisterHelloWorldService(server, "Hello", new(helloService)) // 此函数由编译器生成

	listener, err := net.Listen("tcp", ":8888")
	if err != nil {
		fmt.Println("err:", err)
	}
	server.Serve(listener)
}

client:

func main() {
	client, err := drpc.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("err:", err)
	}

	args := &dgen.HelloRequest{
		Name: "fengluodb",
	}
	reply := &dgen.HelloReply{}

	if err := client.Call("Hello.SayHello", args, reply); err != nil {
		fmt.Println("err:", err)
	}
	fmt.Println("reply:", reply.Reply)
}

在本仓库的 hellowrold 目录下有该示例,其中defalutjson代表不同的序列化方式。

传输协议

请求头:

// RequestHeader request header structure looks like:
// +----------+----------------+----------+
// |    ID    |      Method    |  Checksum|
// +----------+----------------+----------+
// |  uvarint | uvarint+string |   uint32 |
// +----------+----------------+----------+
type RequestHeader struct {
	ID       uint64
	Method   string
	Checksum uint32
}

ID为每个请求的唯一标识,Method为调用的方法名,Checksum用于检查request body传输过程中是否发生错误。

响应头

// ResponseHeader request header structure looks like:
// +---------+----------------+----------+
// |    ID   |      Error     |  Checksum|
// +---------+----------------+----------+
// | uvarint | uvarint+string |   uint32 |
// +---------+----------------+----------+
type ResponseHeader struct {
	ID       uint64
	Error    string
	Checksum uint32
}

ID为每个请求的唯一标识,Error代表函数调用时是否发生错误(如果Error为空,代表没有错误),Checksum用于检查response body传输过程中是否发生错误。

Documentation

Index

Constants

View Source
const (
	// MaxHeaderSize = 10 + 10 + 4 (10 refer to binary.MaxVarintLen64)
	MaxHeaderSize = 24

	Uint16Size = 2
	Uint32Size = 4
)

Variables

View Source
var (
	ErrUnmarshal = errors.New("an error occurred in Unmarshal")
	ErrShutdown  = errors.New("connection is shut down")
)

Functions

func NewService

func NewService() *service

func RegisterService

func RegisterService(s *Server, serviceMethodName string, method Handler) error

Types

type Call

type Call struct {
	ServiceMethod string
	Args          Serializer
	Reply         Serializer
	Error         error
	Done          chan *Call
}

func NewCall

func NewCall(serviceMethod string, args Serializer, reply Serializer) *Call

type Client

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

func Dial

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

func NewClient

func NewClient(conn io.ReadWriteCloser) *Client

func (*Client) Call

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

func (*Client) Close

func (c *Client) Close() error

func (*Client) Go

func (c *Client) Go(serviceMethod string, args, reply Serializer) *Call

type ClientCodec

type ClientCodec interface {
	WriteRequest(*RequestHeader, []byte) error
	ReadResponseHeader(*ResponseHeader) error
	ReadResponseBody() ([]byte, error)
	Close() error
}

func NewClientCodec

func NewClientCodec(conn io.ReadWriteCloser) ClientCodec

type Handler

type Handler func(args []byte) ([]byte, error)

type RequestHeader

type RequestHeader struct {
	ID       uint64
	Method   string
	Checksum uint32
}

RequestHeader request header structure looks like: +----------+----------------+----------+ | ID | Method | Checksum| +----------+----------------+----------+ | uvarint | uvarint+string | uint32 | +----------+----------------+----------+

func (*RequestHeader) Marshal

func (r *RequestHeader) Marshal() []byte

func (*RequestHeader) Unmarshal

func (r *RequestHeader) Unmarshal(data []byte) error

type ResponseHeader

type ResponseHeader struct {
	ID       uint64
	Error    string
	Checksum uint32
}

ResponseHeader request header structure looks like: +---------+----------------+----------+ | ID | Error | Checksum| +---------+----------------+----------+ | uvarint | uvarint+string | uint32 | +---------+----------------+----------+

func (*ResponseHeader) Marshal

func (r *ResponseHeader) Marshal() []byte

func (*ResponseHeader) Unmarshal

func (r *ResponseHeader) Unmarshal(data []byte) error

type Serializer

type Serializer interface {
	Marshal() ([]byte, error)
	Unmarshal([]byte) error
}

type Server

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

func NewServer

func NewServer() *Server

func (*Server) Serve

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

func (*Server) ServeCodec

func (s *Server) ServeCodec(codec ServerCodec)

func (*Server) ServeConn

func (s *Server) ServeConn(conn net.Conn)

type ServerCodec

type ServerCodec interface {
	ReadRequestHeader(*RequestHeader) error
	ReadRequestBody() ([]byte, error)
	WriteResponse(*ResponseHeader, []byte) error
	Close() error
}

func NewServerCodec

func NewServerCodec(conn io.ReadWriteCloser) ServerCodec

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL