refactor/serializing (#1)

Co-authored-by: matst80 <mats.tornberg@gmail.com>
Reviewed-on: https://git.tornberg.me/mats/go-cart-actor/pulls/1

cart-grain.go

@@ -1,95 +1,29 @@
 package main
 
 import (
-	"bufio"
-	"bytes"
-	"encoding/binary"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
 	"net/http"
 	"time"
 
-	"git.tornberg.me/go-cart-actor/git.tornberg.me/go-cart-actor/messages"
+	messages "git.tornberg.me/go-cart-actor/proto"
 	"github.com/matst80/slask-finder/pkg/index"
-	"google.golang.org/protobuf/proto"
 )
 
-type StorableMessage interface {
-	GetBytes() ([]byte, error)
-	FromReader(io.Reader, *Message) error
+type CartId [16]byte
+
+func (id CartId) MarshalJSON() ([]byte, error) {
+	return json.Marshal(id.String())
 }
 
-type Message struct {
-	Type      uint64
-	TimeStamp *int64
-	Content   interface{}
-}
-
-func (m Message) GetBytes() ([]byte, error) {
-	var b bytes.Buffer
-	var err error
-	w := bufio.NewWriter(&b)
-	bytes := make([]byte, 8)
-	binary.LittleEndian.PutUint64(bytes, m.Type)
-	w.Write(bytes)
-	binary.LittleEndian.PutUint64(bytes, uint64(*m.TimeStamp))
-	w.Write(bytes)
-	var messageBytes []byte
-	if m.Type == 1 {
-		messageBytes, err = proto.Marshal(m.Content.(*messages.AddRequest))
-	} else if m.Type == 2 {
-		messageBytes, err = proto.Marshal(m.Content.(*messages.AddItem))
-	} else {
-		return nil, fmt.Errorf("unknown message type")
-	}
-	if err != nil {
-		return nil, err
-	}
-	binary.LittleEndian.PutUint64(bytes, uint64(len(messageBytes)))
-	w.Write(bytes)
-	w.Write(messageBytes)
-	w.Flush()
-	return b.Bytes(), nil
-}
-
-func (i Message) FromReader(reader io.Reader, m *Message) error {
-
-	bytes := make([]byte, 8)
-	if _, err := reader.Read(bytes); err != nil {
-		return err
-	}
-	m.Type = binary.LittleEndian.Uint64(bytes)
-	if _, err := reader.Read(bytes); err != nil {
-		return err
-	}
-	timestamp := int64(binary.LittleEndian.Uint64(bytes))
-	m.TimeStamp = &timestamp
-	if _, err := reader.Read(bytes); err != nil {
-		return err
-	}
-	messageBytes := make([]byte, binary.LittleEndian.Uint64(bytes))
-	if _, err := reader.Read(messageBytes); err != nil {
-		return err
-	}
-	var err error
-
-	if m.Type == 1 {
-		msg := &messages.AddRequest{}
-		err = proto.Unmarshal(messageBytes, msg)
-		m.Content = msg
-	} else if m.Type == 2 {
-		msg := &messages.AddItem{}
-		err = proto.Unmarshal(messageBytes, msg)
-		m.Content = msg
-	} else {
-		return fmt.Errorf("unknown message type")
-	}
+func (id *CartId) UnmarshalJSON(data []byte) error {
+	var str string
+	err := json.Unmarshal(data, &str)
 	if err != nil {
 		return err
 	}
-
+	copy(id[:], []byte(str))
 	return nil
 }
 
@@ -102,19 +36,17 @@ type CartItem struct {
 
 type CartGrain struct {
 	storageMessages []Message
-	Id              string     `json:"id"`
+	Id              CartId     `json:"id"`
 	Items           []CartItem `json:"items"`
 	TotalPrice      int64      `json:"totalPrice"`
 }
 
 type Grain interface {
-	GetId() string
-	GetLastChange() int64
-	HandleMessage(message *Message, isReplay bool, reply *CartGrain) error
-	GetStorageMessage(since int64) []StorableMessage
+	GetId() CartId
+	HandleMessage(message *Message, isReplay bool) ([]byte, error)
 }
 
-func (c *CartGrain) GetId() string {
+func (c *CartGrain) GetId() CartId {
 	return c.Id
 }
 
@@ -141,14 +73,14 @@ func getItemData(sku string) (*messages.AddItem, error) {
 		priceField, ok := item.GetFields()[4]
 		if ok {
 
-			pricef, ok := priceField.(float64)
+			priceFloat, ok := priceField.(float64)
 			if !ok {
 				price, ok = priceField.(int)
 				if !ok {
 					return nil, fmt.Errorf("invalid price type")
 				}
 			} else {
-				price = int(pricef)
+				price = int(priceFloat)
 			}
 		}
 	}
@@ -161,15 +93,15 @@ func getItemData(sku string) (*messages.AddItem, error) {
 	}, nil
 }
 
-func (c *CartGrain) AddItem(sku string, reply *CartGrain) error {
+func (c *CartGrain) AddItem(sku string) ([]byte, error) {
 	cartItem, err := getItemData(sku)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	return c.HandleMessage(&Message{
 		Type:    2,
 		Content: cartItem,
-	}, false, reply)
+	}, false)
 }
 
 func (c *CartGrain) GetStorageMessage(since int64) []StorableMessage {
@@ -183,7 +115,7 @@ func (c *CartGrain) GetStorageMessage(since int64) []StorableMessage {
 	return ret
 }
 
-func (c *CartGrain) HandleMessage(message *Message, isReplay bool, reply *CartGrain) error {
+func (c *CartGrain) HandleMessage(message *Message, isReplay bool) ([]byte, error) {
 	log.Printf("Handling message %d", message.Type)
 	if message.TimeStamp == nil {
 		now := time.Now().Unix()
@@ -191,14 +123,14 @@ func (c *CartGrain) HandleMessage(message *Message, isReplay bool, reply *CartGr
 	}
 	var err error
 	switch message.Type {
-	case 1:
+	case AddRequestType:
 		msg, ok := message.Content.(*messages.AddRequest)
 		if !ok {
 			err = fmt.Errorf("invalid content type")
 		} else {
-			return c.AddItem(msg.Sku, reply)
+			return c.AddItem(msg.Sku)
 		}
-	case 2:
+	case AddItemType:
 		msg, ok := message.Content.(*messages.AddItem)
 		if !ok {
 			err = fmt.Errorf("invalid content type")
@@ -214,9 +146,11 @@ func (c *CartGrain) HandleMessage(message *Message, isReplay bool, reply *CartGr
 	default:
 		err = fmt.Errorf("unknown message type")
 	}
+	if err != nil {
+		return nil, err
+	}
 	if !isReplay {
 		c.storageMessages = append(c.storageMessages, *message)
 	}
-	*reply = *c
-	return err
+	return json.Marshal(c)
 }