Files
2026-11-15 05:47:14 +09:00

245 lines
9.5 KiB
Go

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 {
if !s.SupportsZombieGC() {
return ErrBackendFeatureUnavailable
}
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 !s.SupportsZombieGC() {
return 0, ErrBackendFeatureUnavailable
}
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) {
if !s.SupportsZombieGC() {
return nil, ErrBackendFeatureUnavailable
}
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) {
if !s.SupportsZombieGC() {
return 0, ErrBackendFeatureUnavailable
}
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
}