go-gprc简单例子

妖狐艹你老母 2022-06-05 11:12 178阅读 0赞

[protocol-buffers][]

由于墙的原因，我们一些依赖的包文件可以通过下面方式下载到：
    
    在 github 可以找到源码，下载后复制到对应目录即可的：
    
    google.golang.org/grpc   对应的代码地址在： https://github.com/grpc/grpc-go 
    
    google.golang.org/cloud/compute/metadata   对应的代码地址在：  https://github.com/GoogleCloudPlatform/gcloud-golang 
    
    golang.org/x/oauth2   对应的代码地址在：  https://github.com/golang/oauth2
    
    golang.org/x/net/context 对应的代码地址在： https://github.com/golang/net

server.go

//go:generate protoc -I ../routeguide --go_out=plugins=grpc:../routeguide ../routeguide/route_guide.proto
    
    // Package main implements a simple gRPC server that demonstrates how to use gRPC-Go libraries
    // to perform unary, client streaming, server streaming and full duplex RPCs.
    //
    // It implements the route guide service whose definition can be found in routeguide/route_guide.proto.
    package main
    
    import (
        "encoding/json"
        "flag"
        "fmt"
        "io"
        "io/ioutil"
        "log"
        "math"
        "net"
        "time"
    
        "golang.org/x/net/context"
        "google.golang.org/grpc"
    
        "google.golang.org/grpc/credentials"
        "google.golang.org/grpc/testdata"
    
        "github.com/golang/protobuf/proto"
    
        pb "google.golang.org/grpc/examples/route_guide/routeguide"
    )
    
    var (
        tls        = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
        certFile   = flag.String("cert_file", "", "The TLS cert file")
        keyFile    = flag.String("key_file", "", "The TLS key file")
        jsonDBFile = flag.String("json_db_file", "testdata/route_guide_db.json", "A json file containing a list of features")
        port       = flag.Int("port", 10000, "The server port")
    )
    
    type routeGuideServer struct {
        savedFeatures []*pb.Feature
        routeNotes    map[string][]*pb.RouteNote
    }
    
    // GetFeature returns the feature at the given point.
    func (s *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {
        for _, feature := range s.savedFeatures {
            if proto.Equal(feature.Location, point) {
                return feature, nil
            }
        }
        // No feature was found, return an unnamed feature
        return &pb.Feature{Location: point}, nil
    }
    
    // ListFeatures lists all features contained within the given bounding Rectangle.
    func (s *routeGuideServer) ListFeatures(rect *pb.Rectangle, stream pb.RouteGuide_ListFeaturesServer) error {
        for _, feature := range s.savedFeatures {
            if inRange(feature.Location, rect) {
                if err := stream.Send(feature); err != nil {
                    return err
                }
            }
        }
        return nil
    }
    
    // RecordRoute records a route composited of a sequence of points.
    //
    // It gets a stream of points, and responds with statistics about the "trip":
    // number of points, number of known features visited, total distance traveled, and
    // total time spent.
    func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {
        var pointCount, featureCount, distance int32
        var lastPoint *pb.Point
        startTime := time.Now()
        for {
            point, err := stream.Recv()
            if err == io.EOF {
                endTime := time.Now()
                return stream.SendAndClose(&pb.RouteSummary{
                    PointCount:   pointCount,
                    FeatureCount: featureCount,
                    Distance:     distance,
                    ElapsedTime:  int32(endTime.Sub(startTime).Seconds()),
                })
            }
            if err != nil {
                return err
            }
            pointCount++
            for _, feature := range s.savedFeatures {
                if proto.Equal(feature.Location, point) {
                    featureCount++
                }
            }
            if lastPoint != nil {
                distance += calcDistance(lastPoint, point)
            }
            lastPoint = point
        }
    }
    
    // RouteChat receives a stream of message/location pairs, and responds with a stream of all
    // previous messages at each of those locations.
    func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
        for {
            in, err := stream.Recv()
            if err == io.EOF {
                return nil
            }
            if err != nil {
                return err
            }
            key := serialize(in.Location)
            if _, present := s.routeNotes[key]; !present {
                s.routeNotes[key] = []*pb.RouteNote{in}
            } else {
                s.routeNotes[key] = append(s.routeNotes[key], in)
            }
            for _, note := range s.routeNotes[key] {
                if err := stream.Send(note); err != nil {
                    return err
                }
            }
        }
    }
    
    // loadFeatures loads features from a JSON file.
    func (s *routeGuideServer) loadFeatures(filePath string) {
        file, err := ioutil.ReadFile(filePath)
        if err != nil {
            log.Fatalf("Failed to load default features: %v", err)
        }
        if err := json.Unmarshal(file, &s.savedFeatures); err != nil {
            log.Fatalf("Failed to load default features: %v", err)
        }
    }
    
    func toRadians(num float64) float64 {
        return num * math.Pi / float64(180)
    }
    
    // calcDistance calculates the distance between two points using the "haversine" formula.
    // This code was taken from http://www.movable-type.co.uk/scripts/latlong.html.
    func calcDistance(p1 *pb.Point, p2 *pb.Point) int32 {
        const CordFactor float64 = 1e7
        const R float64 = float64(6371000) // metres
        lat1 := float64(p1.Latitude) / CordFactor
        lat2 := float64(p2.Latitude) / CordFactor
        lng1 := float64(p1.Longitude) / CordFactor
        lng2 := float64(p2.Longitude) / CordFactor
        φ1 := toRadians(lat1)
        φ2 := toRadians(lat2)
        Δφ := toRadians(lat2 - lat1)
        Δλ := toRadians(lng2 - lng1)
    
        a := math.Sin(Δφ/2)*math.Sin(Δφ/2) +
            math.Cos(φ1)*math.Cos(φ2)*
                math.Sin(Δλ/2)*math.Sin(Δλ/2)
        c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
    
        distance := R * c
        return int32(distance)
    }
    
    func inRange(point *pb.Point, rect *pb.Rectangle) bool {
        left := math.Min(float64(rect.Lo.Longitude), float64(rect.Hi.Longitude))
        right := math.Max(float64(rect.Lo.Longitude), float64(rect.Hi.Longitude))
        top := math.Max(float64(rect.Lo.Latitude), float64(rect.Hi.Latitude))
        bottom := math.Min(float64(rect.Lo.Latitude), float64(rect.Hi.Latitude))
    
        if float64(point.Longitude) >= left &&
            float64(point.Longitude) <= right &&
            float64(point.Latitude) >= bottom &&
            float64(point.Latitude) <= top {
            return true
        }
        return false
    }
    
    func serialize(point *pb.Point) string {
        return fmt.Sprintf("%d %d", point.Latitude, point.Longitude)
    }
    
    func newServer() *routeGuideServer {
        s := new(routeGuideServer)
        s.loadFeatures(*jsonDBFile)
        s.routeNotes = make(map[string][]*pb.RouteNote)
        return s
    }
    
    func main() {
        flag.Parse()
        lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", *port))
        if err != nil {
            log.Fatalf("failed to listen: %v", err)
        }
        var opts []grpc.ServerOption
        if *tls {
            if *certFile == "" {
                *certFile = testdata.Path("server1.pem")
            }
            if *keyFile == "" {
                *keyFile = testdata.Path("server1.key")
            }
            creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
            if err != nil {
                log.Fatalf("Failed to generate credentials %v", err)
            }
            opts = []grpc.ServerOption{grpc.Creds(creds)}
        }
        grpcServer := grpc.NewServer(opts...)
        pb.RegisterRouteGuideServer(grpcServer, newServer())
        grpcServer.Serve(lis)
    }

client.go

// Package main implements a simple gRPC client that demonstrates how to use gRPC-Go libraries
    // to perform unary, client streaming, server streaming and full duplex RPCs.
    //
    // It interacts with the route guide service whose definition can be found in routeguide/route_guide.proto.
    package main
    
    import (
        "flag"
        "io"
        "log"
        "math/rand"
        "time"
    
        "golang.org/x/net/context"
        "google.golang.org/grpc"
        "google.golang.org/grpc/credentials"
        pb "google.golang.org/grpc/examples/route_guide/routeguide"
        "google.golang.org/grpc/testdata"
    )
    
    var (
        tls                = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
        caFile             = flag.String("ca_file", "", "The file containning the CA root cert file")
        serverAddr         = flag.String("server_addr", "127.0.0.1:10000", "The server address in the format of host:port")
        serverHostOverride = flag.String("server_host_override", "x.test.youtube.com", "The server name use to verify the hostname returned by TLS handshake")
    )
    
    // printFeature gets the feature for the given point.
    func printFeature(client pb.RouteGuideClient, point *pb.Point) {
        log.Printf("Getting feature for point (%d, %d)", point.Latitude, point.Longitude)
        feature, err := client.GetFeature(context.Background(), point)
        if err != nil {
            log.Fatalf("%v.GetFeatures(_) = _, %v: ", client, err)
        }
        log.Println(feature)
    }
    
    // printFeatures lists all the features within the given bounding Rectangle.
    func printFeatures(client pb.RouteGuideClient, rect *pb.Rectangle) {
        log.Printf("Looking for features within %v", rect)
        stream, err := client.ListFeatures(context.Background(), rect)
        if err != nil {
            log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
        }
        for {
            feature, err := stream.Recv()
            if err == io.EOF {
                break
            }
            if err != nil {
                log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
            }
            log.Println(feature)
        }
    }
    
    // runRecordRoute sends a sequence of points to server and expects to get a RouteSummary from server.
    func runRecordRoute(client pb.RouteGuideClient) {
        // Create a random number of random points
        r := rand.New(rand.NewSource(time.Now().UnixNano()))
        pointCount := int(r.Int31n(100)) + 2 // Traverse at least two points
        var points []*pb.Point
        for i := 0; i < pointCount; i++ {
            points = append(points, randomPoint(r))
        }
        log.Printf("Traversing %d points.", len(points))
        stream, err := client.RecordRoute(context.Background())
        if err != nil {
            log.Fatalf("%v.RecordRoute(_) = _, %v", client, err)
        }
        for _, point := range points {
            if err := stream.Send(point); err != nil {
                log.Fatalf("%v.Send(%v) = %v", stream, point, err)
            }
        }
        reply, err := stream.CloseAndRecv()
        if err != nil {
            log.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
        }
        log.Printf("Route summary: %v", reply)
    }
    
    // runRouteChat receives a sequence of route notes, while sending notes for various locations.
    func runRouteChat(client pb.RouteGuideClient) {
        notes := []*pb.RouteNote{
            {&pb.Point{Latitude: 0, Longitude: 1}, "First message"},
            {&pb.Point{Latitude: 0, Longitude: 2}, "Second message"},
            {&pb.Point{Latitude: 0, Longitude: 3}, "Third message"},
            {&pb.Point{Latitude: 0, Longitude: 1}, "Fourth message"},
            {&pb.Point{Latitude: 0, Longitude: 2}, "Fifth message"},
            {&pb.Point{Latitude: 0, Longitude: 3}, "Sixth message"},
        }
        stream, err := client.RouteChat(context.Background())
        if err != nil {
            log.Fatalf("%v.RouteChat(_) = _, %v", client, err)
        }
        waitc := make(chan struct{})
        go func() {
            for {
                in, err := stream.Recv()
                if err == io.EOF {
                    // read done.
                    close(waitc)
                    return
                }
                if err != nil {
                    log.Fatalf("Failed to receive a note : %v", err)
                }
                log.Printf("Got message %s at point(%d, %d)", in.Message, in.Location.Latitude, in.Location.Longitude)
            }
        }()
        for _, note := range notes {
            if err := stream.Send(note); err != nil {
                log.Fatalf("Failed to send a note: %v", err)
            }
        }
        stream.CloseSend()
        <-waitc
    }
    
    func randomPoint(r *rand.Rand) *pb.Point {
        lat := (r.Int31n(180) - 90) * 1e7
        long := (r.Int31n(360) - 180) * 1e7
        return &pb.Point{Latitude: lat, Longitude: long}
    }
    
    func main() {
        flag.Parse()
        var opts []grpc.DialOption
        if *tls {
            if *caFile == "" {
                *caFile = testdata.Path("ca.pem")
            }
            creds, err := credentials.NewClientTLSFromFile(*caFile, *serverHostOverride)
            if err != nil {
                log.Fatalf("Failed to create TLS credentials %v", err)
            }
            opts = append(opts, grpc.WithTransportCredentials(creds))
        } else {
            opts = append(opts, grpc.WithInsecure())
        }
        conn, err := grpc.Dial(*serverAddr, opts...)
        if err != nil {
            log.Fatalf("fail to dial: %v", err)
        }
        defer conn.Close()
        client := pb.NewRouteGuideClient(conn)
    
        // Looking for a valid feature
        printFeature(client, &pb.Point{Latitude: 409146138, Longitude: -746188906})
    
        // Feature missing.
        printFeature(client, &pb.Point{Latitude: 0, Longitude: 0})
    
        // Looking for features between 40, -75 and 42, -73.
        printFeatures(client, &pb.Rectangle{
            Lo: &pb.Point{Latitude: 400000000, Longitude: -750000000},
            Hi: &pb.Point{Latitude: 420000000, Longitude: -730000000},
        })
    
        // RecordRoute
        runRecordRoute(client)
    
        // RouteChat
        runRouteChat(client)
    }

xxx.proto

syntax = "proto3";
    
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.routeguide";
    option java_outer_classname = "RouteGuideProto";
    
    package routeguide;
    
    // Interface exported by the server.
    service RouteGuide {
      // A simple RPC.
      //
      // Obtains the feature at a given position.
      //
      // A feature with an empty name is returned if there's no feature at the given
      // position.
      rpc GetFeature(Point) returns (Feature) {}
    
      // A server-to-client streaming RPC.
      //
      // Obtains the Features available within the given Rectangle. Results are
      // streamed rather than returned at once (e.g. in a response message with a
      // repeated field), as the rectangle may cover a large area and contain a
      // huge number of features.
      rpc ListFeatures(Rectangle) returns (stream Feature) {}
    
      // A client-to-server streaming RPC.
      //
      // Accepts a stream of Points on a route being traversed, returning a
      // RouteSummary when traversal is completed.
      rpc RecordRoute(stream Point) returns (RouteSummary) {}
    
      // A Bidirectional streaming RPC.
      //
      // Accepts a stream of RouteNotes sent while a route is being traversed,
      // while receiving other RouteNotes (e.g. from other users).
      rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
    }
    
    // Points are represented as latitude-longitude pairs in the E7 representation
    // (degrees multiplied by 10**7 and rounded to the nearest integer).
    // Latitudes should be in the range +/- 90 degrees and longitude should be in
    // the range +/- 180 degrees (inclusive).
    message Point {
      int32 latitude = 1;
      int32 longitude = 2;
    }
    
    // A latitude-longitude rectangle, represented as two diagonally opposite
    // points "lo" and "hi".
    message Rectangle {
      // One corner of the rectangle.
      Point lo = 1;
    
      // The other corner of the rectangle.
      Point hi = 2;
    }
    
    // A feature names something at a given point.
    //
    // If a feature could not be named, the name is empty.
    message Feature {
      // The name of the feature.
      string name = 1;
    
      // The point where the feature is detected.
      Point location = 2;
    }
    
    // A RouteNote is a message sent while at a given point.
    message RouteNote {
      // The location from which the message is sent.
      Point location = 1;
    
      // The message to be sent.
      string message = 2;
    }
    
    // A RouteSummary is received in response to a RecordRoute rpc.
    //
    // It contains the number of individual points received, the number of
    // detected features, and the total distance covered as the cumulative sum of
    // the distance between each point.
    message RouteSummary {
      // The number of points received.
      int32 point_count = 1;
    
      // The number of known features passed while traversing the route.
      int32 feature_count = 2;
    
      // The distance covered in metres.
      int32 distance = 3;
    
      // The duration of the traversal in seconds.
      int32 elapsed_time = 4;
    }

参考:  
[http://doc.oschina.net/grpc?t=60133][http_doc.oschina.net_grpc_t_60133]

[protocol-buffers]: https://developers.google.com/protocol-buffers/docs/gotutorial
[http_doc.oschina.net_grpc_t_60133]: http://doc.oschina.net/grpc?t=60133