// This is an example for serving HTTP, HTTPS, and GoRPC/TLS on the same port. func Example_recursiveCmux() { // Create the TCP listener. l, err := net.Listen("tcp", "127.0.0.1:50051") if err != nil { log.Fatal(err) } // Create a mux. tcpm := cmux.New(l) // We first match on HTTP 1.1 methods. httpl := tcpm.Match(cmux.HTTP1Fast()) // If not matched, we assume that its TLS. tlsl := tcpm.Match(cmux.Any()) tlsl = tlsListener(tlsl) // Now, we build another mux recursively to match HTTPS and GoRPC. // You can use the same trick for SSH. tlsm := cmux.New(tlsl) httpsl := tlsm.Match(cmux.HTTP1Fast()) gorpcl := tlsm.Match(cmux.Any()) go recursiveServeHTTP(httpl) go recursiveServeHTTP(httpsl) go recursiveServeRPC(gorpcl) go tlsm.Serve() tcpm.Serve() }
func Example() { l, err := net.Listen("tcp", "127.0.0.1:50051") if err != nil { log.Fatal(err) } m := cmux.New(l) // We first match the connection against HTTP2 fields. If matched, the // connection will be sent through the "grpcl" listener. grpcl := m.Match(cmux.HTTP2HeaderField("content-type", "application/grpc")) //Otherwise, we match it againts a websocket upgrade request. wsl := m.Match(cmux.HTTP1HeaderField("Upgrade", "websocket")) // Otherwise, we match it againts HTTP1 methods. If matched, // it is sent through the "httpl" listener. httpl := m.Match(cmux.HTTP1Fast()) // If not matched by HTTP, we assume it is an RPC connection. rpcl := m.Match(cmux.Any()) // Then we used the muxed listeners. go serveGRPC(grpcl) go serveWS(wsl) go serveHTTP(httpl) go serveRPC(rpcl) m.Serve() }
func (h *hive) listen() (err error) { h.listener, err = net.Listen("tcp", h.config.Addr) if err != nil { glog.Errorf("%v cannot listen: %v", h, err) return err } glog.Infof("%v is listening", h) m := cmux.New(h.listener) hl := m.Match(cmux.HTTP1Fast()) rl := m.Match(cmux.Any()) go func() { h.httpServer.Serve(hl) glog.Infof("%v closed http listener", h) }() rs := rpc.NewServer() if err := rs.RegisterName("rpcServer", newRPCServer(h)); err != nil { glog.Fatalf("cannot register rpc server: %v", err) } go func() { for { conn, err := rl.Accept() if err != nil { glog.Infof("%v closed rpc listener", h) return } go rs.ServeConn(conn) } }() go m.Serve() return nil }
// This is an example for serving HTTP and HTTPS on the same port. func Example_bothHTTPAndHTTPS() { // Create the TCP listener. l, err := net.Listen("tcp", "127.0.0.1:50051") if err != nil { log.Fatal(err) } // Create a mux. m := cmux.New(l) // We first match on HTTP 1.1 methods. httpl := m.Match(cmux.HTTP1Fast()) // If not matched, we assume that its TLS. // // Note that you can take this listener, do TLS handshake and // create another mux to multiplex the connections over TLS. tlsl := m.Match(cmux.Any()) go serveHTTP1(httpl) go serveHTTPS(tlsl) m.Serve() }