mirror of https://github.com/soheilhy/cmux.git synced 2024-11-10 11:41:52 +08:00

golang多路复用器

Go to file

Tamir Duberstein 36dc9894b6 Replace buffer with bufferedReader bufferedReader is an optimized implementation of io.Reader that behaves like ``` io.MultiReader(bytes.NewReader(buffer.Bytes()), io.TeeReader(source, buffer)) ``` without allocating. This has a measurable effect on benchmarks: ``` name old time/op new time/op delta CMuxConn-4 1.09µs ± 4% 0.99µs ±19% -9.32% (p=0.000 n=17+19) name old alloc/op new alloc/op delta CMuxConn-4 240B ± 0% 260B ± 0% +8.33% (p=0.000 n=20+20) name old allocs/op new allocs/op delta CMuxConn-4 9.00 ± 0% 5.00 ± 0% -44.44% (p=0.000 n=20+20) ``` Note that appropriate test coverage is provided by `TestRead`.		2016-02-26 06:00:06 -05:00
.gitignore	Initial commit	2015-07-29 13:49:26 -04:00
.travis.yml	`go tool vet --shadow .`	2016-02-25 11:47:10 -05:00
bench_test.go	Tweak shutdown behaviour	2016-02-23 11:13:16 -05:00
buffer.go	Replace buffer with bufferedReader	2016-02-26 06:00:06 -05:00
cmux_test.go	(*MuxConn).Read: fix erroneous io.EOF return	2016-02-25 21:59:10 -05:00
cmux.go	Replace buffer with bufferedReader	2016-02-26 06:00:06 -05:00
example_recursive_test.go	errcheck	2016-02-21 12:02:37 -05:00
example_test.go	errcheck	2016-02-21 12:02:37 -05:00
example_tls_test.go	errcheck	2016-02-21 12:02:37 -05:00
LICENSE	Add the license file	2015-08-01 10:36:36 -04:00
matchers.go	http2: use io.ReadFull	2016-02-23 11:25:36 -05:00
patricia_test.go	Initial commit	2015-07-29 13:49:26 -04:00
patricia.go	Simplify formatting in patricia.go	2016-02-21 10:41:14 -05:00
README.md	README: clarify why TLS is limited	2015-12-11 15:22:57 -05:00

README.md

cmux: Connection Mux

cmux is a generic Go library to multiplex connections based on their payload. Using cmux, you can serve gRPC, SSH, HTTPS, HTTP, Go RPC, and pretty much any other protocol on the same TCP listener.

How-To

Simply create your main listener, create a cmux for that listener, and then match connections:

// Create the main listener.
l, err := net.Listen("tcp", ":23456")
if err != nil {
	log.Fatal(err)
}

// Create a cmux.
m := cmux.New(l)

// Match connections in order:
// First grpc, then HTTP, and otherwise Go RPC/TCP.
grpcL := m.Match(cmux.HTTP2HeaderField("content-type", "application/grpc"))
httpL := m.Match(cmux.HTTP1Fast())
trpcL := m.Match(cmux.Any()) // Any means anything that is not yet matched.

// Create your protocol servers.
grpcS := grpc.NewServer()
grpchello.RegisterGreeterServer(grpcs, &server{})

httpS := &http.Server{
	Handler: &helloHTTP1Handler{},
}

trpcS := rpc.NewServer()
s.Register(&ExampleRPCRcvr{})

// Use the muxed listeners for your servers.
go grpcS.Serve(grpcL)
go httpS.Serve(httpL)
go trpcS.Accept(trpcL)

// Start serving!
m.Serve()

Take a look at other examples in the GoDoc.

Docs

GoDocs

Performance

There is room for improvment but, since we are only matching the very first bytes of a connection, the performance overheads on long-lived connections (i.e., RPCs and pipelined HTTP streams) is negligible.

TODO(soheil): Add benchmarks.

Limitations

TLS: net/http uses a type assertion to identify TLS connections; since cmux's lookahead-implementing connection wraps the underlying TLS connection, this type assertion fails. Because of that, you can serve HTTPS using cmux but http.Request.TLS would not be set in your handlers.
Different Protocols on The Same Connection: cmux matches the connection when it's accepted. For example, one connection can be either gRPC or REST, but not both. That is, we assume that a client connection is either used for gRPC or REST.