golang源码分析：grpc context

golangLeetcode

发布于 2022-08-03 13:53:19

8970

发布于 2022-08-03 13:53:19

gRPC 是基于 HTTP/2 协议的。进程间传输定义了一个 metadata 对象，该对象放在 Request-Headers 内，所以通过 metadata 我们可以将上一个进程中的全局对象透传到下一个被调用的进程。

type MD map[string][]string

进程内部我们通过context来传输上下文数据，进程间传递MD的时候，我们也可以从ctx，取出来，进行传递

//set 数据到 metadata
md := metadata.Pairs("key", "val")
// 新建一个有 metadata 的 context
ctx := metadata.NewOutgoingContext(context.Background(), md)

为什么不直接把context里面的数据全取出来，传递给下游呢？这是出于可维护性和安全性两方面的考虑，如果将ctx所有信息都传递下去，很有可能将一些内部信息泄漏，另一方面，下游在取ctx的时候，不知道到底传了哪些数据。所以grpc定义了两个context：

OutgoingContext
IncomingContext

OutgoingContext用于发送请求一方，包装下游依赖的数据，传递出去。IncomingContext用于服务端接受，客户端传递来的context信息。context中间通过序列化成http2 header的方式进行传输。metadata/metadata.go，我们可以看到这两个context虽然也是通过context.WithValue 设置数据，通过context.Value来读取数据。

type mdIncomingKey struct{}
type mdOutgoingKey struct{}

// NewIncomingContext creates a new context with incoming md attached.
func NewIncomingContext(ctx context.Context, md MD) context.Context {
  return context.WithValue(ctx, mdIncomingKey{}, md)
}

// NewOutgoingContext creates a new context with outgoing md attached. If used
// in conjunction with AppendToOutgoingContext, NewOutgoingContext will
// overwrite any previously-appended metadata.
func NewOutgoingContext(ctx context.Context, md MD) context.Context {
  return context.WithValue(ctx, mdOutgoingKey{}, rawMD{md: md})
}

func FromIncomingContext(ctx context.Context) (MD, bool) {
  md, ok := ctx.Value(mdIncomingKey{}).(MD)
  if !ok {
    return nil, false
  }
  out := MD{}
  for k, v := range md {
    // We need to manually convert all keys to lower case, because MD is a
    // map, and there's no guarantee that the MD attached to the context is
    // created using our helper functions.
    key := strings.ToLower(k)
    out[key] = v
  }
  return out, true
}
func FromOutgoingContext(ctx context.Context) (MD, bool) {
  raw, ok := ctx.Value(mdOutgoingKey{}).(rawMD)
  if !ok {
    return nil, false
  }

  out := MD{}
  for k, v := range raw.md {
    // We need to manually convert all keys to lower case, because MD is a
    // map, and there's no guarantee that the MD attached to the context is
    // created using our helper functions.
    key := strings.ToLower(k)
    out[key] = v
  }
  for _, added := range raw.added {
    if len(added)%2 == 1 {
      panic(fmt.Sprintf("metadata: FromOutgoingContext got an odd number of input pairs for metadata: %d", len(added)))
    }

    for i := 0; i < len(added); i += 2 {
      key := strings.ToLower(added[i])
      out[key] = append(out[key], added[i+1])
    }
  }
  return out, ok
}

但是，和普通context也是有差别的，MD的存储的时候，key 是string，value是[]string,context为了尽可能地防止覆盖，key 、value都是interface类型的，并且通过lint等方式，尽可能做到不让修改，也就是说用户自己存入的数据的key尽量要是新定义的类型，类型别名也不可以。

直观理解，客户端在发送请求的时候，会初始化一个OutgoingContext，服务端在取的时候，用的是IncomingContext，中间必然存在一个从OutgoingContext 取数据，方让http2 header，从http2 header 取数据存入IncomingContext 的过程。我们通过源码来分析下：

1，server端构造IncomingContext 的过程：

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) 
        s.serveStreams(st)

我们从server.go文件ServeHTTP 函数开始：

func (s *Server) serveStreams(st transport.ServerTransport) 
        st.HandleStreams(func(stream *transport.Stream)

它调用了internal/transport/http2_server.go里面的函数

func (t *http2Server) HandleStreams(handle func(*Stream), traceCtx func(context.Context, string) context.Context) 
     case *http2.MetaHeadersFrame:
       if t.operateHeaders(frame, handle, traceCtx) {

func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(*Stream), traceCtx func(context.Context, string) context.Context) (fatal bool)
   ctx = metadata.NewIncomingContext(ctx, ht.headerMD)

可以看到，通过http2的header构造了我们的IncomingContext

2，client从 OutgoingContext取数据的过程

客户端的请求调用是从call.go的Invoke函数开始的

func (cc *ClientConn) Invoke(ctx context.Context, method string, args, reply interface{}, opts ...CallOption) error

func invoke(ctx context.Context, method string, req, reply interface{}, cc *ClientConn, opts ...CallOption) error 
        cs, err := newClientStream(ctx, unaryStreamDesc, cc, method, opts...)
         err := cs.SendMsg(req); err != nil

func newClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption)
        return newClientStreamWithParams(ctx, desc, cc, method, mc, onCommit, done, opts...)
          op := func(a *csAttempt) error { return a.newStream() }
            s, err := a.t.NewStream(cs.ctx, cs.callHdr)

最终调用啦a.t.NewStream

实现在internal/transport/http2_client.go

func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error)
     headerFields, err := t.createHeaderFields(ctx, callHdr)

func (t *http2Client) createHeaderFields(ctx context.Context, callHdr *CallHdr) ([]hpack.HeaderField, error)
     md, added, ok := metadata.FromOutgoingContextRaw(ctx); ok

至此，完成了，数据的转换。那么问题来了，对于一个处于中游的grpc服务，每个请求，我都去先获取IncomingContext然后设置OutgoingContext是不是很麻烦我们有没有相关的简单方案呢？答案是middleware

3，客户端middleware

在客户端发起的请求连接的时候，我们可以在options里面添加拦截器unaryClientInterceptors

    conn, err := grpc.Dial(target, dialOptions...)
    dialOptions := append([]grpc.DialOption{
      grpc.WithUnaryInterceptor(grpcMiddleware.ChainUnaryClient(unaryClientInterceptors...)),

客户端的拦截器有很多，比如：

clientinterceptors.UnaryTracingInterceptor,
clientinterceptors.DurationInterceptor,
clientinterceptors.PrometheusInterceptor,
clientinterceptors.BreakerInterceptor,
clientinterceptors.TimeoutInterceptor(cliOpts.Timeout),

一个常见的客户端拦截器可以这么写，拦截器的入参有我们需要的一切：

func DurationInterceptor(ctx context.Context, method string, req, reply interface{},
  cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
   //do some thing
  err := invoker(ctx, method, req, reply, cc, opts...)

4，服务端middleware

我们在注册服务的时候，可以注册unaryServerInterceptors

server = grpc.NewServer(dialOptions...)
    dialOptions := []grpc.ServerOption{
      grpc_middleware.WithUnaryServerChain(unaryServerInterceptors...),

常见的服务端拦截器长这样：

func UnaryServerInterceptor(opts ...Option) grpc.UnaryServerInterceptor {
  o := evaluateOptions(opts)
  return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (_ interface{}, err error) {
  //do some thing
  }

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-11-23，如有侵权请联系 cloudcommunity@tencent.com 删除

网络安全