err := status.Error(codes.NotFound, "some description")

// 生成一個 status.Status 
st := status.New(codes.ResourceExhausted, "Request limit exceeded.")
// 填充錯誤的補充信息 WithDetails
ds, err := st.WithDetails(
    &epb.QuotaFailure{
        Violations: []*epb.QuotaFailure_Violation{{
            Subject:     fmt.Sprintf("name:%s", in.Name),
            Description: "Limit one greeting per person",
        }},
    },
)
if err != nil {
    return nil, st.Err()
}
return nil, ds.Err()

r, err := c.SayHello(ctx, &pb.HelloRequest{Name: "world"})
// 調用 RPC 如果遇到錯誤就對錯誤處理
if err != nil {
    // 轉換錯誤
    s := status.Convert(err)
    // 解析錯誤信息
    for _, d := range s.Details() {
        // 通過斷言直接使用
        switch info := d.(type) {
            case *epb.QuotaFailure:
            log.Printf("Quota failure: %s", info)
            default:
            log.Printf("Unexpected type: %s", info)
        }
    }
}

func main() {
	lis, err := net.Listen("tcp", port)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	grpcServer := grpc.NewServer() 

	// 注冊進訂單服務
	ordermgt_pb.RegisterOrderManagementServer(grpcServer, &orderMgtServer{}) 
	// 注冊進歡迎服務
	hello_pb.RegisterGreeterServer(grpcServer, &helloServer{}) 
}

func main() {
	conn, err := grpc.Dial(address, grpc.WithInsecure())
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	// 訂單服務建立實例連接
	orderManagementClient := pb.NewOrderManagementClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	order1 := pb.Order{Id: "101", Items:[]string{"iPhone XS", "Mac Book Pro"}, Destination:"San Jose, CA", Price:2300.00}
	res, addErr := orderManagementClient.AddOrder(ctx, &order1)
  
	// 歡迎服務建立實例連接
	helloClient := hwpb.NewGreeterClient(conn)
	hwcCtx, hwcCancel := context.WithTimeout(context.Background(), time.Second)
	defer hwcCancel()
  
	helloResponse, err := helloClient.SayHello(hwcCtx, &hwpb.HelloRequest{Name: "gRPC Up and Running!"})
	fmt.Println("Greeting: ", helloResponse.Message)
}

// 方法1
md := metadata.Pairs(
		"1", "v1",
    "1", "v2",	// 方法1會把相同的鍵的字段合并，[ ]string{"v1","v2"}
		"2", "v3",
	)
// 方法2
md := metadata.New(map[string]string{"1":"v1","2":"v2"})

	// 創(chuàng)建元數(shù)據
	md := metadata.Pairs(
		"timestamp", time.Now().Format(time.StampNano),
		"kn", "vn",
	)
	// 創(chuàng)建新元數(shù)據的上下文，這種方法會替換掉已有的上下文
	mdCtx := metadata.NewOutgoingContext(context.Background(), md)
	// 這種方法是將元數(shù)據附加到已有的上下文
	ctxA := metadata.AppendToOutgoingContext(mdCtx, "k1", "v1", "k1", "v2", "k2", "v3")

	// 定義頭信息和 trailer，可以用來接收元數(shù)據
	var header, trailer metadata.MD

	order1 := pb.Order{Id: "101", Items: []string{"iPhone XS", "Mac Book Pro"}, Destination: "San Jose, CA", Price: 2300.00}
	res, _ := client.AddOrder(ctxA, &order1, grpc.Header(&header), grpc.Trailer(&trailer))

	log.Print("AddOrder Response -> ", res.Value)
	// 獲取頭信息
	head, err := res.Header()
	// 獲取trailer
	trail, err := res.Trailer()

// 從上下文中獲取元數(shù)據列表
md, metadataAvailable := metadata.FromIncomingContext(ctx)
	if !metadataAvailable {
		return nil, status.Errorf(codes.DataLoss, "UnaryEcho: failed to get metadata")
	}
// 操作元數(shù)據邏輯
	if t, ok := md["timestamp"]; ok {
		fmt.Printf("timestamp from metadata:\n")
		for i, e := range t {
			fmt.Printf("====> Metadata %d. %s\n", i, e)
		}
	}

// 創(chuàng)建元數(shù)據
header := metadata.New(map[string]string{"location": "San Jose", "timestamp": time.Now().Format(time.StampNano)})
// 發(fā)送頭信息
grpc.SendHeader(ctx, header)
trailer := metadata.Pairs("status","ok")
// 設置trailer
grpc.SetTrailer(ctx,trailer)

func main(){
  roundrobinConn, err := grpc.Dial(
		address,
		grpc.WithBalancerName("round_robin"), 	// 指定負載均衡的算法
    // 默認是"pick_first"，也就是從服務器列表中第一個服務端開始嘗試發(fā)送請求，成功則后續(xù)所有RPC都發(fā)往這個服務器
    // "round_robin"輪詢調度算法，連接所有地址，每次向后端發(fā)送一個RPC
		grpc.WithInsecure(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer roundrobinConn.Close()
	// 起10個RPC調度任務
	makeRPCs(roundrobinConn, 10)
}

func makeRPCs(cc *grpc.ClientConn, n int) {
	hwc := ecpb.NewEchoClient(cc)
	for i := 0; i < n; i++ {
		callUnary(hwc)
	}
}

func callUnary(c ecpb.EchoClient) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
  
}

func main() {
	conn, err := grpc.Dial(address, grpc.WithInsecure())
	defer conn.Close()
	client := pb.NewOrderManagementClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
	defer cancel()

	order1 := pb.Order{Id: "101", Items:[]string{"iPhone XS", "Mac Book Pro"}, Destination:"San Jose, CA", Price:2300.00}
  // 通過 grpc.UseCompressor(gzip.Name) 就可以輕松壓縮數(shù)據
	res, _ := client.AddOrder(ctx, &order1, grpc.UseCompressor(gzip.Name))
}