go-cart-actor/grpc_server.go

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"time"

	messages "git.tornberg.me/go-cart-actor/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

// cartActorGRPCServer implements the CartActor and ControlPlane gRPC services.
// It delegates cart operations to a grain pool and cluster operations to a synced pool.
type cartActorGRPCServer struct {
	messages.UnimplementedCartActorServer
	messages.UnimplementedControlPlaneServer

	pool       GrainPool   // For cart state mutations and queries
	syncedPool *SyncedPool // For cluster membership and control
}

// NewCartActorGRPCServer creates and initializes the server.
func NewCartActorGRPCServer(pool GrainPool, syncedPool *SyncedPool) *cartActorGRPCServer {
	return &cartActorGRPCServer{
		pool:       pool,
		syncedPool: syncedPool,
	}
}

// applyMutation routes a single cart mutation to the target grain (used by per-mutation RPC handlers).
func (s *cartActorGRPCServer) applyMutation(cartID string, mutation interface{}) *messages.CartMutationReply {
	grain, err := s.pool.Apply(ToCartId(cartID), mutation)
	if err != nil {
		return &messages.CartMutationReply{
			StatusCode:      500,
			Result:          &messages.CartMutationReply_Error{Error: err.Error()},
			ServerTimestamp: time.Now().Unix(),
		}
	}
	cartState := ToCartState(grain)
	return &messages.CartMutationReply{
		StatusCode:      200,
		Result:          &messages.CartMutationReply_State{State: cartState},
		ServerTimestamp: time.Now().Unix(),
	}
}

func (s *cartActorGRPCServer) AddRequest(ctx context.Context, req *messages.AddRequestRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) AddItem(ctx context.Context, req *messages.AddItemRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) RemoveItem(ctx context.Context, req *messages.RemoveItemRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) RemoveDelivery(ctx context.Context, req *messages.RemoveDeliveryRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) ChangeQuantity(ctx context.Context, req *messages.ChangeQuantityRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) SetDelivery(ctx context.Context, req *messages.SetDeliveryRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) SetPickupPoint(ctx context.Context, req *messages.SetPickupPointRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

/*
Checkout RPC removed. Checkout is handled at the HTTP layer (PoolServer.HandleCheckout).
*/

func (s *cartActorGRPCServer) SetCartItems(ctx context.Context, req *messages.SetCartItemsRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

func (s *cartActorGRPCServer) OrderCompleted(ctx context.Context, req *messages.OrderCompletedRequest) (*messages.CartMutationReply, error) {
	if req.GetCartId() == "" {
		return &messages.CartMutationReply{
			StatusCode:      400,
			Result:          &messages.CartMutationReply_Error{Error: "cart_id is required"},
			ServerTimestamp: time.Now().Unix(),
		}, nil
	}
	return s.applyMutation(req.GetCartId(), req.GetPayload()), nil
}

// GetState retrieves the current state of a cart grain.
func (s *cartActorGRPCServer) GetState(ctx context.Context, req *messages.StateRequest) (*messages.StateReply, error) {
	if req.GetCartId() == "" {
		return &messages.StateReply{
			StatusCode: 400,
			Result:     &messages.StateReply_Error{Error: "cart_id is required"},
		}, nil
	}
	cartID := ToCartId(req.GetCartId())

	grain, err := s.pool.Get(cartID)
	if err != nil {
		return &messages.StateReply{
			StatusCode: 500,
			Result:     &messages.StateReply_Error{Error: err.Error()},
		}, nil
	}

	cartState := ToCartState(grain)

	return &messages.StateReply{
		StatusCode: 200,
		Result:     &messages.StateReply_State{State: cartState},
	}, nil
}

// ControlPlane: Ping
func (s *cartActorGRPCServer) Ping(ctx context.Context, _ *messages.Empty) (*messages.PingReply, error) {
	return &messages.PingReply{
		Host:     s.syncedPool.Hostname,
		UnixTime: time.Now().Unix(),
	}, nil
}

// ControlPlane: Negotiate (merge host views)
func (s *cartActorGRPCServer) Negotiate(ctx context.Context, req *messages.NegotiateRequest) (*messages.NegotiateReply, error) {
	hostSet := make(map[string]struct{})
	// Caller view
	for _, h := range req.GetKnownHosts() {
		if h != "" {
			hostSet[h] = struct{}{}
		}
	}
	// This host
	hostSet[s.syncedPool.Hostname] = struct{}{}
	// Known remotes
	s.syncedPool.mu.RLock()
	for h := range s.syncedPool.remoteHosts {
		hostSet[h] = struct{}{}
	}
	s.syncedPool.mu.RUnlock()

	out := make([]string, 0, len(hostSet))
	for h := range hostSet {
		out = append(out, h)
	}
	return &messages.NegotiateReply{Hosts: out}, nil
}

// ControlPlane: GetCartIds (locally owned carts only)
func (s *cartActorGRPCServer) GetCartIds(ctx context.Context, _ *messages.Empty) (*messages.CartIdsReply, error) {
	ids := make([]string, 0, len(s.syncedPool.local.grains))
	s.syncedPool.local.mu.RLock()
	for id, g := range s.syncedPool.local.grains {
		if g != nil {
			ids = append(ids, id.String())
		}
	}
	s.syncedPool.local.mu.RUnlock()
	return &messages.CartIdsReply{CartIds: ids}, nil
}

// ControlPlane: ConfirmOwner (simple always-accept implementation)
// Future enhancement: add fencing / versioning & validate current holder.
func (s *cartActorGRPCServer) ConfirmOwner(ctx context.Context, req *messages.OwnerChangeRequest) (*messages.OwnerChangeAck, error) {
	if req.GetCartId() == "" || req.GetNewHost() == "" {
		return &messages.OwnerChangeAck{
			Accepted: false,
			Message:  "cart_id and new_host required",
		}, nil
	}
	// If we are *not* the new host and currently have a local grain, we:
	//   1. Drop any local grain (relinquish ownership)
	//   2. Spawn (or refresh) a remote proxy pointing to the new owner so
	//      subsequent mutations from this node route correctly.
	if req.GetNewHost() != s.syncedPool.Hostname {
		cid := ToCartId(req.GetCartId())
		// Drop local ownership if present.
		s.syncedPool.local.mu.Lock()
		delete(s.syncedPool.local.grains, cid)
		s.syncedPool.local.mu.Unlock()

		// Ensure a remote proxy exists for the new owner. SpawnRemoteGrain will
		// no-op if host unknown and attempt AddRemote asynchronously.
		s.syncedPool.SpawnRemoteGrain(cid, req.GetNewHost())
	}
	return &messages.OwnerChangeAck{
		Accepted: true,
		Message:  "accepted",
	}, nil
}

// ControlPlane: Closing (peer shutdown notification)
func (s *cartActorGRPCServer) Closing(ctx context.Context, req *messages.ClosingNotice) (*messages.OwnerChangeAck, error) {
	if req.GetHost() != "" {
		s.syncedPool.RemoveHost(req.GetHost())
	}
	return &messages.OwnerChangeAck{
		Accepted: true,
		Message:  "removed host",
	}, nil
}

// StartGRPCServer configures and starts the unified gRPC server on the given address.
// It registers both the CartActor and ControlPlane services.
func StartGRPCServer(addr string, pool GrainPool, syncedPool *SyncedPool) (*grpc.Server, error) {
	lis, err := net.Listen("tcp", addr)
	if err != nil {
		return nil, fmt.Errorf("failed to listen: %w", err)
	}

	grpcServer := grpc.NewServer()
	server := NewCartActorGRPCServer(pool, syncedPool)

	messages.RegisterCartActorServer(grpcServer, server)
	messages.RegisterControlPlaneServer(grpcServer, server)
	reflection.Register(grpcServer)

	log.Printf("gRPC server listening on %s", addr)
	go func() {
		if err := grpcServer.Serve(lis); err != nil {
			log.Fatalf("failed to serve gRPC: %v", err)
		}
	}()

	return grpcServer, nil
}