type Context interface {
    // 返回当前context应该被cancel的时间
    // 如果 ok==false 的话，那么当前context没有deadline
    Deadline() (deadline time.Time, ok bool)

    // 返回了一个chan，当 当前context被cancel的时候，这个chan就会被close
    // 如果这个context永远也不会被cancel的时候，会返回一个nil
    //
    // WithCancel会在cancel的遍历Done
    // WithDeadline
    // WithTimeout
    //
    // Done是为了在select中使用提供的
    //
    //  // Stream generates values with DoSomething and sends them to out
    //  // until DoSomething returns an error or ctx.Done is closed.
    //  func Stream(ctx context.Context, out chan<- Value) error {
    //          for {
    //                  v, err := DoSomething(ctx)
    //                  if err != nil {
    //                          return err
    //                  }
    //                  select {
    //                  case <-ctx.Done():
    //                          return ctx.Err()
    //                  case out <- v:
    //                  }
    //          }
    //  }
    //
    // See https://blog.golang.org/pipelines for more examples of how to use
    // a Done channel for cancelation.
    Done() <-chan struct{}

    // 如果Done还没有被close，返回nil
    // 如果Done已经被clode了，返回一个non-nil的err，有几个err：
    // Canceled： context是被cancel的
    // DeadlineExceeded： context的deadline过了
    // 如果Err返回了一个non-nil，那么以后返回的结果也都是一样的
    Err() error

    // 返回指定的key的值，如果没有，返回nil
    //
    // 一个key指定了context中唯一的value。
    // key可以是任何可以比较的类型，(golint不允许使用string)
    // 各个包应该定义自己的非导出的类型所谓key，以避免重叠
    Value(key interface{}) interface{}
}

type key = struct{}
ctx := context.Background()
ctx = context.WithValue(ctx, key{}, "this is value")
fmt.Printf("value: %v\n", ctx.Value(key{}))

// 定义存储k-v的struct，是一个树结构
type valueCtx struct {
    Context
    key, val interface{}
}

// String接口
// 其中的c.Context是通过`%v`格式化的，所以这个函数实际上是一个递归函数
// 这里使用%v作为递归的方法而不是c.Context.String()，是因为Context接口没有定义String方法，而valueCtx没有定义，这一点值得学习
func (c *valueCtx) String() string {
    return fmt.Sprintf("%v.WithValue(%#v, %#v)\n", c.Context, c.key, c.val)
}

// 取值方法
// 先判断当前context中是否有该存储的值
// 没有就使用父context取，也是一个递归函数
func (c *valueCtx) Value(key interface{}) interface{} {
    if c.key == key {
        return c.val
    }
    return c.Context.Value(key)
}

// 赋值方法
// 实际上是返回一个struct，这个struct里面有key和val的field，作为k-v的存储载体
// 然后为了保留意见设置的数据，需要把老context传下去
// 所以大概是这么个格式：{{{context.TODO(), key1, val1}, key2, val2}, key3, val3}
// 所以如果在同一个key上设置了两个值，那么旧的值永远不会取出来，因为会先取到后设置的值；所以也可以直接理解为一个map（实际上复杂度不是O(1)的）
func WithValue(parent Context, key, val interface{}) Context {
    if key == nil {
        panic("nil key")
    }

    if !reflect.TypeOf(key).Comparable() {
        panic("key is not comparable")
    }

    return &valueCtx{parent, key, val}
}

package main

import (
    "context"
    "fmt"

    "google.golang.org/grpc/metadata"
)

func main() {
    // client
    md := metadata.Pairs(
        "k1", "v1",
        "k2", "v2",
    )
    ctx := metadata.NewOutgoingContext(context.Background(), md)

    // server
    md2, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        panic("no metadata")
    }

    fmt.Printf("k1 %v\n", md2["k1"])
    fmt.Printf("k2 %v\n", md2["k2"])
}