func (c jsonClient) Call(ctx context.Context, reqMeta yarpc.CallReqMeta, reqBody interface{}, resBodyOut interface{}) (yarpc.CallResMeta, error) {
treq := transport.Request{
Caller: c.ch.Caller(),
Service: c.ch.Service(),
Encoding: Encoding,
}
meta.ToTransportRequest(reqMeta, &treq)
encoded, err := json.Marshal(reqBody)
if err != nil {
return nil, encoding.RequestBodyEncodeError(&treq, err)
}
treq.Body = bytes.NewReader(encoded)
tres, err := c.ch.GetUnaryOutbound().Call(ctx, &treq)
if err != nil {
return nil, err
}
dec := json.NewDecoder(tres.Body)
if err := dec.Decode(resBodyOut); err != nil {
return nil, encoding.ResponseBodyDecodeError(&treq, err)
}
if err := tres.Body.Close(); err != nil {
return nil, err
}
return meta.FromTransportResponse(tres), nil
}
func (c rawClient) CallOneway(ctx context.Context, reqMeta yarpc.CallReqMeta, body []byte) (transport.Ack, error) {
treq := transport.Request{
Caller: c.ch.Caller(),
Service: c.ch.Service(),
Encoding: Encoding,
Body: bytes.NewReader(body),
}
meta.ToTransportRequest(reqMeta, &treq)
return c.ch.GetOnewayOutbound().CallOneway(ctx, &treq)
}
func (c thriftClient) buildTransportRequest(
reqMeta yarpc.CallReqMeta,
reqBody envelope.Enveloper,
) (*transport.Request, protocol.Protocol, error) {
proto := c.p
if !c.Enveloping {
proto = disableEnvelopingProtocol{
Protocol: proto,
Type: wire.Reply, // we only decode replies with this instance
}
}
treq := transport.Request{
Caller: c.ch.Caller(),
Service: c.ch.Service(),
Encoding: Encoding,
}
meta.ToTransportRequest(reqMeta, &treq)
// Always override the procedure name to the Thrift procedure name.
treq.Procedure = procedureName(c.thriftService, reqBody.MethodName())
value, err := reqBody.ToWire()
if err != nil {
// ToWire validates the request. If it failed, we should return the error
// as-is because it's not an encoding error.
return nil, nil, err
}
reqEnvelopeType := reqBody.EnvelopeType()
if reqEnvelopeType != wire.Call && reqEnvelopeType != wire.OneWay {
return nil, nil, encoding.RequestBodyEncodeError(
&treq, errUnexpectedEnvelopeType(reqEnvelopeType),
)
}
var buffer bytes.Buffer
err = proto.EncodeEnveloped(wire.Envelope{
Name: reqBody.MethodName(),
Type: reqEnvelopeType,
SeqID: 1, // don't care
Value: value,
}, &buffer)
if err != nil {
return nil, nil, encoding.RequestBodyEncodeError(&treq, err)
}
treq.Body = &buffer
return &treq, proto, nil
}
func (c jsonClient) CallOneway(ctx context.Context, reqMeta yarpc.CallReqMeta, reqBody interface{}) (transport.Ack, error) {
treq := transport.Request{
Caller: c.ch.Caller(),
Service: c.ch.Service(),
Encoding: Encoding,
}
meta.ToTransportRequest(reqMeta, &treq)
var buff bytes.Buffer
if err := json.NewEncoder(&buff).Encode(reqBody); err != nil {
return nil, encoding.RequestBodyEncodeError(&treq, err)
}
treq.Body = &buff
return c.ch.GetOnewayOutbound().CallOneway(ctx, &treq)
}
func (c rawClient) Call(ctx context.Context, reqMeta yarpc.CallReqMeta, body []byte) ([]byte, yarpc.CallResMeta, error) {
treq := transport.Request{
Caller: c.ch.Caller(),
Service: c.ch.Service(),
Encoding: Encoding,
Body: bytes.NewReader(body),
}
meta.ToTransportRequest(reqMeta, &treq)
tres, err := c.ch.GetUnaryOutbound().Call(ctx, &treq)
if err != nil {
return nil, nil, err
}
defer tres.Body.Close()
resBody, err := ioutil.ReadAll(tres.Body)
if err != nil {
return nil, nil, err
}
return resBody, meta.FromTransportResponse(tres), nil
}