package store import ( "context" "database/sql" "errors" "fmt" "strings" "time" ) const ( ZombieGCDefaultLimit = 100 ZombieGCMaxLimit = 1000 ZombieGCDefaultGraceSeconds int64 = 24 * 60 * 60 zombieGCTimeout = 5 * time.Second emptyDocumentSHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" ) var ErrZombieGCOptions = errors.New("invalid zombie GC options") type ZombieObject struct { UUID string CreatedAt int64 RevisionCount int MaxBodyLength int } // EnsureZombieGCSchema runs during initialization, never on the request path. // Domain-only stores used for federation do not necessarily own an object store. func (s *Store) EnsureZombieGCSchema() error { var exists bool if err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='objects')`).Scan(&exists); err != nil || !exists { return err } statements := []string{ `CREATE TABLE IF NOT EXISTS zombie_gc_maintenance (singleton INTEGER PRIMARY KEY CHECK(singleton=1), grace_seconds INTEGER NOT NULL CHECK(grace_seconds>=86400))`, `INSERT OR IGNORE INTO zombie_gc_maintenance(singleton,grace_seconds) VALUES(1,86400)`, `CREATE INDEX IF NOT EXISTS idx_objects_zombie_age ON objects(created_at,uuid)`, `CREATE INDEX IF NOT EXISTS idx_object_origins_domain ON object_origins(domain_uuid,object_uuid)`, `CREATE INDEX IF NOT EXISTS idx_assets_object_uuid ON assets(object_uuid)`, `CREATE INDEX IF NOT EXISTS idx_tags_object_uuid ON tags(object_uuid)`, `CREATE INDEX IF NOT EXISTS idx_spot_pages_page ON spot_pages(page_uuid)`, `CREATE INDEX IF NOT EXISTS idx_street_inbox_page ON street_inbox_pages(page_uuid)`, `CREATE INDEX IF NOT EXISTS idx_city_page_overrides_page ON city_page_overrides(page_uuid)`, `CREATE INDEX IF NOT EXISTS idx_adapter_sessions_object ON adapter_sessions(object_uuid)`, `CREATE INDEX IF NOT EXISTS idx_auth_grants_object_target ON auth_capability_grants(target_type,target_id)`, } for _, statement := range statements { if _, err := s.DB.Exec(statement); err != nil { return err } } return nil } // RaiseZombieMaintenanceGrace is an instance-maintenance operation, not a // Domain setting. The persistent high-water mark cannot shorten old retention. func (s *Store) RaiseZombieMaintenanceGrace(ctx context.Context, graceSeconds int64) (int64, error) { if graceSeconds < 0 { return 0, ErrZombieGCOptions } ctx, cancel := context.WithTimeout(ctx, zombieGCTimeout) defer cancel() var grace int64 err := s.DB.QueryRowContext(ctx, `UPDATE zombie_gc_maintenance SET grace_seconds=MAX(grace_seconds,?) WHERE singleton=1 RETURNING grace_seconds`, graceSeconds).Scan(&grace) return grace, err } // This predicate intentionally examines all domains, all revisions (not merely // the head), and both inline bytes and CAS metadata. A nonempty inline body must // not be masked by a stale empty-document hash. Semantic references and active // editor sessions also protect deliberately empty documents. const zombieEligibility = ` NOT EXISTS(SELECT 1 FROM paths p WHERE p.object_uuid=o.uuid) AND NOT EXISTS(SELECT 1 FROM assets a WHERE a.object_uuid=o.uuid) AND NOT EXISTS(SELECT 1 FROM revisions r WHERE r.object_uuid=o.uuid AND ( COALESCE(r.document_hash,'') NOT IN ('','` + emptyDocumentSHA256 + `') OR length(CAST(COALESCE(r.body,'') AS BLOB)) > 0 OR EXISTS(SELECT 1 FROM revision_document_refs ref WHERE ref.revision_uuid=r.uuid))) AND NOT EXISTS(SELECT 1 FROM spot_pages sp WHERE sp.page_uuid=o.uuid) AND NOT EXISTS(SELECT 1 FROM street_inbox_pages ip WHERE ip.page_uuid=o.uuid) AND NOT EXISTS(SELECT 1 FROM city_page_overrides ov WHERE ov.page_uuid=o.uuid) AND NOT EXISTS(SELECT 1 FROM auth_capability_grants g WHERE g.target_type='object' AND g.target_id=o.uuid) AND NOT EXISTS(SELECT 1 FROM adapter_sessions ed WHERE ed.object_uuid=o.uuid AND MAX(ed.ticket_expires_at_ms,ed.session_expires_at_ms) > CAST(strftime('%s','now') AS INTEGER)*1000) ` func zombieOptions(graceSeconds int64, limit int) (int, error) { if graceSeconds < 0 || limit < 0 || limit > ZombieGCMaxLimit { return 0, ErrZombieGCOptions } if limit == 0 { limit = ZombieGCDefaultLimit } return limit, nil } type zombieQueryer interface { QueryContext(context.Context, string, ...any) (*sql.Rows, error) } func queryZombieObjects(ctx context.Context, q zombieQueryer, domainUUID string, cutoff int64, limit int) ([]ZombieObject, error) { query := `SELECT o.uuid,o.created_at,(SELECT COUNT(*) FROM revisions r WHERE r.object_uuid=o.uuid),0 ` args := []any{} if domainUUID != "" { // Start with the indexed Domain origins, not every other Domain's // objects. CROSS JOIN preserves that loop order even before ANALYZE. query += `FROM object_origins origin CROSS JOIN objects o ON o.uuid=origin.object_uuid WHERE origin.domain_uuid=? AND ` args = append(args, domainUUID) } else { query += `FROM objects o WHERE ` } query += `o.created_at < ? AND ` + zombieEligibility args = append(args, cutoff) query += ` ORDER BY o.created_at,o.uuid LIMIT ?` args = append(args, limit) rows, err := q.QueryContext(ctx, query, args...) if err != nil { return nil, err } defer rows.Close() out := []ZombieObject{} for rows.Next() { var z ZombieObject if err := rows.Scan(&z.UUID, &z.CreatedAt, &z.RevisionCount, &z.MaxBodyLength); err != nil { return nil, err } out = append(out, z) } return out, rows.Err() } // ListZombieObjects is reserved for trusted, instance-wide maintenance/CLI use. // HTTP callers must use ListZombieObjectsInDomain, including instance admins. func (s *Store) ListZombieObjects(graceSeconds int64) ([]ZombieObject, error) { return s.listZombieObjects(context.Background(), "", graceSeconds, ZombieGCMaxLimit) } func (s *Store) ListZombieObjectsInDomain(ctx context.Context, domainUUID string, graceSeconds int64, limit int) ([]ZombieObject, error) { if strings.TrimSpace(domainUUID) == "" { return nil, fmt.Errorf("%w: Domain required", ErrZombieGCOptions) } return s.listZombieObjects(ctx, domainUUID, graceSeconds, limit) } func (s *Store) listZombieObjects(ctx context.Context, domainUUID string, graceSeconds int64, limit int) ([]ZombieObject, error) { limit, err := zombieOptions(graceSeconds, limit) if err != nil { return nil, err } ctx, cancel := context.WithTimeout(ctx, zombieGCTimeout) defer cancel() return queryZombieObjects(ctx, s.DB, domainUUID, time.Now().Unix()-graceSeconds, limit) } // PurgeZombieObjects remains global only for trusted instance maintenance. func (s *Store) PurgeZombieObjects(graceSeconds int64, limit int) (int, error) { return s.purgeZombieObjects(context.Background(), "", graceSeconds, limit) } func (s *Store) PurgeZombieObjectsInDomain(ctx context.Context, domainUUID string, graceSeconds int64, limit int) (int, error) { if strings.TrimSpace(domainUUID) == "" { return 0, fmt.Errorf("%w: Domain required", ErrZombieGCOptions) } return s.purgeZombieObjects(ctx, domainUUID, graceSeconds, limit) } func (s *Store) purgeZombieObjects(ctx context.Context, domainUUID string, graceSeconds int64, limit int) (int, error) { limit, err := zombieOptions(graceSeconds, limit) if err != nil { return 0, err } ctx, cancel := context.WithTimeout(ctx, zombieGCTimeout) defer cancel() tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return 0, err } defer tx.Rollback() // Acquire SQLite's writer lock BEFORE reading any candidate. Other writers // cannot add a Path/Asset/revision between selection and deletion. result, err := tx.ExecContext(ctx, `UPDATE zombie_gc_maintenance SET grace_seconds=grace_seconds WHERE singleton=1`) if err != nil { return 0, err } if n, err := result.RowsAffected(); err != nil || n != 1 { return 0, errors.New("zombie GC maintenance lock is unavailable") } cutoff := time.Now().Unix() - graceSeconds zombies, err := queryZombieObjects(ctx, tx, domainUUID, cutoff, limit) if err != nil { return 0, err } deleted := 0 for _, z := range zombies { // Revalidate immediately before destructive work, within the write // transaction. A future selector refactor cannot make a stale list safe. query := `SELECT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=? AND o.created_at < ? AND ` + zombieEligibility args := []any{z.UUID, cutoff} if domainUUID != "" { query += ` AND EXISTS(SELECT 1 FROM object_origins origin WHERE origin.object_uuid=o.uuid AND origin.domain_uuid=?)` args = append(args, domainUUID) } var eligible bool if err := tx.QueryRowContext(ctx, query+`)`, args...).Scan(&eligible); err != nil { return 0, err } if !eligible { continue } // Foreign keys are not enabled on every legacy connection. Explicitly // clean dependent bookkeeping; revision triggers maintain the FTS index. for _, statement := range []string{ `DELETE FROM revision_document_refs WHERE revision_uuid IN (SELECT uuid FROM revisions WHERE object_uuid=?)`, `DELETE FROM tags WHERE object_uuid=?`, `DELETE FROM revisions WHERE object_uuid=?`, `DELETE FROM adapter_sessions WHERE object_uuid=?`, `DELETE FROM object_origins WHERE object_uuid=?`, `DELETE FROM objects WHERE uuid=?`, } { if _, err := tx.ExecContext(ctx, statement, z.UUID); err != nil { return 0, err } } deleted++ } if err := tx.Commit(); err != nil { return 0, err } return deleted, nil }