A drop-in, lightweight gRPC replacement.

Links

• DRPC website
• Examples
• Quickstart documentation
• Launch blog post

Highlights

• Simple, at just a few thousandlines of code.
• Small dependencies. Only 3 requirements in go.mod, and 9 lines ofgo mod graph!
• Compatible. Works for many gRPC use-cases as-is!
• Fast. DRPC has a lightning quickwire format.
• Extensible. DRPC is transport agnostic, supports middleware, and is designed around interfaces.
• Battle Tested. Already used in production for years across tens of thousands of servers.

External Packages

• go.bryk.io/pkg/net/drpc

  • Simplified TLS setup (for client and server)
  • Server middleware, including basic components for logging, token-based auth, rate limit, panic recovery, etc
  • Client middleware, including basic components for logging, custom metadata, panic recovery, etc
  • Bi-directional streaming support over upgraded HTTP(S) connections using WebSockets
  • Concurrent RPCs via connection pool

• go.elara.ws/drpc

  • Concurrent RPCs based onyamux
  • Simple drop-in replacements fordrpcserver anddrpcconn

• Open an issue or join theZulip chat if you'd like to be featured here.

Examples

• A basic drpc client and server
• A basic drpc client and server that also serves a Twirp/grpc-web compatible http server on the same port
• Serving gRPC and DRPC on the same port

Other Languages

DRPC can be made compatible with RPC clients generated from other languages. For example,Twirp clients andgrpc-web clients can be used against thedrpchttp package.

Native implementations can have some advantages, and so some support for other languages are in progress, all in various states of completeness. Join theZulip chat if you want more information or to help out with any!

Licensing

DRPC is licensed under the MIT/expat license. See the LICENSE file for more.

Benchmarks

These microbenchmarks attempt to provide a comparison and come with some caveats. First, it does not send data over a network connection which is expected to be the bottleneck almost all of the time. Second, no attempt was made to do the benchmarks in a controlled environment (CPU scaling disabled, noiseless, etc.). Third, no tuning was done to ensure they're both performing optimally, so there is an inherent advantage for DRPC because the author is familiar with how it works.

Lines of code

DRPC is proud to get as much done in as few lines of code as possible. It's the author's belief that this is only possible by having a clean, strong architecture and that it reduces the chances for bugs to exist (most studies show a linear corellation with number of bugs and lines of code). This table helps keep the library honest, and it would be nice if more libraries considered this.

Constants¶

Variables¶

var (Error         =errs.Class("drpc")InternalError =errs.Class("internal error")ProtocolError =errs.Class("protocol error")ClosedError   =errs.Class("closed"))

Functions¶

Types¶

type Conn interface {// Close closes the connection.Close()error// Closed returns a channel that is closed if the connection is definitely closed.Closed() <-chan struct{}// Invoke issues a unary RPC to the remote. Only one Invoke or Stream may be// open at once.Invoke(ctxcontext.Context, rpcstring, encEncoding, in, outMessage)error// NewStream starts a stream with the remote. Only one Invoke or Stream may be// open at once.NewStream(ctxcontext.Context, rpcstring, encEncoding) (Stream,error)}

type Description interface {// NumMethods returns the number of methods available.NumMethods()int// Method returns the information about the nth method along with a handler// to invoke it. The method interface that it returns is expected to be// a method expression like `(*Type).HandlerName`.Method(nint) (rpcstring, encodingEncoding, receiverReceiver, method interface{}, okbool)}

type Encoding interface {// Marshal returns the encoded form of msg.Marshal(msgMessage) ([]byte,error)// Unmarshal reads the encoded form of some Message into msg.// The buf is expected to contain only a single complete Message.Unmarshal(buf []byte, msgMessage)error}

type Handler interface {// HandleRPC executes the RPC identified by the rpc string using the stream to// communicate with the remote.HandleRPC(streamStream, rpcstring) (errerror)}

type Message interface{}

type Mux interface {// Register marks that the description should dispatch RPCs that it describes to// the provided srv.Register(srv interface{}, descDescription)error}

type Receiver = func(srv interface{}, ctxcontext.Context, in1, in2 interface{}) (outMessage, errerror)

type Stream interface {// Context returns the context associated with the stream. It is canceled// when the Stream is closed and no more messages will ever be sent or// received on it.Context()context.Context// MsgSend sends the Message to the remote.MsgSend(msgMessage, encEncoding)error// MsgRecv receives a Message from the remote.MsgRecv(msgMessage, encEncoding)error// CloseSend signals to the remote that we will no longer send any messages.CloseSend()error// Close closes the stream.Close()error}

type Transport interface {io.Readerio.Writerio.Closer}