func (c *Connection) readResponse(response proto.Message) (proto.Message, error) {
message, ok := <-c.messages
if !ok {
return nil, DisconnectedError
}
if message.GetType() == warden.Message_Error {
errorResponse := &warden.ErrorResponse{}
err := proto.Unmarshal(message.Payload, errorResponse)
if err != nil {
return nil, errors.New("error unmarshalling error!")
}
return nil, &WardenError{
Message: errorResponse.GetMessage(),
Data: errorResponse.GetData(),
Backtrace: errorResponse.GetBacktrace(),
}
}
responseType := warden.TypeForMessage(response)
if message.GetType() != responseType {
return nil, errors.New(
fmt.Sprintf(
"expected message type %s, got %s\n",
responseType.String(),
message.GetType().String(),
),
)
}
err := proto.Unmarshal(message.GetPayload(), response)
return response, err
}
func (c *Connection) sendMessage(req proto.Message) error {
c.writeLock.Lock()
defer c.writeLock.Unlock()
request, err := proto.Marshal(req)
if err != nil {
return err
}
msg := &warden.Message{
Type: warden.TypeForMessage(req).Enum(),
Payload: request,
}
data, err := proto.Marshal(msg)
if err != nil {
return err
}
_, err = c.conn.Write(
[]byte(
fmt.Sprintf(
"%d\r\n%s\r\n",
len(data),
data,
),
),
)
if err != nil {
c.disconnected()
return err
}
return nil
}