gRPC 内容介绍 2017年07月04日 20:36:15 gRPC 内容介绍

其他 2018-06-23 02:13:21 阅读次数: 2

gRPC 内容介绍

2017年07月04日 20:36:15
阅读数：2009

gRPC概念和基本思想

概念：

gRPC是Googel基于HTTP/2以及protobuf的。gRPC通常有四种模式，unary，client streaming， server streaming 以及bidirectional streaming，但无论哪一种模式对底层的HTTP/2来说都是stream，所以总结来看，grpc仍是一套request+response的模型。

基本思想：

定义一个服务，指定其可以被远程调用的方法及其参数和返回类型。gRPC默认使用

protocol buffers 作为接口定义语言（可以替换protocol buffers），来描述服务接口和消息结构。

所以，在深入分析gRPC server如何工作之前，先了解下HTTP/2的特性和概念。

HTTP/2基本概念及特性解释

  • 二进制分帧

    • Stream： 一个双向流，一条连接可以有多个 streams。
    • Message： 也就是逻辑上面的 request，response。
    • Frame:：数据传输的最小单位。每个 Frame 都属于一个特定的 stream 或者整个连接。一个 message 可能有多个 frame 组成。

    HTTP/2将每次request、response以帧为单位进行了更细小的划分，同时抽象了流的概念，所有的帧都在特定的stream上进行传输，帧可以在数据流上乱序发送，然后再根据每个帧首部的流标识符重新组装。

    帧格式介绍：http://httpwg.org/specs/rfc7540.html#rfc.section.4.1

  • 多路复用（Multiplexing）

    在HTTP/1.1协议中，浏览器客户端在同一时间，针对同一域名下的请求有一定数量限制。超过限制数量的请求会被阻塞。

    多路复用允许同时通过单一的HTTP/2连接发起多重请求-响应消息。HTTP/2 通过 stream 支持了连接的多路复用，提高了连接的利用率。Stream 有很多重要特性：

    • 一条连接可以包含多个 streams，多个 streams 发送的数据互相不影响。
    • Stream 可以被 client 和 server 单方面或者共享使用。
    • Stream 可以被任意一段关闭。
    • Stream 会确定好发送 frame 的顺序，另一端会按照接受到的顺序来处理。
    • Stream 用一个唯一 ID 来标识。

    这里在说一下 Stream ID，如果是 client 创建的 stream，ID 就是奇数，如果是 server 创建的，ID 就是偶数。ID 0x00 和 0x01 都有特定的使用场景。

    Stream ID 不可能被重复使用，如果一条连接上面 ID 分配完了，client 会新建一条连接。而 server 则会给 client 发送一个 GOAWAY frame 强制让 client 新建一条连接。

    ​

    多路复用!

  • 服务器推送

    通常，只有在浏览器请求某个资源的时候，服务器才会向浏览器发送该资源。Server Push则允许服务器在收到浏览器的请求之前，主动向浏览器推送资源。比如说，网站首页引用了一个CSS文件。浏览器在请求首页时，服务器除了返回首页的HTML之外，可以将其引用的 CSS文件也一并推给客户端。

    Server push是HTTP/2中一个很强大的功能：

    • 服务器除了响应客户端的请求外，还可以向客户端额外推送资源。
    • 服务器推送的资源有自己独立的URL， 可以被浏览器缓存，可以达到多页面共享。
    • 资源推送遵守同源策略，服务器不可随便推送第三方资源给客户端。
    • 客户端可以拒绝推送过来的资源。

  • 头部压缩

    • HTTP/2在客户端和服务器端使用“首部表”来跟踪和存储之前发送的键－值对，对于相同的数据，不再通过每次请求和响应发送；
    • 首部表在HTTP/2的连接存续期内始终存在，由客户端和服务器共同渐进地更新;
    • 每个新的首部键－值对要么被追加到当前表的末尾，要么替换表中之前的值。

    例如：下图中的两个请求， 请求一发送了所有的头部字段，第二个请求则只需要发送差异数据，这样可以减少冗余数据，降低开销

    头部压缩

gRPC Server源码分析

gRPC Server主要完成以下功能：

  • 将proto中定义的service的真正实现注册到grpc的Server中。
  • 管理Server的Socket以及在Socket上传输数据的过程。

注册流程

以下以grpc/examples/helloworld为例进行分析。

  • 定义proto文件
syntax = "proto3";

option java_multiple_files = true;
option java_package = "io.grpc.examples.helloworld";
option java_outer_classname = "HelloWorldProto";
package helloworld;
// 定义Greeter service的方法以及方法对应的request、response
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}
message HelloRequest {
  string name = 1;
}
message HelloReply {
  string message = 1;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 将Greeter server的真正实现注册到grpc Server
// 定义Server
type server struct{}

// 实现 helloworld.proto对应的方法
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
  //将真正实现的GreeterServer注册到grpc server
    pb.RegisterGreeterServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 注册函数的分析
//生成的hello.pb.go对Greeter service的描述
var _Greeter_serviceDesc = grpc.ServiceDesc{
    ServiceName: "helloworld.Greeter",
    HandlerType: (*GreeterServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "SayHello",
            Handler:    _Greeter_SayHello_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
    Metadata: fileDescriptor0,
}
——————————————————————————————————————pb.go生成的注册函数——————————————————————————————————————
func RegisterGreeterServer(s *grpc.Server, srv GreeterServer) {
    s.RegisterService(&_Greeter_serviceDesc, srv)
}
——————————————————————————————grpc暴露的注册函数————————————————————————————————————————————
//将自定的Greeter Service注册到grpc Server
func (s *Server) RegisterService(sd *ServiceDesc, ss interface{}) {
    ht := reflect.TypeOf(sd.HandlerType).Elem()
    st := reflect.TypeOf(ss)
  //判断是否符合proto中定义的方法
    if !st.Implements(ht) {
        grpclog.Fatalf("grpc: Server.RegisterService found the handler of type %v that does not satisfy %v", st, ht)
    }
    s.register(sd, ss)
}

func (s *Server) register(sd *ServiceDesc, ss interface{}) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.printf("RegisterService(%q)", sd.ServiceName)
    if _, ok := s.m[sd.ServiceName]; ok {
        grpclog.Fatalf("grpc: Server.RegisterService found duplicate service registration for %q", sd.ServiceName)
    }
  //初始化srv
    srv := &service{
        server: ss,
        md:     make(map[string]*MethodDesc),
        sd:     make(map[string]*StreamDesc),
        mdata:  sd.Metadata,
    }
  //保存unary method对应的handler
    for i := range sd.Methods {
        d := &sd.Methods[i]
        srv.md[d.MethodName] = d
    }
  //保存stream(client, server, bidirectional)对应对应的handler
    for i := range sd.Streams {
        d := &sd.Streams[i]
        srv.sd[d.StreamName] = d
    }
  //把服务注册到grpc server中
    s.m[sd.ServiceName] = srv
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

Socket和传输数据的管理

//在做以下函数在说明的时候，去掉一些错误处理的代码和非主要逻辑的代码。
//可自行查看grpc/server.go的源码进行理解
  func (s *Server) Serve(lis net.Listener) error {
    for {
      rawConn, err := lis.Accept()
      go s.handleRawConn(rawConn)
    }
  }
//handleRawConn函数说明
func (s *Server) handleRawConn(rawConn net.Conn) {
    conn, authInfo, err := s.useTransportAuthenticator(rawConn)
    //s.opts在上一步中并未设置useHandlerImpl,进一步分析serveNewHTTP2Transport
    if s.opts.useHandlerImpl {
        s.serveUsingHandler(conn)
    } else {
        s.serveNewHTTP2Transport(conn, authInfo)
    }
}
//serveNewHTTP2Transport分析
func (s *Server) serveNewHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) {
//创建http2的transport,可自己配置该connection上最大streams数量    
  st, err := transport.NewServerTransport("http2", c, s.opts.maxConcurrentStreams, authInfo)
    if !s.addConn(st) {
        st.Close()
        return
    }
    s.serveStreams(st)
}
//调用该transport上stream对应handler函数
func (s *Server) serveStreams(st transport.ServerTransport) {
    defer s.removeConn(st)
    defer st.Close()
    var wg sync.WaitGroup
    st.HandleStreams(func(stream *transport.Stream) {
        wg.Add(1)
        go func() {
            defer wg.Done()
          //真正的steam处理函数
            s.handleStream(st, stream, s.traceInfo(st, stream))
        }()
    })
    wg.Wait()
}

func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream, trInfo *traceInfo) {
    sm := stream.Method()
    if sm != "" && sm[0] == '/' {
        sm = sm[1:]
    }
    pos := strings.LastIndex(sm, "/")
    if pos == -1 {
        if trInfo != nil {
            trInfo.tr.LazyLog(&fmtStringer{"Malformed method name %q", []interface{}{sm}}, true)
            trInfo.tr.SetError()
        }
        if err := t.WriteStatus(stream, codes.InvalidArgument, fmt.Sprintf("malformed method name: %q", stream.Method())); err != nil {
            if trInfo != nil {
                trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true)
                trInfo.tr.SetError()
            }
            grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
        }
        if trInfo != nil {
            trInfo.tr.Finish()
        }
        return
    }
  //从请求中分离出调的服务和方法
    service := sm[:pos]
    method := sm[pos+1:]
  //从grpc server中分离出注册的service信息，此处为greeterServer
    srv, ok := s.m[service]
    if !ok {
        if trInfo != nil {
            trInfo.tr.LazyLog(&fmtStringer{"Unknown service %v", []interface{}{service}}, true)
            trInfo.tr.SetError()
        }
        if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown service %v", service)); err != nil {
            if trInfo != nil {
                trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true)
                trInfo.tr.SetError()
            }
            grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
        }
        if trInfo != nil {
            trInfo.tr.Finish()
        }
        return
    }
    // Unary RPC or Streaming RPC?
    if md, ok := srv.md[method]; ok {
        s.processUnaryRPC(t, stream, srv, md, trInfo)
        return
    }
    if sd, ok := srv.sd[method]; ok {
        s.processStreamingRPC(t, stream, srv, sd, trInfo)
        return
    }
    if trInfo != nil {
        trInfo.tr.LazyLog(&fmtStringer{"Unknown method %v", []interface{}{method}}, true)
        trInfo.tr.SetError()
    }
  //client调用了server端并未实现的method
    if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown method %v", method)); err != nil {
        if trInfo != nil {
            trInfo.tr.LazyLog(&fmtStringer{"%v", []interface{}{err}}, true)
            trInfo.tr.SetError()
        }
        grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
    }
    if trInfo != nil {
        trInfo.tr.Finish()
    }
}


//最后，真实的处理stream上recv message和发送response
func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, md *MethodDesc, trInfo *traceInfo) (err error) {
    p := &parser{r: stream}
    for {
      //recvMsg从指定流获取message，返回它的message和payload format格式
        pf, req, err := p.recvMsg(s.opts.maxMsgSize)

        //check stream上传输的message压缩算法是否符合要求
        if err := checkRecvPayload(pf, stream.RecvCompress(), s.opts.dc); err != nil {
            switch err := err.(type) {
            case *rpcError:
                if err := t.WriteStatus(stream, err.code, err.desc); err != nil {
                    grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err)
                }
            default:
                if err := t.WriteStatus(stream, codes.Internal, err.Error()); err != nil {
                    grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err)
                }

            }
            return err
        }
        statusCode := codes.OK
        statusDesc := ""
        df := func(v interface{}) error {
            if pf == compressionMade {
                var err error
                req, err = s.opts.dc.Do(bytes.NewReader(req))
                if err != nil {
                    if err := t.WriteStatus(stream, codes.Internal, err.Error()); err != nil {
                        grpclog.Printf("grpc: Server.processUnaryRPC failed to write status %v", err)
                    }
                    return err
                }
            }
            if len(req) > s.opts.maxMsgSize {
                // TODO: Revisit the error code. Currently keep it consistent with
                // java implementation.
                statusCode = codes.Internal
                statusDesc = fmt.Sprintf("grpc: server received a message of %d bytes exceeding %d limit", len(req), s.opts.maxMsgSize)
            }
            if err := s.opts.codec.Unmarshal(req, v); err != nil {
                return err
            }
            if trInfo != nil {
                trInfo.tr.LazyLog(&payload{sent: false, msg: v}, true)
            }
            return nil
        }
      //调用之前注册的函数的handler
        reply, appErr := md.Handler(srv.server, stream.Context(), df, s.opts.unaryInt)
        if appErr != nil {
            if err, ok := appErr.(*rpcError); ok {
                statusCode = err.code
                statusDesc = err.desc
            } else {
                statusCode = convertCode(appErr)
                statusDesc = appErr.Error()
            }
            if trInfo != nil && statusCode != codes.OK {
                trInfo.tr.LazyLog(stringer(statusDesc), true)
                trInfo.tr.SetError()
            }
            if err := t.WriteStatus(stream, statusCode, statusDesc); err != nil {
                grpclog.Printf("grpc: Server.processUnaryRPC failed to write status: %v", err)
                return err
            }
            return nil
        }
        if trInfo != nil {
            trInfo.tr.LazyLog(stringer("OK"), false)
        }
        opts := &transport.Options{
            Last:  true,
            Delay: false,
        }
      //将结果返回给client端
        if err := s.sendResponse(t, stream, reply, s.opts.cp, opts); err != nil {
            switch err := err.(type) {
            case transport.ConnectionError:
                // Nothing to do here.
            case transport.StreamError:
                statusCode = err.Code
                statusDesc = err.Desc
            default:
                statusCode = codes.Unknown
                statusDesc = err.Error()
            }
            return err
        }
        if trInfo != nil {
            trInfo.tr.LazyLog(&payload{sent: true, msg: reply}, true)
        }
        return t.WriteStatus(stream, statusCode, statusDesc)
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212

至此，基于gRPC server端的源码分析全部结束。笔者对于gRPC的理解仍不够深入，如果发现理解有误的地方，欢迎指出。

参考资料

猜你喜欢

转载自blog.csdn.net/jhope/article/details/80689574
今日推荐
探索 api.maynor1024.live：一站式 AI 服务平台
AI一键去衣技术：窥见深度学习在图像处理领域的革命(最后有彩蛋)
艾体宝案例 | 使用Redis和Spring Ai构建rag应用程序
Apple M1 vs 高通8Gen2 vs Apple A12Z各方面比较
【升职加薪必备架构图】Springboot学习路线汇总_springboot四层架构流程图
与Apollo共创生态：Apollo7周年大会自动驾驶生态利剑出鞘
Spring Boot 3.0：未来企业应用开发的基石
Java 的 AI 前景光明
国内首个智能体生态大会！2024百度万象大会定档5月30日
开源一周年，青语言新版发布
深入浅出：大型语言模型（LLM）的全面解读
顶会ICLR2024论文Time-LLM：基于大语言模型的时间序列预测
周排行
学习笔记(01):Python入门教程-计算机如何区分数字和字符
命令行提示符_颜色
五步轻松搞定Linux下的文件同步(备份)
Visio 2010，如何打开多个窗口
西安新起点|MBA考研十大热门城市
BiSeNet: Bilateral Segmentation Network for Real-time Semantic Segmentation
【蓝桥杯】ADV-73 数组输出
[DeeplearningAI笔记]卷积神经网络4.11一维和三维卷积
Java 逻辑运算符
Python爬虫入门——2. 5 利用正则表达式爬取豆瓣电影 Top 250
每日归档
更多
2024-06-01(60)
2024-05-31(47)
2024-05-30(4)
2024-05-29(65)
2024-05-28(2)
2024-05-27(56)
2024-05-26(6)
2024-05-25(68)
2024-05-24(65)
2024-05-23(9)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022