c50b3cfb3b
A 50k-file library used to wedge the database. This wave fixes the four reasons why, plus a timestamp-ordering bug the work exposed. Chunked scans (internal/library/scan.go) - One transaction wrapped the whole reconciliation, holding SQLite's single write lock for the entire scan. Now 500 groups per transaction, and the two missing-file passes are batched too. - Verified: a 20,000-file scan reports partial progress (scanned=1500 mid-scan) and a concurrent progress save returns 200 throughout. Under the old code that save blocked for the whole scan. - Behaviour change: a scan is no longer all-or-nothing. A crash now leaves a consistent partial scan. The scan is idempotent, so re-running finishes it. - res.Errors is capped at 100 (a broken mount used to append one string per file, then serialise the lot into the job row); the overflow is counted. Concurrent job workers (internal/jobs/jobs.go) - Run() was single-threaded, so a scan stalled every enrichment job behind it. Now 4 workers with jittered idle waits. - Handlers run concurrently, so Register/lookup take an RWMutex, and a panicking handler is recovered and marked failed rather than killing a worker and stranding a row in 'running'. - RecoverStale() requeues jobs left 'running' by a dead process; called at boot from main.go. Previously such a job stayed 'running' forever and the UI polled it forever. Explore (internal/media/discover.go) - Full-scanned and sorted the whole library on every home load, and was deterministic, so it showed the same 30 items every visit. Now a per-kind fair-share id range scan with a random start, wrap-around, dedup and interleaving. The doc comment claimed per-kind sampling before; now it does. Indexes (migrations/0008_query_indexes.sql) - Benchmarked with ANALYZE over 60k items: browse page 1 13.37ms -> 0.03ms (484x, full scan -> covering index), deep page 8x, recently added 3.2x. - A candidate index for the Continue shelf was built, measured and REJECTED: the planner never chose it because `finished = 0` selects the majority of a user's rows, so it had no selectivity and would have cost a write on every progress save. Recorded in the migration rather than shipped as dead weight. Canonical timestamps (internal/core/stamp.go) - time.RFC3339Nano trims trailing zeros, so its fraction width varies and the strings are not lexicographically sortable: ".5Z" > ".55Z" as strings though .500s < .550s. That broke every ORDER BY <timestamp> and MAX(timestamp), including the Continue shelf and Most Viewed. It was wrong even in columns written 100% by Go, so it was not a cross-format issue. - All 14 write sites now use core.Stamp, matching SQLite's own default format exactly. Read paths are untouched: RFC3339Nano parses both shapes, so existing rows keep working. Also: busy_timeout 5s -> 15s. Chunked scans still delay a concurrent write, and measured tail latency on a first scan of 15k new files reached 3.3s, leaving almost no margin at 5s. Waiting beats failing with SQLITE_BUSY and losing a playback position. A 10ms inter-batch yield was implemented, measured, found to have no effect distinguishable from noise (overlapping ranges), and removed. Verified end to end, not just compiled: orphan recovery logged at boot, scan returns 202 in 0.7ms, Explore varies across loads, concurrent writes survive a scan. gofmt/vet clean, 14 packages pass, -race clean on the queue, svelte-check 0/0, fresh install applies all 8 migrations.
90 lines
2.6 KiB
Go
90 lines
2.6 KiB
Go
package games
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/mithral/vellum/internal/core"
|
|
)
|
|
|
|
// MaxSaveBytes caps an uploaded save state. EmulatorJS states are typically a
|
|
// few hundred kilobytes; anything near this limit is a client bug.
|
|
const MaxSaveBytes = 16 << 20 // 16 MiB
|
|
|
|
// Save is one stored save state.
|
|
type Save struct {
|
|
Slot string `json:"slot"`
|
|
Size int64 `json:"size"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
}
|
|
|
|
// ListSaves returns a user's save slots for an item, newest first.
|
|
func ListSaves(ctx context.Context, db *sql.DB, userID, itemID int64) ([]Save, error) {
|
|
rows, err := db.QueryContext(ctx, `
|
|
SELECT slot, size, updated_at FROM game_saves
|
|
WHERE user_id = ? AND item_id = ?
|
|
ORDER BY updated_at DESC`, userID, itemID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("games: list saves: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
out := []Save{}
|
|
for rows.Next() {
|
|
var s Save
|
|
var updated string
|
|
if err := rows.Scan(&s.Slot, &s.Size, &updated); err != nil {
|
|
return nil, err
|
|
}
|
|
s.UpdatedAt, _ = time.Parse(time.RFC3339Nano, updated)
|
|
out = append(out, s)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// GetSave returns one save state's bytes. The bool is false when no save
|
|
// exists for that slot.
|
|
func GetSave(ctx context.Context, db *sql.DB, userID, itemID int64, slot string) ([]byte, bool, error) {
|
|
var data []byte
|
|
err := db.QueryRowContext(ctx, `
|
|
SELECT data FROM game_saves
|
|
WHERE user_id = ? AND item_id = ? AND slot = ?`, userID, itemID, slot).Scan(&data)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, false, nil
|
|
}
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("games: get save: %w", err)
|
|
}
|
|
return data, true, nil
|
|
}
|
|
|
|
// PutSave upserts a save state.
|
|
func PutSave(ctx context.Context, db *sql.DB, userID, itemID int64, slot string, data []byte) error {
|
|
if len(data) == 0 {
|
|
return errors.New("games: save is empty")
|
|
}
|
|
if len(data) > MaxSaveBytes {
|
|
return fmt.Errorf("games: save exceeds %d bytes", MaxSaveBytes)
|
|
}
|
|
_, err := db.ExecContext(ctx, `
|
|
INSERT INTO game_saves (user_id, item_id, slot, data, size, updated_at)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT (user_id, item_id, slot)
|
|
DO UPDATE SET data = excluded.data, size = excluded.size, updated_at = excluded.updated_at`,
|
|
userID, itemID, slot, data, len(data), core.Now())
|
|
if err != nil {
|
|
return fmt.Errorf("games: put save: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DeleteSave removes one save slot.
|
|
func DeleteSave(ctx context.Context, db *sql.DB, userID, itemID int64, slot string) error {
|
|
_, err := db.ExecContext(ctx, `
|
|
DELETE FROM game_saves WHERE user_id = ? AND item_id = ? AND slot = ?`,
|
|
userID, itemID, slot)
|
|
return err
|
|
}
|