115 lines
3.5 KiB
Go
115 lines
3.5 KiB
Go
package companion
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// SCUMPlayerLogProjection is plugin-owned business logic. It consumes the
|
|
// opaque log channel after the platform has forwarded it and publishes a typed
|
|
// players snapshot; Run and Platform never inspect the source text.
|
|
type SCUMPlayerLogProjection struct {
|
|
Client *Client
|
|
ServerInstanceID string
|
|
KeepForSeconds int
|
|
MaxRecords int
|
|
Now func() time.Time
|
|
|
|
mu sync.Mutex
|
|
players map[string]scumPlayerProjection
|
|
sequence uint64
|
|
}
|
|
|
|
type scumPlayerProjection struct {
|
|
PlayerID string
|
|
PlayerName string
|
|
Status string
|
|
LastSeenAt time.Time
|
|
}
|
|
|
|
func NewSCUMPlayerLogProjection(client *Client, serverInstanceID string) *SCUMPlayerLogProjection {
|
|
return &SCUMPlayerLogProjection{Client: client, ServerInstanceID: serverInstanceID, KeepForSeconds: 86400, MaxRecords: 1000, Now: time.Now, players: map[string]scumPlayerProjection{}}
|
|
}
|
|
|
|
func (projection *SCUMPlayerLogProjection) Handle(ctx context.Context, batch SemanticEventBatch) error {
|
|
if projection == nil || projection.Client == nil || strings.TrimSpace(projection.ServerInstanceID) == "" {
|
|
return fmt.Errorf("SCUM player log projection is not configured")
|
|
}
|
|
if batch.ServerID != projection.ServerInstanceID {
|
|
return fmt.Errorf("SCUM player log projection server scope mismatch")
|
|
}
|
|
now := time.Now
|
|
if projection.Now != nil {
|
|
now = projection.Now
|
|
}
|
|
projection.mu.Lock()
|
|
for _, event := range batch.Events {
|
|
playerID := strings.TrimSpace(event.PlayerID)
|
|
if playerID == "" {
|
|
continue
|
|
}
|
|
name := strings.TrimSpace(event.DisplayName)
|
|
if name == "" {
|
|
name = playerID
|
|
}
|
|
player := projection.players[playerID]
|
|
player.PlayerID = playerID
|
|
player.PlayerName = name
|
|
player.LastSeenAt = event.OccurredAt.UTC()
|
|
if player.LastSeenAt.IsZero() {
|
|
player.LastSeenAt = now().UTC()
|
|
}
|
|
switch event.Type {
|
|
case "scum.login":
|
|
player.Status = "online"
|
|
case "scum.logout":
|
|
player.Status = "offline"
|
|
default:
|
|
continue
|
|
}
|
|
projection.players[playerID] = player
|
|
}
|
|
if len(batch.Events) == 0 {
|
|
projection.mu.Unlock()
|
|
return nil
|
|
}
|
|
players := make([]scumPlayerProjection, 0, len(projection.players))
|
|
for _, player := range projection.players {
|
|
players = append(players, player)
|
|
}
|
|
projection.sequence++
|
|
sequence := projection.sequence
|
|
projection.mu.Unlock()
|
|
sort.Slice(players, func(i, j int) bool { return players[i].PlayerID < players[j].PlayerID })
|
|
payloadPlayers := make([]map[string]any, 0, len(players))
|
|
for _, player := range players {
|
|
payloadPlayers = append(payloadPlayers, map[string]any{
|
|
"playerId": player.PlayerID,
|
|
"playerName": player.PlayerName,
|
|
"status": player.Status,
|
|
"lastSeenAt": player.LastSeenAt.Format(time.RFC3339Nano),
|
|
})
|
|
}
|
|
observedAt := now().UTC()
|
|
_, err := projection.Client.UploadSnapshot(ctx, Snapshot{
|
|
Type: "players", SchemaVersion: "1", StreamKey: "current", Sequence: sequence,
|
|
ObservedAt: observedAt, Payload: map[string]any{"observedAt": observedAt.Format(time.RFC3339Nano), "players": payloadPlayers},
|
|
KeepForSeconds: projection.KeepForSeconds, MaxRecords: projection.MaxRecords,
|
|
})
|
|
return err
|
|
}
|
|
|
|
type noopConsoleLogStore struct{}
|
|
|
|
func (noopConsoleLogStore) EnsureSchema(context.Context) error { return nil }
|
|
func (noopConsoleLogStore) StoreConsoleRecords(context.Context, []ConsoleRecord) (int, error) {
|
|
return 0, nil
|
|
}
|
|
func (noopConsoleLogStore) StoreSemanticEventBatch(_ context.Context, batch SemanticEventBatch) (int, error) {
|
|
return len(batch.Events), nil
|
|
}
|