feat: multihost sync ui (#825)

internal/api/syncapi/syncstatehandler.go

@@ -0,0 +1,103 @@
+package syncapi
+
+import (
+	"context"
+	"time"
+
+	"connectrpc.com/connect"
+	v1 "github.com/garethgeorge/backrest/gen/go/v1"
+	"github.com/garethgeorge/backrest/gen/go/v1/v1connect"
+)
+
+type BackrestSyncStateHandler struct {
+	v1connect.UnimplementedBackrestSyncStateServiceHandler
+	mgr *SyncManager
+}
+
+var _ v1connect.BackrestSyncStateServiceHandler = &BackrestSyncStateHandler{}
+
+func NewBackrestSyncStateHandler(mgr *SyncManager) *BackrestSyncStateHandler {
+	return &BackrestSyncStateHandler{
+		mgr: mgr,
+	}
+}
+
+func (h *BackrestSyncStateHandler) GetPeerSyncStatesStream(ctx context.Context, req *connect.Request[v1.SyncStateStreamRequest], stream *connect.ServerStream[v1.PeerState]) error {
+	ctx, cancel := context.WithCancelCause(ctx)
+	defer cancel(nil)
+
+	// Subscribe to the peer state changes
+	onStateChangeChan := h.mgr.peerStateManager.OnStateChanged().Subscribe()
+
+	messagesToSend := make(chan *v1.PeerState, 100) // Buffered channel to allow sending items without blocking
+
+	sendAllInList := func(peers []*v1.Multihost_Peer) {
+		for _, peerState := range peers {
+			state := h.mgr.peerStateManager.GetPeerState(peerState.Keyid)
+			if state == nil {
+				continue // Skip if the peer state is not found
+			}
+			messagesToSend <- peerStateToProto(state)
+		}
+	}
+
+	sendAll := func(config *v1.Config) {
+		sendAllInList(config.GetMultihost().GetKnownHosts())
+		sendAllInList(config.GetMultihost().GetAuthorizedClients())
+	}
+
+	// Start a goroutine to listen for state changes and send them to the stream
+	go func() {
+		config, err := h.mgr.configMgr.Get()
+		if err != nil {
+			cancel(err)
+			return
+		}
+
+		// Send initial states for all known hosts and authorized clients
+		sendAll(config)
+
+		if !req.Msg.Subscribe {
+			cancel(nil)
+		}
+
+		defer h.mgr.peerStateManager.OnStateChanged().Unsubscribe(onStateChangeChan)
+		for {
+			select {
+			case <-ctx.Done():
+				return // Exit the goroutine if the context is done
+
+			case peerState, ok := <-onStateChangeChan:
+				if !ok {
+					return // Channel closed, exit the goroutine
+				}
+
+				select {
+				case messagesToSend <- peerStateToProto(peerState):
+				default:
+					// If the channel is full, wait for 100 milliseconds before cancelling
+					select {
+					case messagesToSend <- peerStateToProto(peerState):
+					case <-time.After(100 * time.Millisecond):
+						cancel(nil)
+						return
+					}
+				}
+			}
+		}
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case item, ok := <-messagesToSend:
+			if !ok {
+				return nil
+			}
+			if err := stream.Send(item); err != nil {
+				return connect.NewError(connect.CodeInternal, err)
+			}
+		}
+	}
+}