Files
pipelines/internal/server/chat_open_workspace.go
T

119 lines
4.0 KiB
Go

package server
import (
"context"
"fmt"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
const chatWorkspaceScope = "default"
type chatOpenWorkspaceStore interface {
ChatOpenWorkspace(context.Context, string) (protocol.ChatOpenWorkspaceSnapshot, error)
SaveChatOpenWorkspace(context.Context, string, []protocol.ChatOpenWorkspaceEntry, bool) (protocol.ChatOpenWorkspaceSnapshot, error)
}
func reconcileChatWorkspace(ctx context.Context, snapshot protocol.ChatOpenWorkspaceSnapshot, broker chatBroker, registry operatorRegistry, store chatOpenWorkspaceStore) (protocol.ChatOpenWorkspaceSnapshot, error) {
if broker == nil || registry == nil || store == nil {
return snapshot, nil
}
valid := make([]protocol.ChatOpenWorkspaceEntry, 0, len(snapshot.Entries))
for _, entry := range snapshot.Entries {
row, found, err := registry.OperatorSession(ctx, entry.SessionID)
if err != nil {
return snapshot, err
}
if !found || row.ClosedAt != 0 {
continue
}
if _, live, err := broker.Session(ctx, entry.SessionID); err != nil {
return snapshot, err
} else if live {
valid = append(valid, entry)
}
}
if len(valid) == len(snapshot.Entries) {
return snapshot, nil
}
return store.SaveChatOpenWorkspace(ctx, chatWorkspaceScope, valid, false)
}
func validateChatWorkspace(ctx context.Context, request protocol.Message, broker chatBroker, registry operatorRegistry) ([]protocol.ChatOpenWorkspaceEntry, error) {
if request.ChatOpenWorkspaceRequest == nil {
return nil, fmt.Errorf("chat_open_workspace_request is required")
}
entries := request.ChatOpenWorkspaceRequest.Entries
if len(entries) > 64 {
return nil, fmt.Errorf("too many open chats")
}
seen := map[string]bool{}
for i := range entries {
id := strings.TrimSpace(entries[i].SessionID)
if !validChatSessionID(id) || seen[id] {
return nil, fmt.Errorf("invalid or duplicate open chat session %q", id)
}
entries[i].SessionID = id
seen[id] = true
if registry == nil || broker == nil {
return nil, fmt.Errorf("chat workspace validation unavailable")
}
row, found, err := registry.OperatorSession(ctx, id)
if err != nil {
return nil, err
}
if !found || row.ClosedAt != 0 {
continue
}
if _, live, err := broker.Session(ctx, id); err != nil {
return nil, err
} else if !live {
continue
}
}
return entries, nil
}
func handleChatOpenWorkspace(ctx context.Context, request protocol.Message, broker chatBroker, registry operatorRegistry, store chatOpenWorkspaceStore, changes *chatSessionChanges, clientID string, write func(protocol.Message) error) {
if store == nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat workspace persistence unavailable"})
return
}
entries, err := validateChatWorkspace(ctx, request, broker, registry)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
// Invalid, closed, deleted, and replaced sessions are dropped rather than
// returned as errors: clients can never restore them from a stale snapshot.
valid := entries[:0]
for _, entry := range entries {
row, found, rowErr := registry.OperatorSession(ctx, entry.SessionID)
if rowErr != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: rowErr.Error()})
return
}
if !found || row.ClosedAt != 0 {
continue
}
_, live, sessionErr := broker.Session(ctx, entry.SessionID)
if sessionErr != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: sessionErr.Error()})
return
}
if live {
valid = append(valid, entry)
}
}
snapshot, err := store.SaveChatOpenWorkspace(ctx, chatWorkspaceScope, valid, request.ChatOpenWorkspaceRequest.Seed)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
_ = write(protocol.Message{Type: protocol.ChatOpenWorkspace, ID: request.ID, ChatOpenWorkspace: &snapshot})
if changes != nil {
changes.broadcastWorkspace(clientID, snapshot)
}
}