Go 语言编程之旅 第三章 RPC 应用

syntax = "proto3";

package helloworld;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

在定义上更简单，更明了。
数据描述文件只需原来的 1/10 至 1/3。
解析速度是原来的 20 倍至 100 倍。
减少了二义性。
生成了更易使用的数据访问类。
序列化和反序列化速度快。
开发者本身在传输过程中并不需要过多的关注其内容。

Unary RPC：一元 RPC。
Server-side streaming RPC：服务端流式 RPC。
Client-side streaming RPC：客户端流式 RPC。
Bidirectional streaming RPC：双向流式 RPC。

$ wget https://github.com/google/protobuf/releases/download/v3.11.2/protobuf-all-3.11.2.zip
$ unzip protobuf-all-3.11.2.zip && cd protobuf-3.11.2/
$ ./configure
$ make
$ make install

$ protoc --version

protoc: error while loading shared libraries: libprotobuf.so.15: cannot open shared object file: No such file or directory

Libraries have been installed in:
   /usr/local/lib
...

$ go get -u github.com/golang/protobuf/protoc-gen-go@v1.3.2

$ GIT_TAG="v1.3.2"
$ go get -d -u github.com/golang/protobuf/protoc-gen-go
$ git -C "$(go env GOPATH)"/src/github.com/golang/protobuf checkout $GIT_TAG
$ go install github.com/golang/protobuf/protoc-gen-go

$ mv $GOPATH/bin/protoc-gen-go /usr/local/go/bin/

$ mkdir -p $HOME/go-programming-tour-book/grpc-demo
$ cd $HOME/go-programming-tour-book/grpc-demo
$ go mod init github.com/go-programming-tour-book/grpc-demo

grpc-demo
├── go.mod
├── client
├── proto
└── server

syntax = "proto3";

package helloworld;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
    string name = 1;
}
    
message HelloReply {
    string message = 1;
}

$ protoc --go_out=plugins=grpc:. ./proto/*.proto 

helloworld.pb.go 
helloworld.proto

type HelloRequest struct {
    Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    ...
}

func (m *HelloRequest) Reset()         { *m = HelloRequest{} }
func (m *HelloRequest) String() string { return proto.CompactTextString(m) }
func (*HelloRequest) ProtoMessage()    {}
func (*HelloRequest) Descriptor() ([]byte, []int) {
    return fileDescriptor_4d53fe9c48eadaad, []int{0}
}
func (m *HelloRequest) GetName() string {...}

func init() {
    proto.RegisterType((*HelloRequest)(nil), "helloworld.HelloRequest")
    proto.RegisterType((*HelloReply)(nil), "helloworld.HelloReply")
}

func init() { proto.RegisterFile("proto/helloworld.proto", fileDescriptor_4d53fe9c48eadaad) }

var fileDescriptor_4d53fe9c48eadaad = []byte{
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2b, 0x28, 0xca, 0x2f,
    ...
}

func (*HelloRequest) Descriptor() ([]byte, []int) {
    return fileDescriptor_4d53fe9c48eadaad, []int{0}
}

func (*HelloReply) Descriptor() ([]byte, []int) {
    return fileDescriptor_4d53fe9c48eadaad, []int{1}
}

type GreeterClient interface {
    SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
    cc *grpc.ClientConn
}

func NewGreeterClient(cc *grpc.ClientConn) GreeterClient {
    return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
    out := new(HelloReply)
    err := c.cc.Invoke(ctx, "/helloworld.Greeter/SayHello", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

message HelloRequest {
    bytes name = 1;
}

message HelloRequest {
    repeated string name = 1;
}

message HelloRequest {
    message World {
        string name = 1;
    }
    
    repeated World worlds = 1;
}

message World {
    string name = 1;
}

message HelloRequest {
    repeated World worlds = 1;
}

message HelloRequest {
    oneof name {
        string nick_name = 1;
        string true_name = 2;
    }
}

enum NameType {
    NickName = 0;
    TrueName = 1;
}

message HelloRequest {
    string name = 1;
    NameType nameType = 2;
}

message HelloRequest {
    map<string, string> names = 2;
}

$ go get -u google.golang.org/grpc@v1.29.1

import (
    ...
    // 设置引用别名
    pb "github.com/go-programming-tour-book/grpc-demo/proto"
)

var port string

func init() {
    flag.StringVar(&port, "p", "8000", "启动端口号")
    flag.Parse()
}

$ protoc --go_out=plugins=grpc:. ./proto/*.proto

syntax = "proto3";

package UnaryRPC;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply) {};
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

package main

import (
    "context"
    "flag"
    "net"
    pb "github.com/go-programming-tour-book/grpc-demo/proto"
    "google.golang.org/grpc"
)

var port string

func init() {
    flag.StringVar(&port, "p", "8000", "启动端口号")
    flag.Parse()
}

type GreeterServer struct{}

func (s *GreeterServer) SayHello(ctx context.Context, r *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "hello.world"}, nil
}

func main() {
    server := grpc.NewServer()
    pb.RegisterGreeterServer(server, &GreeterServer{})
    lis, _ := net.Listen("tcp", ":"+port)
    server.Serve(lis)
}

package main

import (
    "flag"
    "log"
    "context"
    pb "github.com/go-programming-tour-book/grpc-demo/proto"
    "google.golang.org/grpc"
)

var port string

func init() {
    flag.StringVar(&port, "p", "8000", "启动端口号")
    flag.Parse()
}

func main() {
    conn, _ := grpc.Dial(":"+port, grpc.WithInsecure())
    defer conn.Close()

    client := pb.NewGreeterClient(conn)
    _ = DoSayHello(client)  // DoSayHello方法无特定含义，可以为任意名称
}

func DoSayHello(client pb.GreeterClient) error {
    resp, _ := client.SayHello(context.Background(), &pb.HelloRequest{Name: "eddycjy"})
    log.Printf("client.SayHello resp: %s", resp.Message)
    return nil
}

service Greeter {
    rpc SayList (HelloRequest) returns (stream HelloReply) {};
}

type GreeterServer struct{}

func (s *GreeterServer) SayList(r *pb.HelloRequest, stream pb.Greeter_SayListServer) error {
    for n := 0; n <= 6; n++ {
        _ = stream.Send(&pb.HelloReply{Message: "hello.list"})
    }

    return nil
}

func main() {
    server := grpc.NewServer()
    pb.RegisterGreeterServer(server, &GreeterServer{})
    lis, _ := net.Listen("tcp", ":"+port)
    server.Serve(lis)
}

func main() {
    conn, _ := grpc.Dial(":"+port, grpc.WithInsecure())
    defer conn.Close()

    client := pb.NewGreeterClient(conn)
    r := pb.HelloRequest{Name: "abcdef"}
    _ = ToSayList(client, &r)
}

func ToSayList(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayList(context.Background(), r)
    for {
        resp, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }

        log.Printf("resp: %v", resp)
    }

    return nil
}

service Greeter {
    rpc SayRecord(stream HelloRequest) returns (HelloReply) {};
}

type GreeterServer struct{}

func (s *GreeterServer) SayRecord(stream pb.Greeter_SayRecordServer) error {
    for {
        resp, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.HelloReply{Message: "say.record"})
        }
        if err != nil {
            return err
        }

        log.Printf("resp: %v", resp)
    }

    return nil
}

func main() {
    server := grpc.NewServer()
    pb.RegisterGreeterServer(server, &GreeterServer{})
    lis, _ := net.Listen("tcp", ":"+port)
    server.Serve(lis)
}

func main() {
    conn, _ := grpc.Dial(":"+port, grpc.WithInsecure())
    defer conn.Close()

    client := pb.NewGreeterClient(conn)
    r := pb.HelloRequest{Name: "abcdef"}
    _ = DoSayRecord(client, &r)
}

func DoSayRecord(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayRecord(context.Background())
    for n := 0; n < 6; n++ {
        _ = stream.Send(r)
    }
    resp, _ := stream.CloseAndRecv()

    log.Printf("resp err: %v", resp)
    return nil
}

service Greeter {
    rpc SayRoute(stream HelloRequest) returns (stream HelloReply) {};
}

type GreeterServer struct{}

func (s *GreeterServer) SayRoute(stream pb.Greeter_SayRouteServer) error {
    n := 0
    for {
        _ = stream.Send(&pb.HelloReply{Message: "say.route"})

        resp, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }

        n++
        log.Printf("resp: %v", resp)
    }
}

func main() {
    server := grpc.NewServer()
    pb.RegisterGreeterServer(server, &GreeterServer{})
    lis, _ := net.Listen("tcp", ":"+port)
    server.Serve(lis)
}

func main() {
    conn, _ := grpc.Dial(":"+port, grpc.WithInsecure())
    defer conn.Close()

    client := pb.NewGreeterClient(conn)
    r := pb.HelloRequest{Name: "abcdef"}
    _ = DoSayRoute(client, &r)
}

func DoSayRoute(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayRoute(context.Background())
    for n := 0; n <= 6; n++ {
        _ = stream.Send(r)
        resp, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }

        log.Printf("resp err: %v", resp)
    }

    _ = stream.CloseSend()

    return nil
}

method：POST
scheme：http
path：/proto.SearchService/Search
authority：:10001
content-type：application/grpc
user-agent：grpc-go/1.20.0-dev

$ mkdir -p $HOME/go-programming-tour-book/tag-service
$ cd $HOME/go-programming-tour-book/tag-service
$ go mod init github.com/go-programming-tour-book/tag-service

tag-service
├── main.go
├── go.mod
├── go.sum
├── pkg
├── internal
├── proto
├── server
└── third_party

go get -u google.golang.org/grpc@v1.29.1

syntax = "proto3";

package proto;

message Pager {
    int64 page = 1;
    int64 page_size = 2;
    int64 total_rows = 3;
}

syntax = "proto3";

package proto;

import "proto/common.proto";

service TagService {
    rpc GetTagList (GetTagListRequest) returns (GetTagListReply) {}
}

message GetTagListRequest {
    string name = 1;
    uint32 state = 2;
}

message Tag {
    int64 id = 1;
    string name = 2;
    uint32 state = 3;
}

message GetTagListReply {
    repeated Tag list = 1;
    Pager pager = 2;
}

$ protoc --go_out=plugins=grpc:. ./proto/*.proto 

const (
    APP_KEY    = "eddycjy"
    APP_SECRET = "go-programming-tour-book"
)

type AccessToken struct {
    Token string `json:"token"`
}

func (a *API) getAccessToken(ctx context.Context) (string, error) {
    body, err := a.httpGet(ctx, fmt.Sprintf("%s?app_key=%s&app_secret=%s", "auth", APP_KEY, APP_SECRET))
    if err != nil {
        return "", err
    }

    var accessToken AccessToken
    _ = json.Unmarshal(body, &accessToken)
    return accessToken.Token, nil
}

func (a *API) httpGet(ctx context.Context, path string) ([]byte, error) {
    resp, err := http.Get(fmt.Sprintf("%s/%s", a.URL, path))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    return body, nil
}

type API struct {
    URL string
}

func NewAPI(url string) *API {
    return &API{URL: url}
}

func (a *API) GetTagList(ctx context.Context, name string) ([]byte, error) {
    token, err := a.getAccessToken(ctx)
    if err != nil {
        return nil, err
    }

    body, err := a.httpGet(ctx, fmt.Sprintf("%s?token=%s&name=%s", "api/v1/tags", token, name))
    if err != nil {
        return nil, err
    }

    return body, nil
}

import (
    pb "github.com/go-programming-tour-book/tag-service/proto"
    ...
)

type TagServer struct {}

func NewTagServer() *TagServer {
    return &TagServer{}
}

func (t *TagServer) GetTagList(ctx context.Context, r *pb.GetTagListRequest) (*pb.GetTagListReply, error) {
    api := bapi.NewAPI("http://127.0.0.1:8000")
    body, err := api.GetTagList(ctx, r.GetName())
    if err != nil {
        return nil, err
    }

    tagList := pb.GetTagListReply{}
    err = json.Unmarshal(body, &tagList)
    if err != nil {
        return nil, errcode.TogRPCError(errcode.Fail)
    }

    return &tagList, nil
}

func main() {
    s := grpc.NewServer()
    pb.RegisterTagServiceServer(s, server.NewTagServer())

    var port string = "8001"   // 不能与blog服务的端口一致，这是另外一个服务
    lis, err := net.Listen("tcp", ":"+port)
    if err != nil {
        log.Fatalf("net.Listen err: %v", err)
    }

    err = s.Serve(lis)
    if err != nil {
        log.Fatalf("server.Serve err: %v", err)
    }
}

$ go get github.com/fullstorydev/grpcurl
$ go install github.com/fullstorydev/grpcurl/cmd/grpcurl

import (
    "google.golang.org/grpc/reflection"
    ...
)

func main() {
    s := grpc.NewServer()
    pb.RegisterTagServiceServer(s, server.NewTagServer())
    reflection.Register(s)
    ...
}

$ grpcurl -plaintext localhost:8001 list
grpc.reflection.v1alpha.ServerReflection
proto.TagService

$ grpcurl -plaintext localhost:8001 list proto.TagService
proto.TagService.GetTagList

$ grpcurl -plaintext -d '{"name":"Go"}' localhost:8001 proto.TagService.GetTagList  
{
  "list": [
    {
      "id": "1",
      "name": "Go",
      "state": 1
    }
  ],
  "pager": {
    "page": "1",
    "pageSize": "10",
    "totalRows": "1"
  }
}

$ grpcurl -plaintext localhost:8001 proto.TagService.GetTagList 
ERROR:
  Code: Unknown
  Message: Get http://127.0.0.1:8000/api/v1/tags?name=: dial tcp 127.0.0.1:8000: connect: connection refused

Code     Status     Notes
0     OK     成功
1     CANCELLED     该操作被调用方取消
2     UNKNOWN     未知错误
3     INVALID_ARGUMENT     无效的参数
4     DEADLINE_EXCEEDED     在操作完成之前超过了约定的最后期限。
5     NOT_FOUND     找不到
6     ALREADY_EXISTS     已经存在
7     PERMISSION_DENIED     权限不足
8     RESOURCE_EXHAUSTED     资源耗尽
9     FAILED_PRECONDITION     该操作被拒绝，因为未处于执行该操作所需的状态
10     ABORTED     该操作被中止
11     OUT_OF_RANGE     超出范围，尝试执行的操作超出了约定的有效范围
12     UNIMPLEMENTED     未实现
13     INTERNAL     内部错误
14     UNAVAILABLE     该服务当前不可用。
15     DATA_LOSS     不可恢复的数据丢失或损坏。

func FromError(err error) (s *Status, ok bool) {
    ...
    if se, ok := err.(interface {
        GRPCStatus() *Status
    }); ok {
        return se.GRPCStatus(), true
    }
    return New(codes.Unknown, err.Error()), false
}

type Error struct {
    code int
    msg  string
}

var _codes = map[int]string{}

func NewError(code int, msg string) *Error {
    if _, ok := _codes[code]; ok {
        panic(fmt.Sprintf("错误码 %d 已经存在，请更换一个", code))
    }
    _codes[code] = msg
    return &Error{code: code, msg: msg}
}

func (e *Error) Error() string {
    return fmt.Sprintf("错误码：%d, 错误信息:：%s", e.Code(), e.Msg())
}

func (e *Error) Code() int {
    return e.code
}

func (e *Error) Msg() string {
    return e.msg
}

var (
    Success          = NewError(0, "成功")
    Fail             = NewError(10000000, "内部错误")
    InvalidParams    = NewError(10000001, "无效参数")
    Unauthorized     = NewError(10000002, "认证错误")
    NotFound         = NewError(10000003, "没有找到")
    Unknown          = NewError(10000004, "未知")
    DeadlineExceeded = NewError(10000005, "超出最后截止期限")
    AccessDenied     = NewError(10000006, "访问被拒绝")
    LimitExceed      = NewError(10000007, "访问限制")
    MethodNotAllowed = NewError(10000008, "不支持该方法")
)

func TogRPCError(err *Error) error {
    s := status.New(ToRPCCode(err.Code()), err.Msg())
    return s.Err()
}

func ToRPCCode(code int) codes.Code {
    var statusCode codes.Code
    switch code {
    case Fail.Code():
        statusCode = codes.Internal
    case InvalidParams.Code():
        statusCode = codes.InvalidArgument
    case Unauthorized.Code():
        statusCode = codes.Unauthenticated
    case AccessDenied.Code():
        statusCode = codes.PermissionDenied
    case DeadlineExceeded.Code():
        statusCode = codes.DeadlineExceeded
    case NotFound.Code():
        statusCode = codes.NotFound
    case LimitExceed.Code():
        statusCode = codes.ResourceExhausted
    case MethodNotAllowed.Code():
        statusCode = codes.Unimplemented
    default:
        statusCode = codes.Unknown
    }

    return statusCode
}

type Status struct {
    Code      int32 `protobuf:"..."`
    Message   string `protobuf:"..."`
    Details   []*any.Any `protobuf:"..."`
    ...
}

import "google/protobuf/any.proto";

package proto;

message Pager {...}

message Error {
    int32 code = 1;
    string message = 2;
    google.protobuf.Any detail = 3;
}

func TogRPCError(err *Error) error {
    s, _ := status.New(ToRPCCode(err.Code()), err.Msg()).WithDetails(&pb.Error{Code: int32(err.Code()), Message: err.Msg()})
    return s.Err()
}

type Status struct {
    *status.Status
}

func FromError(err error) *Status {
    s, _ := status.FromError(err)
    return &Status{s}
}

func ToRPCStatus(code int, msg string) *Status {
    s, _ := status.New(ToRPCCode(code), msg).WithDetails(&pb.Error{Code: int32(code), Message: msg})
    return &Status{s}
}

var (
    ErrorGetTagListFail = NewError(20010001, "获取标签列表失败")
)

func (t *TagServer) GetTagList(ctx context.Context, r *pb.GetTagListRequest) (*pb.GetTagListReply, error) {
    _, err := http.Get("http://127.0.0.1:8000/api/v1/tags?name=" + r.GetName())
    if err != nil {
        return nil, errcode.TogRPCError(errcode.ErrorGetTagListFail)
    }
    ...
}

$ grpcurl -plaintext localhost:8001 proto.TagService.GetTagList  
ERROR:
  Code: Unknown
  Message: 获取标签列表失败
  Details:
  1)    {
          "@type": "type.googleapis.com/proto.Error",
          "code": 20010001,
          "message": "获取标签列表失败"
        }

err := errcode.TogRPCError(errcode.ErrorGetTagListFail)
sts := errcode.FromError(err)
details := sts.Details()

type GetTagListReply struct {
    List                 []*Tag   `protobuf:"... json:"list,omitempty"`
    Pager                *Pager   `protobuf:"... json:"pager,omitempty"`
}

type Tag struct {
    Id                   int64    `protobuf:"... json:"id,omitempty"`
    Name                 string   `protobuf:"... json:"name,omitempty"`
    State                uint32   `protobuf:"... json:"state,omitempty"`
    ...
}

package main

import (
    ...
    pb "github.com/go-programming-tour-book/tag-service/proto"
)

func main() {
    ctx := context.Background()
    clientConn, _ := GetClientConn(ctx, "localhost:8004", nil)
    defer clientConn.Close()
  
    tagServiceClient := pb.NewTagServiceClient(clientConn)
    resp, _ := tagServiceClient.GetTagList(ctx, &pb.GetTagListRequest{Name: "Go"})
    
    log.Printf("resp: %v", resp)
}

func GetClientConn(ctx context.Context, target string, opts []grpc.DialOption) (*grpc.ClientConn, error) {
    opts = append(opts, grpc.WithInsecure())
    return grpc.DialContext(ctx, target, opts...)
}

func main() {
    ctx := context.Background()
    clientConn, _ := GetClientConn(ctx, "localhost:8004", nil)
    defer clientConn.Close()
}

func main() {
    ctx := context.Background()
    clientConn, _ := GetClientConn(
        ctx,
        "localhost:8004",
        []grpc.DialOption{grpc.WithBlock()},
    )
    defer clientConn.Close()
}

func (ac *addrConn) connect()
func (ac *addrConn) resetTransport()
func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time)
func (ac *addrConn) getReadyTransport()

func (ac *addrConn) resetTransport() {
    for i := 0; ; i++ {
        if ac.state == connectivity.Shutdown {
            return
        }
        ...
        connectDeadline := time.Now().Add(dialDuration)
        ac.updateConnectivityState(connectivity.Connecting)
        newTr, addr, reconnect, err := ac.tryAllAddrs(addrs, connectDeadline)
        if err != nil {
            if ac.state == connectivity.Shutdown {
                return
            }
            ac.updateConnectivityState(connectivity.TransientFailure)
            timer := time.NewTimer(backoffFor)
            select {
            case <-timer.C:
                ...
            }
            continue
        }

        if ac.state == connectivity.Shutdown {
            newTr.Close()
            return
        }
        ...
        if !healthcheckManagingState {
            ac.updateConnectivityState(connectivity.Ready)
        }
        ...

        if ac.state == connectivity.Shutdown {
            return
        }
        ac.updateConnectivityState(connectivity.TransientFailure)
    }
}

var grpcPort string
var httpPort string

func init() {
    flag.StringVar(&grpcPort, "grpc_port", "8001", "gRPC 启动端口号")
    flag.StringVar(&httpPort, "http_port", "9001", "HTTP 启动端口号")
    flag.Parse()
}

func RunHttpServer(port string) error {
    serveMux := http.NewServeMux()
    serveMux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        _, _ = w.Write([]byte(`pong`))
    })

    return http.ListenAndServe(":"+port, serveMux)
}

func RunGrpcServer(port string) error {
    s := grpc.NewServer()
    pb.RegisterTagServiceServer(s, server.NewTagServer())
    reflection.Register(s)
    lis, err := net.Listen("tcp", ":"+port)
    if err != nil {
        return err
    }

    return s.Serve(lis)
}

func main() {
    errs := make(chan error)
    go func() {
        err := RunHttpServer(httpPort)
        if err != nil {
            errs <- err
        }
    }()
    go func() {
        err := RunGrpcServer(grpcPort)
        if err != nil {
            errs <- err
        }
    }()

    select {
    case err := <-errs:
        log.Fatalf("Run Server err: %v", err)
    }
}

$ go get -u github.com/soheilhy/cmux@v0.1.4

var port string

func init() {
    flag.StringVar(&port, "port", "8003", "启动端口号")
    flag.Parse()
}

func RunTCPServer(port string) (net.Listener, error) {
    return net.Listen("tcp", ":"+port)
}

func RunGrpcServer() *grpc.Server {
    s := grpc.NewServer()
    pb.RegisterTagServiceServer(s, server.NewTagServer())
    reflection.Register(s)

    return s
}

func RunHttpServer(port string) *http.Server {
    serveMux := http.NewServeMux()
    serveMux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        _, _ = w.Write([]byte(`pong`))
    })

    return &http.Server{
        Addr:    ":" + port,
        Handler: serveMux,
    }
}

func main() {
    l, err := RunTCPServer(port)
    if err != nil {
        log.Fatalf("Run TCP Server err: %v", err)
    }

    m := cmux.New(l)
    grpcL := m.MatchWithWriters(cmux.HTTP2MatchHeaderFieldPrefixSendSettings("content-type", "application/grpc"))
    httpL := m.Match(cmux.HTTP1Fast())
    
    grpcS := RunGrpcServer()
    httpS := RunHttpServer(port)
    go grpcS.Serve(grpcL)
    go httpS.Serve(httpL)

    err = m.Serve()
    if err != nil {
        log.Fatalf("Run Serve err: %v", err)
    }
}

syntax = "proto3";

package proto;

import "proto/common.proto";
import "google/api/annotations.proto";

service TagService {
    rpc GetTagList (GetTagListRequest) returns (GetTagListReply) {
        option (google.api.http) = {
            get: "/api/v1/tags"
        };
    }
}
...

$ protoc -I/usr/local/include -I. \
       -I$GOPATH/src \
       -I$GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
       --grpc-gateway_out=logtostderr=true:. \
       ./proto/*.proto

protoc -I. -IG:\GoPath -IG:\GoPath\pkg\mod\github.com\grpc-ecosystem\grpc-gateway@v1.16.0\third_party\googleapis --grpc-gateway_out=logtostderr=true:. ./proto/*.proto

syntax = "proto3";

package google.api;

import "google/api/http.proto";
import "google/protobuf/descriptor.proto";
...
extend google.protobuf.MethodOptions {
  HttpRule http = 72295728;
}

message HttpRule {
  string selector = 1;
  oneof pattern {
    string get = 2;
    string put = 3;
    string post = 4;
    string delete = 5;
    string patch = 6;
    CustomHttpPattern custom = 8;
  }

  string body = 7;
  string response_body = 12;
  repeated HttpRule additional_bindings = 11;
}

var port string

func init() {
    flag.StringVar(&port, "port", "8004", "启动端口号")
    flag.Parse()
}

func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
    return h2c.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
            grpcServer.ServeHTTP(w, r)
        } else {
            otherHandler.ServeHTTP(w, r)
        }
    }), &http2.Server{})
}

gRPC 和 HTTP/1.1 的流量区分：
    对 ProtoMajor 进行判断，该字段代表客户端请求的版本号，客户端始终使用 HTTP/1.1 或 HTTP/2。
    Header 头 Content-Type 的确定：grpc 的标志位 application/grpc 的确定。
gRPC 服务的非加密模式的设置：关注代码中的"h2c"标识，“h2c” 标识允许通过明文 TCP 运行 HTTP/2 的协议，此标识符用于 HTTP/1.1 升级标头字段以及标识 HTTP/2 over TCP，而官方标准库 golang.org/x/net/http2/h2c 实现了 HTTP/2 的未加密模式，我们直接使用即可。

import (
    "github.com/grpc-ecosystem/grpc-gateway/runtime"
    ...
)

func RunServer(port string) error {
    httpMux := runHttpServer()
    grpcS := runGrpcServer()
    gatewayMux := runGrpcGatewayServer()

    httpMux.Handle("/", gatewayMux)

    return http.ListenAndServe(":"+port, grpcHandlerFunc(grpcS, httpMux))
}

func runHttpServer() *http.ServeMux {
    serveMux := http.NewServeMux()
    serveMux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        _, _ = w.Write([]byte(`pong`))
    })

    return serveMux
}

func runGrpcServer() *grpc.Server {
    s := grpc.NewServer()
    pb.RegisterTagServiceServer(s, server.NewTagServer())
    reflection.Register(s)

    return s
}

func runGrpcGatewayServer() *runtime.ServeMux {
    endpoint := "0.0.0.0:" + port
    gwmux := runtime.NewServeMux()
    dopts := []grpc.DialOption{grpc.WithInsecure()}
    _ = pb.RegisterTagServiceHandlerFromEndpoint(context.Background(), gwmux, endpoint, dopts)

    return gwmux
}

func main() {
    err := RunServer(port)
    if err != nil {
        log.Fatalf("Run Serve err: %v", err)
    }
}

$ curl http://127.0.0.1:8004/ping
$ curl http://127.0.0.1:8004/api/v1/tags
$ grpcurl -plaintext localhost:8004 proto.TagService.GetTagList 

{
    "error": "获取标签列表失败",
    "code": 2,
    "message": "获取标签列表失败",
    "details": [{
        "@type": "type.googleapis.com/proto.Error",
        "code": 20010001,
        "message": "获取标签列表失败"
    }]
}

type httpError struct {
    Code    int32  `json:"code,omitempty"`
    Message string `json:"message,omitempty"`
}

func grpcGatewayError(ctx context.Context, _ *runtime.ServeMux, marshaler runtime.Marshaler, w http.ResponseWriter, _ *http.Request, err error) {
    s, ok := status.FromError(err)
    if !ok {
        s = status.New(codes.Unknown, err.Error())
    }

    httpError := httpError{Code: int32(s.Code()), Message: s.Message()}
    details := s.Details()
    for _, detail := range details {
        if v, ok := detail.(*pb.Error); ok {
            httpError.Code = v.Code
            httpError.Message = v.Message
        }
    }

    resp, _ := json.Marshal(httpError)
    w.Header().Set("Content-type", marshaler.ContentType())
    w.WriteHeader(runtime.HTTPStatusFromCode(s.Code()))
    _, _ = w.Write(resp)
}

func runGrpcGatewayServer() *runtime.ServeMux {
    endpoint := "0.0.0.0:" + port

    runtime.HTTPError = grpcGatewayError

    gwmux := runtime.NewServeMux()
    dopts := []grpc.DialOption{grpc.WithInsecure()}
    _ = pb.RegisterTagServiceHandlerFromEndpoint(context.Background(), gwmux, endpoint, dopts)

    return gwmux
}
...

$ curl -v http://127.0.0.1:8004/api/v1/tags 
< HTTP/1.1 500 Internal Server Error
< Content-Type: application/json

{"code":20010001,"message":"获取标签列表失败"}

func RegisterTagServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
    conn, err := grpc.Dial(endpoint, opts...)
    if err != nil {
        return err
    }
    defer func() {
        if err != nil {
            if cerr := conn.Close(); cerr != nil {
                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
            }
            return
        }
        go func() {
            <-ctx.Done()
            if cerr := conn.Close(); cerr != nil {
                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
            }
        }()
    }()

    return RegisterTagServiceHandler(ctx, mux, conn)
}

func RegisterTagServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TagServiceClient) error {
  
    mux.Handle("GET", pattern_TagService_GetTagList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
    
        ctx, cancel := context.WithCancel(req.Context())
        defer cancel()
        inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
        rctx, _ := runtime.AnnotateContext(ctx, mux, req)
        resp, md, _ := request_TagService_GetTagList_0(rctx, inboundMarshaler, client, req, pathParams)
        ctx = runtime.NewServerMetadataContext(ctx, md)

        forward_TagService_GetTagList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
    })

    return nil
}

注册方法：会将当前 RPC 方法所预定义的 HTTP Endpoint（根据 proto 文件所生成的.pb.gw.go 中所包含的信息）注册到外部所传入的 HTTP 多路复用器中，也就是对应我们程序中的 runtime.NewServeMux 方法所返回的 gmux。

超时时间：会根据外部所传入的上下文进行控制。

请求/响应数据：根据所传入的 MIME 类型进行默认序列化，例如：application/jsonpb、application/json。另外其在实现上是一个 Marshaler，也就是我们可以通过调用 grpc-gateway 中的 runtime.WithMarshalerOption 方法来注册我们所需要的 MIME 类型及其对应的 Marshaler。

Metadata（元数据）：会将 gRPC metadata 转换为 context 中，便于使用。

$ go get -u github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger

$ go get -u github.com/go-bindata/go-bindata/...

$ go-bindata --nocompress -pkg swagger -o pkg/swagger/data.go third_party/swagger-ui/...

$ go get -u github.com/elazarl/go-bindata-assetfs/...

import (
    assetfs "github.com/elazarl/go-bindata-assetfs"
    "github.com/go-programming-tour-book/tag-service/pkg/swagger"
    ...
)

func runHttpServer() *http.ServeMux {
    serveMux := http.NewServeMux()
    serveMux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        _, _ = w.Write([]byte(`pong`))
    })

    prefix := "/swagger-ui/"
    fileServer := http.FileServer(&assetfs.AssetFS{
        Asset:    swagger.Asset,
        AssetDir: swagger.AssetDir,
        Prefix:   "third_party/swagger-ui",
    })
    serveMux.Handle(prefix, http.StripPrefix(prefix, fileServer))
    
    return serveMux
}

$ protoc -I/usr/local/include -I. \
  -I$GOPATH/src \
  -I$GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
  --swagger_out=logtostderr=true:. \
  ./proto/*.proto

protoc -I. -IG:\GoPath -IG:\GoPath\pkg\mod\github.com\grpc-ecosystem\grpc-gateway@v1.16.0\third_party\googleapis --swagger_out=logtostderr=true:. ./proto/*.proto

func runHttpServer() *http.ServeMux {
    ...
    serveMux.Handle(prefix, http.StripPrefix(prefix, fileServer))
    
    serveMux.HandleFunc("/swagger/", func(w http.ResponseWriter, r *http.Request) {
        if !strings.HasSuffix(r.URL.Path, "swagger.json") {
            http.NotFound(w, r)
            return
        }

        p := strings.TrimPrefix(r.URL.Path, "/swagger/")
        p = path.Join("proto", p)

        http.ServeFile(w, r, p)
    })

    return serveMux
}