245 lines
9.5 KiB
Go
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
|
|
}
|