major codec upgrade

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

codec/codec.go

@@ -18,40 +18,22 @@ const (
 var (
 	// ErrInvalidMessage returned when invalid messge passed to codec
 	ErrInvalidMessage = errors.New("invalid message")
+	// ErrUnknownContentType returned when content-type is unknown
+	ErrUnknownContentType = errors.New("unknown content-type")
 )
 
 // MessageType
 type MessageType int
 
-// NewCodec takes in a connection/buffer and returns a new Codec
-type NewCodec func(io.ReadWriteCloser) Codec
-
-// Codec encodes/decodes various types of messages used within go-micro.
+// Codec encodes/decodes various types of messages used within micro.
 // ReadHeader and ReadBody are called in pairs to read requests/responses
 // from the connection. Close is called when finished with the
 // connection. ReadBody may be called with a nil argument to force the
 // body to be read and discarded.
 type Codec interface {
-	Reader
-	Writer
-	Close() error
-	String() string
-}
-
-// Reader interface
-type Reader interface {
-	ReadHeader(*Message, MessageType) error
-	ReadBody(interface{}) error
-}
-
-// Writer interface
-type Writer interface {
-	Write(*Message, interface{}) error
-}
-
-// Marshaler is a simple encoding interface used for the broker/transport
-// where headers are not supported by the underlying implementation.
-type Marshaler interface {
+	ReadHeader(io.ReadWriter, *Message, MessageType) error
+	ReadBody(io.ReadWriter, interface{}) error
+	Write(io.ReadWriter, *Message, interface{}) error
 	Marshal(interface{}) ([]byte, error)
 	Unmarshal([]byte, interface{}) error
 	String() string

codec/noop.go

@@ -0,0 +1,93 @@
+package codec
+
+import (
+	"io"
+	"io/ioutil"
+)
+
+type noopCodec struct {
+}
+
+// Frame gives us the ability to define raw data to send over the pipes
+type Frame struct {
+	Data []byte
+}
+
+func (c *noopCodec) ReadHeader(conn io.ReadWriter, m *Message, t MessageType) error {
+	return nil
+}
+
+func (c *noopCodec) ReadBody(conn io.ReadWriter, b interface{}) error {
+	// read bytes
+	buf, err := ioutil.ReadAll(conn)
+	if err != nil {
+		return err
+	}
+
+	if b == nil {
+		return nil
+	}
+
+	switch v := b.(type) {
+	case []byte:
+		v = buf
+	case *[]byte:
+		*v = buf
+	case *Frame:
+		v.Data = buf
+	default:
+		return ErrInvalidMessage
+	}
+
+	return nil
+}
+
+func (c *noopCodec) Write(conn io.ReadWriter, m *Message, b interface{}) error {
+	var v []byte
+	switch vb := b.(type) {
+	case nil:
+		return nil
+	case *Frame:
+		v = vb.Data
+	case *[]byte:
+		v = *vb
+	case []byte:
+		v = vb
+	default:
+		return ErrInvalidMessage
+	}
+	_, err := conn.Write(v)
+	return err
+}
+
+func (c *noopCodec) String() string {
+	return "noop"
+}
+
+func NewCodec() Codec {
+	return &noopCodec{}
+}
+
+func (n *noopCodec) Marshal(v interface{}) ([]byte, error) {
+	switch ve := v.(type) {
+	case *[]byte:
+		return *ve, nil
+	case []byte:
+		return ve, nil
+	case *Message:
+		return ve.Body, nil
+	}
+	return nil, ErrInvalidMessage
+}
+
+func (n *noopCodec) Unmarshal(d []byte, v interface{}) error {
+	switch ve := v.(type) {
+	case []byte:
+		ve = d
+	case *[]byte:
+		*ve = d
+	case *Message:
+		ve.Body = d
+	}
+	return ErrInvalidMessage
+}