func serveGRPC(l net.Listener) { grpcs := grpc.NewServer() grpchello.RegisterGreeterServer(grpcs, &grpcServer{}) if err := grpcs.Serve(l); err != cmux.ErrListenerClosed { panic(err) } }
func main() { lis, err := net.Listen("tcp", port) if err != nil { log.Fatalf("failed to listen: %v", err) } s := grpc.NewServer() pb.RegisterGreeterServer(s, &server{}) s.Serve(lis) }
func TestGRPCClient(t *testing.T) { l, err := net.Listen("tcp", ":0") if err != nil { t.Fatalf("failed to listen: %v", err) } defer l.Close() s := grpc.NewServer() pb.RegisterGreeterServer(s, &greeterServer{}) go s.Serve(l) defer s.Stop() parts := strings.Split(l.Addr().String(), ":") port, _ := strconv.Atoi(parts[len(parts)-1]) addr := strings.Join(parts[:len(parts)-1], ":") r := mock.NewRegistry() r.Register(®istry.Service{ Name: "test", Version: "test", Nodes: []*registry.Node{ ®istry.Node{ Id: "test-1", Address: addr, Port: port, }, }, }) se := selector.NewSelector( selector.Registry(r), ) c := NewClient( client.Registry(r), client.Selector(se), ) req := c.NewRequest("test", "/helloworld.Greeter/SayHello", &pb.HelloRequest{ Name: "John", }) rsp := pb.HelloReply{} err = c.Call(context.TODO(), req, &rsp) if err != nil { t.Fatal(err) } if rsp.Message != "Hello John" { t.Fatalf("Got unexpected response %v", rsp.Message) } }
func servermain() { lis, err := net.Listen("tcp", address) if err != nil { log.Fatalf("failed to Listen: %v", err) } s := grpc.NewServer() pb.RegisterGreeterServer(s, &server{}) err = s.Serve(lis) if err != nil { log.Fatalf("failed to Serve: %v", err) } }
func main() { flag.Parse() lis, err := net.Listen("tcp", fmt.Sprintf(":%v", *port)) if err != nil { log.Exitf("failed to listen: %v", err) } http.Handle("/metrics", prometheus.Handler()) go http.ListenAndServe(fmt.Sprintf(":%v", *debugPort), nil) s := grpc.NewServer() pb.RegisterGreeterServer(s, &server{}) s.Serve(lis) }
func main() { lis, err := net.Listen("tcp", port) if err != nil { log.Fatalf("failed to listen: %v", err) } s := grpc.NewServer() pb.RegisterGreeterServer(s, &server{}) // Register reflection service on gRPC server. reflection.Register(s) if err := s.Serve(lis); err != nil { log.Fatalf("failed to serve: %v", err) } }
func startBackends(t *testing.T, sn string, lis ...net.Listener) (servers []*grpc.Server) { for _, l := range lis { creds := &serverNameCheckCreds{ sn: sn, } s := grpc.NewServer(grpc.Creds(creds)) hwpb.RegisterGreeterServer(s, &helloServer{}) servers = append(servers, s) go func(s *grpc.Server, l net.Listener) { s.Serve(l) }(s, l) } return }
func main() { // 原生的listener // 至于如何利用每个connection确实也不是listener的事情 lis, err := net.Listen("tcp", port) if err != nil { log.Fatalf("failed to listen: %v", err) } // 1. 启动一个Server, 关联: listener和handler s := grpc.NewServer() pb.RegisterGreeterServer(s, &server{}) // 2. 提供服务 s.Serve(lis) }
func main() { flag.Parse() ready := make(chan struct{}) go func() { <-ready var client helloworld.GreeterClient if *useGRPC { opts := []grpc.DialOption{ grpc.WithBlock(), grpc.WithTimeout(3 * time.Second), grpc.WithInsecure(), } conn, err := grpc.Dial(*addr, opts...) if err != nil { log.Fatalf("grpc.Dial: %v", err) } client = helloworld.NewGreeterClient(conn) } else { t := (http.DefaultTransport.(*http.Transport)) t.TLSClientConfig = &tls.Config{ InsecureSkipVerify: true, } if *useHTTP2 { if err := http2.ConfigureTransport(t); err != nil { log.Fatal(err) } } } ctx := context.Background() for i := 0; i < *numRuns; i++ { randomBytes := make([]byte, *msgSize) n, err := rand.Read(randomBytes) if err != nil { log.Fatal(err) } if n != *msgSize { log.Fatal("didn't read enough bytes") } msg := string(randomBytes) t1 := time.Now() var proto string if *useGRPC { _, err = client.SayHello(ctx, &helloworld.HelloRequest{Name: msg}) proto = "GRPC" } else { var resp *http.Response resp, err = http.Post("https://"+*addr, "text/plain", bytes.NewReader(randomBytes)) proto = "HTTP" if resp != nil { proto = resp.Proto resp.Body.Close() } } if *verbose { fmt.Println() } fmt.Printf("%v\t%v\t%v\n", time.Now().Sub(t1), *latency, proto) if err != nil { log.Fatal(err) } } os.Exit(0) }() var server *grpc.Server if *useGRPC { server = grpc.NewServer() helloworld.RegisterGreeterServer(server, greeter{}) } l, err := net.Listen("tcp", *addr) if err != nil { log.Fatal(err) } rate := Rate{Latency: *latency} l = &Listener{l, rate, rate} close(ready) if *useGRPC { log.Fatal(server.Serve(l)) } else { var config tls.Config var err error if *useHTTP2 { config.NextProtos = []string{"h2"} } config.Certificates = make([]tls.Certificate, 1) config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile) if err != nil { log.Fatal(err) } srv := &http.Server{Addr: *addr, TLSConfig: &config, Handler: http.HandlerFunc(validate)} tlsListener := tls.NewListener(l, &config) log.Fatal(srv.Serve(tlsListener)) } }
func serveGRPC(l net.Listener) { grpcs := grpc.NewServer() grpchello.RegisterGreeterServer(grpcs, &grpcServer{}) grpcs.Serve(l) }