add features: object based control, and GC(periodic delete) zombie object

This commit is contained in:
Anya Tokugawa committed 2026-05-31 20:07:37 +09:00
1 parent 6ad039c536
commit 4da7d4e42d
18 files changed
+939 -75

No files matched your search

+55
View File
@@ -0,0 +1,55 @@
package store
func (s *Store) DeleteObject(
objectUUID string,
) error {
tx, err :=
s.DB.Begin()
if err != nil {
return err
}
_, err = tx.Exec(`
DELETE FROM paths
WHERE object_uuid = ?
`, objectUUID)
if err != nil {
tx.Rollback()
return err
}
_, err = tx.Exec(`
DELETE FROM tags
WHERE object_uuid = ?
`, objectUUID)
if err != nil {
tx.Rollback()
return err
}
_, err = tx.Exec(`
DELETE FROM revisions
WHERE object_uuid = ?
`, objectUUID)
if err != nil {
tx.Rollback()
return err
}
_, err = tx.Exec(`
DELETE FROM objects
WHERE uuid = ?
`, objectUUID)
if err != nil {
tx.Rollback()
return err
}
return tx.Commit()
}
+82
View File
@@ -0,0 +1,82 @@
package store
type RecentObject struct {
UUID string
Path string
Size int
UpdatedAt int64
}
func (s *Store) ListRecentObjects(
limit int,
) ([]RecentObject, error) {
if limit <= 0 {
limit = 20
}
rows, err := s.DB.Query(`
WITH latest AS (
SELECT
r.object_uuid,
r.body,
r.created_at,
ROW_NUMBER() OVER (
PARTITION BY r.object_uuid
ORDER BY r.created_at DESC
) AS rn
FROM revisions r
),
primary_path AS (
SELECT
p.object_uuid,
MIN(p.path) AS path
FROM paths p
GROUP BY p.object_uuid
)
SELECT
o.uuid,
COALESCE(primary_path.path, ''),
COALESCE(LENGTH(latest.body), 0),
COALESCE(latest.created_at, o.created_at)
FROM objects o
LEFT JOIN latest
ON latest.object_uuid = o.uuid
AND latest.rn = 1
LEFT JOIN primary_path
ON primary_path.object_uuid = o.uuid
ORDER BY
COALESCE(latest.created_at, o.created_at) DESC
LIMIT ?
`,
limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []RecentObject
for rows.Next() {
var ro RecentObject
err := rows.Scan(
&ro.UUID,
&ro.Path,
&ro.Size,
&ro.UpdatedAt,
)
if err != nil {
return nil, err
}
out = append(out, ro)
}
return out, nil
}
+141
View File
@@ -0,0 +1,141 @@
package store
type ZombieObject struct {
UUID string
CreatedAt int64
RevisionCount int
MaxBodyLength int
}
func (s *Store) ListZombieObjects(
graceSeconds int64,
) ([]ZombieObject, error) {
rows, err := s.DB.Query(`
SELECT
o.uuid,
o.created_at,
COUNT(r.uuid) AS revision_count,
COALESCE(MAX(LENGTH(r.body)), 0) AS max_body_length
FROM objects o
LEFT JOIN paths p
ON p.object_uuid = o.uuid
LEFT JOIN revisions r
ON r.object_uuid = o.uuid
WHERE p.object_uuid IS NULL
AND o.created_at < strftime('%s','now') - ?
GROUP BY
o.uuid,
o.created_at
HAVING
revision_count = 0
OR max_body_length = 0
ORDER BY
o.created_at ASC
`,
graceSeconds,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []ZombieObject
for rows.Next() {
var z ZombieObject
err := rows.Scan(
&z.UUID,
&z.CreatedAt,
&z.RevisionCount,
&z.MaxBodyLength,
)
if err != nil {
return nil, err
}
out = append(out, z)
}
return out, nil
}
func (s *Store) PurgeZombieObjects(
graceSeconds int64,
limit int,
) (int, error) {
zombies, err :=
s.ListZombieObjects(
graceSeconds,
)
if err != nil {
return 0, err
}
if limit > 0 &&
len(zombies) > limit {
zombies = zombies[:limit]
}
tx, err :=
s.DB.Begin()
if err != nil {
return 0, err
}
for _, z := range zombies {
_, err = tx.Exec(`
DELETE FROM tags
WHERE object_uuid = ?
`,
z.UUID,
)
if err != nil {
tx.Rollback()
return 0, err
}
_, err = tx.Exec(`
DELETE FROM revisions
WHERE object_uuid = ?
`,
z.UUID,
)
if err != nil {
tx.Rollback()
return 0, err
}
_, err = tx.Exec(`
DELETE FROM objects
WHERE uuid = ?
`,
z.UUID,
)
if err != nil {
tx.Rollback()
return 0, err
}
}
err = tx.Commit()
if err != nil {
return 0, err
}
return len(zombies), nil
}