119 lines
4.0 KiB
Go
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)
|
|
}
|
|
}
|