Files
go-cart-actor/rpc-server.go
2024-11-08 23:50:57 +01:00

93 lines
1.8 KiB
Go

package main
import (
"encoding/binary"
"fmt"
"io"
"net"
)
type GrainHandler struct {
listener net.Listener
pool *GrainLocalPool
}
func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
grain, err := h.pool.GetGrain(id)
if err != nil {
return err
}
*reply = grain
return nil
}
func NewGrainHandler(pool *GrainLocalPool, listen string) (*GrainHandler, error) {
handler := &GrainHandler{
pool: pool,
}
l, err := net.Listen("tcp", listen)
handler.listener = l
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) 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)
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:
fmt.Printf("Handling message\n")
var msg Message
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.Process(packet.Id, msg)
if err != nil {
fmt.Println("Error handling message:", err)
}
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)
}
SendProxyResponse(conn, grain)
}
}
}
}