Files
pages/internal/store/zombie_gc.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

233 lines
9.2 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 {
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
}