major refactoring :/

rpc-server.go

@@ -1,15 +1,13 @@
 package main
 
 import (
-	"encoding/binary"
+	"bytes"
 	"fmt"
-	"io"
-	"net"
 )
 
 type GrainHandler struct {
-	listener net.Listener
-	pool     *GrainLocalPool
+	*CartServer
+	pool *GrainLocalPool
 }
 
 func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
@@ -22,68 +20,83 @@ func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
 }
 
 func NewGrainHandler(pool *GrainLocalPool, listen string) (*GrainHandler, error) {
+	server, err := CartListen(listen)
 	handler := &GrainHandler{
-		pool: pool,
+		CartServer: server,
+		pool:       pool,
 	}
-	l, err := net.Listen("tcp", listen)
-	handler.listener = l
+	server.HandleCall(RemoteHandleMessage, handler.RemoteHandleMessageHandler)
+	server.HandleCall(RemoteGetState, handler.RemoteGetStateHandler)
 	return handler, err
 }
 
-func (h *GrainHandler) Serve() {
-	for {
-		conn, err := h.listener.Accept()
-		if err != nil {
-			fmt.Println("Error accepting connection:", err)
-			continue
-		}
-
-		go h.handleClient(conn)
+func (h *GrainHandler) RemoteHandleMessageHandler(id CartId, data []byte) (uint16, []byte, error) {
+	var msg Message
+	err := ReadMessage(bytes.NewReader(data), &msg)
+	if err != nil {
+		fmt.Println("Error reading message:", err)
+		return RemoteHandleMessageReply, nil, err
 	}
+	replyData, err := h.pool.Process(id, msg)
+	if err != nil {
+		fmt.Println("Error handling message:", err)
+	}
+	if err != nil {
+		return RemoteHandleMessageReply, nil, err
+	}
+	return RemoteHandleMessageReply, replyData, nil
 }
 
-func (h *GrainHandler) handleClient(conn net.Conn) {
-	var err error
-
-	defer conn.Close()
-
-	var packet CartPacket
-
-	for {
-		err = binary.Read(conn, binary.LittleEndian, &packet)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			fmt.Println("Error in connection:", err)
-		}
-		if packet.Version != 2 {
-			fmt.Printf("Unknown version %d", packet.Version)
-			break
-		}
-
-		switch packet.MessageType {
-		case RemoteHandleMessage:
-			var msg Message
-			err = ReadMessage(conn, &msg)
-			if err != nil {
-				fmt.Println("Error reading message:", err)
-			}
-
-			data, err := h.pool.Process(packet.Id, msg)
-			if err != nil {
-				fmt.Println("Error handling message:", err)
-			}
-			SendRawResponse(conn, data)
-
-		case RemoteGetState:
-			data, err := h.pool.Get(packet.Id)
-			if err != nil {
-				fmt.Println("Error getting grain:", err)
-			}
-			SendRawResponse(conn, data)
-		}
-
+func (h *GrainHandler) RemoteGetStateHandler(id CartId, data []byte) (uint16, []byte, error) {
+	data, err := h.pool.Get(id)
+	if err != nil {
+		return RemoteGetStateReply, nil, err
 	}
-
+	return RemoteGetStateReply, data, nil
 }
+
+// func (h *GrainHandler) handleClient(conn net.Conn) {
+// 	var err error
+
+// 	defer conn.Close()
+
+// 	var packet CartPacket
+
+// 	for {
+// 		err = binary.Read(conn, binary.LittleEndian, &packet)
+// 		if err != nil {
+// 			if err == io.EOF {
+// 				break
+// 			}
+// 			fmt.Println("Error in connection:", err)
+// 		}
+// 		if packet.Version != 2 {
+// 			fmt.Printf("Unknown version %d", packet.Version)
+// 			break
+// 		}
+
+// 		switch packet.MessageType {
+// 		case RemoteHandleMessage:
+// 			var msg Message
+// 			err = ReadMessage(conn, &msg)
+// 			if err != nil {
+// 				fmt.Println("Error reading message:", err)
+// 			}
+
+// 			data, err := h.pool.Process(packet.Id, msg)
+// 			if err != nil {
+// 				fmt.Println("Error handling message:", err)
+// 			}
+// 			SendRawResponse(conn, data)
+
+// 		case RemoteGetState:
+// 			data, err := h.pool.Get(packet.Id)
+// 			if err != nil {
+// 				fmt.Println("Error getting grain:", err)
+// 			}
+// 			SendRawResponse(conn, data)
+// 		}
+
+// 	}
+
+// }