cleanup

rpc-server.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"encoding/binary"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net"
@@ -10,11 +9,11 @@ import (
 
 type GrainHandler struct {
 	listener net.Listener
-	pool     GrainPool
+	pool     *GrainLocalPool
 }
 
 func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
-	grain, err := h.pool.Get(id)
+	grain, err := h.pool.GetGrain(id)
 	if err != nil {
 		return err
 	}
@@ -22,7 +21,7 @@ func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
 	return nil
 }
 
-func NewGrainHandler(pool GrainPool, listen string) (*GrainHandler, error) {
+func NewGrainHandler(pool *GrainLocalPool, listen string) (*GrainHandler, error) {
 	handler := &GrainHandler{
 		pool: pool,
 	}
@@ -33,33 +32,30 @@ func NewGrainHandler(pool GrainPool, listen string) (*GrainHandler, error) {
 
 func (h *GrainHandler) Serve() {
 	for {
-		// Accept incoming connections
 		conn, err := h.listener.Accept()
 		if err != nil {
-			fmt.Println("Error:", err)
+			fmt.Println("Error accepting connection:", err)
 			continue
 		}
 
-		// Handle client connection in a goroutine
 		go h.handleClient(conn)
 	}
 }
 
 func (h *GrainHandler) handleClient(conn net.Conn) {
-
+	var err error
 	fmt.Println("Handling client connection")
 	defer conn.Close()
 
 	var packet CartPacket
 	for {
-
 		for {
-			err := binary.Read(conn, binary.LittleEndian, &packet)
+			err = binary.Read(conn, binary.LittleEndian, &packet)
 			if err != nil {
 				if err == io.EOF {
 					break
 				}
-				fmt.Println("Error reading packet:", err)
+				fmt.Println("Error in connection:", err)
 			}
 			if packet.Version != 2 {
 				fmt.Printf("Unknown version %d", packet.Version)
@@ -70,42 +66,24 @@ func (h *GrainHandler) handleClient(conn net.Conn) {
 			case RemoteHandleMessage:
 				fmt.Printf("Handling message\n")
 				var msg Message
-				err := MessageFromReader(conn, &msg)
+				err = MessageFromReader(conn, &msg)
 				if err != nil {
 					fmt.Println("Error reading message:", err)
 				}
 				fmt.Printf("Message: %s, %v\n", packet.Id.String(), msg)
-				grain, err := h.pool.Get(packet.Id)
-				if err != nil {
-					fmt.Println("Error getting grain:", err)
-				}
-				_, err = grain.HandleMessage(&msg, false)
+				grain, err := h.pool.Process(packet.Id, msg)
 				if err != nil {
 					fmt.Println("Error handling message:", err)
 				}
-				SendPacket(conn, ResponseBody, func(w io.Writer) error {
-					data, err := json.Marshal(grain)
-					if err != nil {
-						return err
-					}
-					w.Write(data)
-					return nil
-				})
-			case RemoteGetState:
+				SendProxyResponse(conn, grain)
 
+			case RemoteGetState:
 				fmt.Printf("Package: %s %v\n", packet.Id.String(), packet)
 				grain, err := h.pool.Get(packet.Id)
 				if err != nil {
 					fmt.Println("Error getting grain:", err)
 				}
-				SendPacket(conn, ResponseBody, func(w io.Writer) error {
-					data, err := json.Marshal(grain)
-					if err != nil {
-						return err
-					}
-					w.Write(data)
-					return nil
-				})
+				SendProxyResponse(conn, grain)
 			}
 
 		}