func (cdc *HrpcServerCodec) WriteResponse(resp *rpc.Response, msg interface{}) error {
cdc.conn.SetDeadline(time.Now().Add(cdc.hsv.ioTimeo))
var err error
buf := EMPTY
if msg != nil {
w := bytes.NewBuffer(make([]byte, 0, 128))
enc := codec.NewEncoder(w, &cdc.msgpackHandle)
err := enc.Encode(msg)
if err != nil {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to marshal "+
"response message: %s", err.Error()))
}
buf = w.Bytes()
}
hdr := common.HrpcResponseHeader{}
hdr.MethodId = common.HrpcMethodNameToId(resp.ServiceMethod)
hdr.Seq = resp.Seq
hdr.ErrLength = uint32(len(resp.Error))
hdr.Length = uint32(len(buf))
writer := bufio.NewWriterSize(cdc.conn, 256)
err = binary.Write(writer, binary.LittleEndian, &hdr)
if err != nil {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to write response "+
"header: %s", err.Error()))
}
if hdr.ErrLength > 0 {
_, err = io.WriteString(writer, resp.Error)
if err != nil {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to write error "+
"string: %s", err.Error()))
}
}
if hdr.Length > 0 {
var length int
length, err = writer.Write(buf)
if err != nil {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to write response "+
"message: %s", err.Error()))
}
if uint32(length) != hdr.Length {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to write all of "+
"response message: %s", err.Error()))
}
}
err = writer.Flush()
if err != nil {
return newIoErrorWarn(cdc, fmt.Sprintf("Failed to write the response "+
"bytes: %s", err.Error()))
}
cdc.numHandled++
return nil
}
func (cdc *HrpcClientCodec) WriteRequest(req *rpc.Request, msg interface{}) error {
methodId := common.HrpcMethodNameToId(req.ServiceMethod)
if methodId == common.METHOD_ID_NONE {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unknown method name %s",
req.ServiceMethod))
}
mh := new(codec.MsgpackHandle)
mh.WriteExt = true
w := bytes.NewBuffer(make([]byte, 0, 2048))
enc := codec.NewEncoder(w, mh)
err := enc.Encode(msg)
if err != nil {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unable to marshal "+
"message as msgpack: %s", err.Error()))
}
buf := w.Bytes()
if len(buf) > common.MAX_HRPC_BODY_LENGTH {
return errors.New(fmt.Sprintf("HrpcClientCodec: message body is %d "+
"bytes, but the maximum message size is %d bytes.",
len(buf), common.MAX_HRPC_BODY_LENGTH))
}
hdr := common.HrpcRequestHeader{
Magic: common.HRPC_MAGIC,
MethodId: methodId,
Seq: req.Seq,
Length: uint32(len(buf)),
}
err = binary.Write(cdc.rwc, binary.LittleEndian, &hdr)
if err != nil {
return errors.New(fmt.Sprintf("Error writing header bytes: %s",
err.Error()))
}
_, err = cdc.rwc.Write(buf)
if err != nil {
return errors.New(fmt.Sprintf("Error writing body bytes: %s",
err.Error()))
}
return nil
}
func (cdc *HrpcClientCodec) WriteRequest(rr *rpc.Request, msg interface{}) error {
methodId := common.HrpcMethodNameToId(rr.ServiceMethod)
if methodId == common.METHOD_ID_NONE {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unknown method name %s",
rr.ServiceMethod))
}
mh := new(codec.MsgpackHandle)
mh.WriteExt = true
w := bytes.NewBuffer(make([]byte, 0, 2048))
var err error
enc := codec.NewEncoder(w, mh)
if methodId == common.METHOD_ID_WRITE_SPANS {
spans := msg.([]*common.Span)
req := &common.WriteSpansReq{
NumSpans: len(spans),
}
err = enc.Encode(req)
if err != nil {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unable to marshal "+
"message as msgpack: %s", err.Error()))
}
for spanIdx := range spans {
err = enc.Encode(spans[spanIdx])
if err != nil {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unable to marshal "+
"span %d out of %d as msgpack: %s", spanIdx, len(spans), err.Error()))
}
}
} else {
err = enc.Encode(msg)
if err != nil {
return errors.New(fmt.Sprintf("HrpcClientCodec: Unable to marshal "+
"message as msgpack: %s", err.Error()))
}
}
buf := w.Bytes()
if len(buf) > common.MAX_HRPC_BODY_LENGTH {
return errors.New(fmt.Sprintf("HrpcClientCodec: message body is %d "+
"bytes, but the maximum message size is %d bytes.",
len(buf), common.MAX_HRPC_BODY_LENGTH))
}
hdr := common.HrpcRequestHeader{
Magic: common.HRPC_MAGIC,
MethodId: methodId,
Seq: rr.Seq,
Length: uint32(len(buf)),
}
err = binary.Write(cdc.rwc, binary.LittleEndian, &hdr)
if err != nil {
return errors.New(fmt.Sprintf("Error writing header bytes: %s",
err.Error()))
}
if cdc.testHooks != nil && cdc.testHooks.HandleWriteRequestBody != nil {
cdc.testHooks.HandleWriteRequestBody()
}
_, err = cdc.rwc.Write(buf)
if err != nil {
return errors.New(fmt.Sprintf("Error writing body bytes: %s",
err.Error()))
}
return nil
}