// Poll fetches the latest state of a long-running operation. // // If Poll fails, the error is returned and op is unmodified. // If Poll succeeds and the operation has completed with failure, // the error is returned and op.Done will return true. // If Poll succeeds and the operation has completed successfully, // op.Done will return true; if resp != nil, the response of the operation // is stored in resp. func (op *Operation) Poll(ctx context.Context, resp proto.Message) error { if !op.Done() { p, err := op.c.GetOperation(ctx, &pb.GetOperationRequest{Name: op.Name()}) if err != nil { return err } op.proto = p } if !op.Done() { return nil } switch r := op.proto.Result.(type) { case *pb.Operation_Error: // TODO (pongad): r.Details may contain further information return grpc.Errorf(codes.Code(r.Error.Code), "%s", r.Error.Message) case *pb.Operation_Response: if resp == nil { return nil } return ptypes.UnmarshalAny(r.Response, resp) default: return fmt.Errorf("unsupported result type %[1]T: %[1]v", r) } }
func (kvserver *KvServer) PingStreamCS(stream BfKvService_PingStreamCSServer) error { log.Printf("===PingStreamCS===,clientid=(%s)", getClientId(stream.Context())) pingResp := &BfPingData{Message: message} anyResp, err := ptypes.MarshalAny(pingResp) if err != nil { log.Fatalf("MarshalAny fail,%v", err) return err } for { anyReq, err := stream.Recv() if err == io.EOF { return nil } if err != nil { return err } pingReq := &BfPingData{} if ptypes.Is(anyReq, pingReq) { ptypes.UnmarshalAny(anyReq, pingReq) log.Printf("recv,%s", pingReq.Message) } else { log.Fatalf("PingStreamS,%v", anyReq) return err } if err := stream.Send(anyResp); err != nil { return err } } }
func (kvserver *KvServer) PingStreamS(anyReq *Any, stream BfKvService_PingStreamSServer) error { log.Printf("===PingStreamS===,clientid=(%s)", getClientId(stream.Context())) pingReq := &BfPingData{} if ptypes.Is(anyReq, pingReq) { ptypes.UnmarshalAny(anyReq, pingReq) log.Printf("recv,%s", pingReq.Message) } else { log.Fatalf("PingStreamS,%v", anyReq) return nil } pingResp := &BfPingData{Message: message} anyResp, err := ptypes.MarshalAny(pingResp) if err != nil { log.Fatalf("MarshalAny fail,%v", err) return err } rd := rand.New(rand.NewSource(time.Now().UnixNano())) for i := 0; i < 10; i++ { log.Printf("send,%d", i) if err := stream.Send(anyResp); err != nil { return err } s := 500 + rd.Int31n(500) - 1 time.Sleep(time.Duration(s) * time.Millisecond) } return nil }
//===internal api=== func (client *BfTrderClient) DispatchPush(anyResp *Any) { if ptypes.Is(anyResp, tickType_) { tickResp := &BfTickData{} ptypes.UnmarshalAny(anyResp, tickResp) spi_.OnTick(tickResp) } else if ptypes.Is(anyResp, pingType_) { pingResp := &BfPingData{} ptypes.UnmarshalAny(anyResp, pingResp) spi_.OnPing(pingResp) } else if ptypes.Is(anyResp, accountType_) { accountResp := &BfAccountData{} ptypes.UnmarshalAny(anyResp, accountResp) spi_.OnAccount(accountResp) } else if ptypes.Is(anyResp, positionType_) { positionResp := &BfPositionData{} ptypes.UnmarshalAny(anyResp, positionResp) spi_.OnPosition(positionResp) } else if ptypes.Is(anyResp, orderType_) { orderResp := &BfOrderData{} ptypes.UnmarshalAny(anyResp, orderResp) spi_.OnOrder(orderResp) } else if ptypes.Is(anyResp, tradeType_) { tradeResp := &BfTradeData{} ptypes.UnmarshalAny(anyResp, tradeResp) spi_.OnTrade(tradeResp) } else if ptypes.Is(anyResp, logType_) { logResp := &BfLogData{} ptypes.UnmarshalAny(anyResp, logResp) spi_.OnLog(logResp) } else if ptypes.Is(anyResp, errorType_) { errorResp := &BfErrorData{} ptypes.UnmarshalAny(anyResp, errorResp) spi_.OnError(errorResp) } else if ptypes.Is(anyResp, notificationType_) { notificationResp := &BfNotificationData{} ptypes.UnmarshalAny(anyResp, notificationResp) spi_.OnNotification(notificationResp) } else { log.Printf("invalid type message,%v", anyResp) } }
func fromLogEntry(le *logpb.LogEntry) (*logging.Entry, error) { time, err := ptypes.Timestamp(le.Timestamp) if err != nil { return nil, err } var payload interface{} switch x := le.Payload.(type) { case *logpb.LogEntry_TextPayload: payload = x.TextPayload case *logpb.LogEntry_ProtoPayload: var d ptypes.DynamicAny if err := ptypes.UnmarshalAny(x.ProtoPayload, &d); err != nil { return nil, fmt.Errorf("logging: unmarshalling proto payload: %v", err) } payload = d.Message case *logpb.LogEntry_JsonPayload: // Leave this as a Struct. // TODO(jba): convert to map[string]interface{}? payload = x.JsonPayload default: return nil, fmt.Errorf("logging: unknown payload type: %T", le.Payload) } hr, err := toHTTPRequest(le.HttpRequest) if err != nil { return nil, err } return &logging.Entry{ Timestamp: time, Severity: logging.Severity(le.Severity), Payload: payload, Labels: le.Labels, InsertID: le.InsertId, HTTPRequest: hr, Operation: le.Operation, LogName: slashUnescaper.Replace(le.LogName), Resource: le.Resource, }, nil }
// Metadata unmarshals op's metadata into meta. // If op does not contain any metadata, Metadata returns ErrNoMetadata and meta is unmodified. func (op *Operation) Metadata(meta proto.Message) error { if m := op.proto.Metadata; m != nil { return ptypes.UnmarshalAny(m, meta) } return ErrNoMetadata }