refactor protocol message encoding functions

Author: iamjinlei

ipc/node.go

@@ -114,18 +114,28 @@ func (n *Node) clientLoop() {
 			defer c.Close()
 
 			n.cfg.setWriteDeadline(c)
-			if err := protocol.WriteHandshake(c, n.id); err != nil {
+			if err := protocol.WriteMsg(
+				c,
+				protocol.NewHandshake(n.id),
+			); err != nil {
 				n.sendErr(err)
 				return
 			}
 
 			n.cfg.setReadDeadline(c)
-			if ack, err := protocol.ReadAck(c); err != nil {
+			if msg, err := protocol.ReadMsg(c); err != nil {
 				n.sendErr(err)
 				return
-			} else if !ack.Ok() {
-				n.sendErr(ErrHandshake)
-				return
+			} else {
+				ack, err := msg.Ack()
+				if err != nil {
+					n.sendErr(err)
+					return
+				}
+				if !ack.Ok() {
+					n.sendErr(ErrHandshake)
+					return
+				}
 			}
 
 			n.cfg.log("[Client] handshake succeeded")
@@ -153,15 +163,24 @@ func transceive(
 			cfg.log("[Client] outgoing message received from queue")
 
 			cfg.setWriteDeadline(conn)
-			if err := protocol.WriteRequest(conn, req.Data()); err != nil {
+			if err := protocol.WriteMsg(
+				conn,
+				protocol.NewRequest(req.Data()),
+			); err != nil {
 				req.setResponse(nil, err)
 				return
 			}
 
 			cfg.log("[Client] outgoing message sent")
 
 			cfg.setReadDeadline(conn)
-			resp, err := protocol.ReadResponse(conn)
+			msg, err := protocol.ReadMsg(conn)
+			if err != nil {
+				req.setResponse(nil, err)
+				return
+			}
+
+			resp, err := msg.Response()
 			if err != nil {
 				req.setResponse(nil, err)
 				return
@@ -237,14 +256,22 @@ func (n *Node) serverLoop() {
 					defer c.Close()
 
 					n.cfg.setReadDeadline(c)
-					h, err := protocol.ReadHandshake(c)
+					msg, err := protocol.ReadMsg(c)
+					if err != nil {
+						n.sendErr(err)
+						return
+					}
+					h, err := msg.Handshake()
 					if err != nil {
 						n.sendErr(err)
 						return
 					}
 
 					n.cfg.setWriteDeadline(c)
-					if err := protocol.WriteAck(c, true, "ok"); err != nil {
+					if err := protocol.WriteMsg(
+						c,
+						protocol.NewAck(true, "ok"),
+					); err != nil {
 						n.sendErr(err)
 						return
 					}
@@ -285,7 +312,11 @@ func serve(
 		}
 
 		cfg.setReadDeadline(conn)
-		req, err := protocol.ReadRequest(conn)
+		msg, err := protocol.ReadMsg(conn)
+		if err != nil {
+			return err
+		}
+		req, err := msg.Request()
 		if err != nil {
 			return err
 		}
@@ -298,7 +329,10 @@ func serve(
 
 		d, err := r.response()
 		cfg.setWriteDeadline(conn)
-		if err := protocol.WriteResponse(conn, d, err); err != nil {
+		if err := protocol.WriteMsg(
+			conn,
+			protocol.NewResponse(d, err),
+		); err != nil {
 			return err
 		}
 

protocol/ack.go

@@ -1,59 +1,25 @@
 package protocol
 
-import (
-	"io"
-
-	"github.com/iamjinlei/go-ipc/transport"
-)
-
 type Ack struct {
 	O bool
 	M string
 }
 
-func (a *Ack) Ok() bool {
-	return a.O
-}
-
-func (a *Ack) Msg() string {
-	return a.M
-}
-
-func (a *Ack) Encode() ([]byte, error) {
-	return encode(a)
-}
-
-func EncodeAck(ok bool, msg string) ([]byte, error) {
-	a := &Ack{
+func NewAck(ok bool, msg string) *Ack {
+	return &Ack{
 		O: ok,
 		M: msg,
 	}
-	return a.Encode()
 }
 
-func DecodeAck(d []byte) (*Ack, error) {
-	var a Ack
-	if err := decode(d, &a); err != nil {
-		return nil, err
-	}
-
-	return &a, nil
+func (a *Ack) Ok() bool {
+	return a.O
 }
 
-func WriteAck(w io.Writer, ok bool, msg string) error {
-	pkt, err := EncodeAck(ok, msg)
-	if err != nil {
-		return err
-	}
-
-	return transport.WritePacket(w, pkt)
+func (a *Ack) Msg() string {
+	return a.M
 }
 
-func ReadAck(r io.Reader) (*Ack, error) {
-	pkt, err := transport.ReadPacket(r)
-	if err != nil {
-		return nil, err
-	}
-
-	return DecodeAck(pkt)
+func (a *Ack) Type() MsgType {
+	return TypeAck
 }

protocol/ack_test.go

@@ -11,23 +11,17 @@ import (
 )
 
 func TestAck(t *testing.T) {
-	msg := "ack message"
+	data := "ack message"
 	for _, ok := range []bool{true, false} {
-		// Encode-decode
-		enc, err := protocol.EncodeAck(ok, msg)
-		assert.NoError(t, err)
-		a, err := protocol.DecodeAck(enc)
-		assert.NoError(t, err)
-		assert.Equal(t, ok, a.Ok())
-		assert.Equal(t, msg, a.Msg())
-
-		// Write-read
 		buf := bytes.NewBuffer(nil)
-		require.NoError(t, protocol.WriteAck(buf, ok, msg))
+		a := protocol.NewAck(ok, data)
+		require.NoError(t, protocol.WriteMsg(buf, a))
 
-		a, err = protocol.ReadAck(bytes.NewReader(buf.Bytes()))
+		msg, err := protocol.ReadMsg(bytes.NewReader(buf.Bytes()))
+		assert.NoError(t, err)
+		a, err = msg.Ack()
 		assert.NoError(t, err)
 		assert.Equal(t, ok, a.Ok())
-		assert.Equal(t, msg, a.Msg())
+		assert.Equal(t, data, a.Msg())
 	}
 }

protocol/encoding.go

@@ -1,53 +1,19 @@
 package protocol
 
-import (
-	"io"
-
-	"github.com/iamjinlei/go-ipc/transport"
-)
-
 type Handshake struct {
 	Id string
 }
 
-func (h *Handshake) ID() string {
-	return h.Id
-}
-
-func (h *Handshake) Encode() ([]byte, error) {
-	return encode(h)
-}
-
-func EncodeHandshake(id string) ([]byte, error) {
-	h := &Handshake{
+func NewHandshake(id string) *Handshake {
+	return &Handshake{
 		Id: id,
 	}
-	return h.Encode()
-}
-
-func DecodeHandshake(d []byte) (*Handshake, error) {
-	var h Handshake
-	if err := decode(d, &h); err != nil {
-		return nil, err
-	}
-
-	return &h, nil
 }
 
-func WriteHandshake(w io.Writer, id string) error {
-	pkt, err := EncodeHandshake(id)
-	if err != nil {
-		return err
-	}
-
-	return transport.WritePacket(w, pkt)
+func (h *Handshake) ID() string {
+	return h.Id
 }
 
-func ReadHandshake(r io.Reader) (*Handshake, error) {
-	pkt, err := transport.ReadPacket(r)
-	if err != nil {
-		return nil, err
-	}
-
-	return DecodeHandshake(pkt)
+func (h *Handshake) Type() MsgType {
+	return TypeHandshake
 }

protocol/handshake.go

@@ -13,18 +13,13 @@ import (
 func TestHandshake(t *testing.T) {
 	id := "test_id"
 
-	// Encode-decode
-	enc, err := protocol.EncodeHandshake(id)
-	assert.NoError(t, err)
-	h, err := protocol.DecodeHandshake(enc)
-	assert.NoError(t, err)
-	assert.Equal(t, id, h.ID())
-
-	// Write-read
+	h := protocol.NewHandshake(id)
 	buf := bytes.NewBuffer(nil)
-	require.NoError(t, protocol.WriteHandshake(buf, id))
+	require.NoError(t, protocol.WriteMsg(buf, h))
 
-	h, err = protocol.ReadHandshake(bytes.NewReader(buf.Bytes()))
+	msg, err := protocol.ReadMsg(bytes.NewReader(buf.Bytes()))
+	assert.NoError(t, err)
+	h, err = msg.Handshake()
 	assert.NoError(t, err)
 	assert.Equal(t, id, h.ID())
 }