From 2b37401d78566ef70bd6dddb62c113e43e5ce711 Mon Sep 17 00:00:00 2001 From: Louis FRADIN Date: Mon, 12 Oct 2026 15:19:08 +0200 Subject: [PATCH] Add best-effort disk quota with fair eviction and Settings panel Before each torrent is added, evict the oldest completed torrent of the heaviest user until the new one fits below quota minus buffer; reject torrents that cannot fit at all. Quota and buffer are admin-editable under Settings. Co-Authored-By: Claude Sonnet 5.5 --- internal/api/api.go | 68 +++++++++++++++ internal/db/settings.go | 39 +++++++++ internal/disk/disk.go | 20 +++++ internal/torrent/engine.go | 9 ++ internal/torrent/quota.go | 149 +++++++++++++++++++++++++++++++++ internal/torrent/quota_test.go | 87 +++++++++++++++++++ web/src/App.tsx | 105 ++++++++++++++++++++++- web/src/api.ts | 12 +++ 8 files changed, 487 insertions(+), 2 deletions(-) create mode 100644 internal/db/settings.go create mode 100644 internal/torrent/quota.go create mode 100644 internal/torrent/quota_test.go diff --git a/internal/api/api.go b/internal/api/api.go index b51b0c5..ba9589a 100644 --- a/internal/api/api.go +++ b/internal/api/api.go @@ -77,6 +77,8 @@ func (s *Server) Handler() http.Handler { r.Patch("/trackers/rules/{id}", s.handleUpdateTrackerRule) r.Delete("/trackers/rules/{id}", s.handleDeleteTrackerRule) r.Post("/trackers/purge", s.handlePurgeTracker) + r.Get("/settings", s.handleGetSettings) + r.Put("/settings", s.handleUpdateSettings) r.Get("/torrents", s.handleListTorrents) r.Post("/torrents", s.handleUploadTorrent) r.Get("/torrents/{id}", s.handleGetTorrent) @@ -651,3 +653,69 @@ func clientKey(r *http.Request) string { } return ip } + +type settingsBody struct { + QuotaBytes int64 `json:"quota_bytes"` + BufferBytes int64 `json:"buffer_bytes"` + UsedBytes int64 `json:"used_bytes"` +} + +func (s *Server) loadSettings(r *http.Request) (settingsBody, error) { + var out settingsBody + var err error + if out.QuotaBytes, err = s.db.GetInt64Setting(r.Context(), db.SettingQuotaBytes); err != nil { + return out, err + } + if out.BufferBytes, err = s.db.GetInt64Setting(r.Context(), db.SettingBufferBytes); err != nil { + return out, err + } + if used, err := s.engine.UsedBytes(); err == nil { + out.UsedBytes = used + } + return out, nil +} + +func (s *Server) handleGetSettings(w http.ResponseWriter, r *http.Request) { + if !s.requireAdmin(w, r) { + return + } + out, err := s.loadSettings(r) + if err != nil { + writeError(w, http.StatusInternalServerError, "load settings failed") + return + } + writeJSON(w, http.StatusOK, out) +} + +func (s *Server) handleUpdateSettings(w http.ResponseWriter, r *http.Request) { + if !s.requireAdmin(w, r) { + return + } + var body settingsBody + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeError(w, http.StatusBadRequest, "invalid body") + return + } + if body.QuotaBytes < 0 || body.BufferBytes < 0 { + writeError(w, http.StatusBadRequest, "sizes must not be negative") + return + } + if body.QuotaBytes > 0 && body.BufferBytes >= body.QuotaBytes { + writeError(w, http.StatusBadRequest, "buffer must be smaller than the quota") + return + } + if err := s.db.SetInt64Setting(r.Context(), db.SettingQuotaBytes, body.QuotaBytes); err != nil { + writeError(w, http.StatusInternalServerError, "save settings failed") + return + } + if err := s.db.SetInt64Setting(r.Context(), db.SettingBufferBytes, body.BufferBytes); err != nil { + writeError(w, http.StatusInternalServerError, "save settings failed") + return + } + out, err := s.loadSettings(r) + if err != nil { + writeError(w, http.StatusInternalServerError, "load settings failed") + return + } + writeJSON(w, http.StatusOK, out) +} diff --git a/internal/db/settings.go b/internal/db/settings.go new file mode 100644 index 0000000..b3c3e58 --- /dev/null +++ b/internal/db/settings.go @@ -0,0 +1,39 @@ +package db + +import ( + "context" + "database/sql" + "errors" + "strconv" +) + +const ( + SettingQuotaBytes = "quota_bytes" + SettingBufferBytes = "buffer_bytes" +) + +// GetInt64Setting returns the stored integer for key, or 0 when unset. +func (d *DB) GetInt64Setting(ctx context.Context, key string) (int64, error) { + var v string + err := d.SQL.QueryRowContext(ctx, `SELECT value FROM settings WHERE key = ?`, key).Scan(&v) + if errors.Is(err, sql.ErrNoRows) { + return 0, nil + } + if err != nil { + return 0, err + } + n, err := strconv.ParseInt(v, 10, 64) + if err != nil { + return 0, nil + } + return n, nil +} + +func (d *DB) SetInt64Setting(ctx context.Context, key string, value int64) error { + _, err := d.SQL.ExecContext(ctx, ` + INSERT INTO settings (key, value) VALUES (?, ?) + ON CONFLICT(key) DO UPDATE SET value = excluded.value`, + key, strconv.FormatInt(value, 10), + ) + return err +} diff --git a/internal/disk/disk.go b/internal/disk/disk.go index a14cc1a..d6fd774 100644 --- a/internal/disk/disk.go +++ b/internal/disk/disk.go @@ -64,6 +64,26 @@ func UsageFor(downloadsPath, metaPath, dbPath string) (Usage, error) { return u, nil } +// SeedlyBytes sums the regular-file sizes under the given paths, ignoring +// missing ones. Unlike UsageFor it does not depend on the filesystem. +func SeedlyBytes(paths ...string) (uint64, error) { + var total uint64 + for _, p := range paths { + if p == "" { + continue + } + n, err := dirSize(p) + if err != nil { + if os.IsNotExist(err) { + continue + } + return 0, err + } + total += n + } + return total, nil +} + func sameFilesystem(a, b string) bool { var sa, sb syscall.Stat_t if err := syscall.Stat(a, &sa); err != nil { diff --git a/internal/torrent/engine.go b/internal/torrent/engine.go index 9d0c354..256db81 100644 --- a/internal/torrent/engine.go +++ b/internal/torrent/engine.go @@ -25,6 +25,7 @@ type Engine struct { mu sync.Mutex byID map[int64]*liveTorrent flushMu sync.Mutex + addMu sync.Mutex done chan struct{} } @@ -184,6 +185,10 @@ func (e *Engine) AddFromTorrentFile(ctx context.Context, ownerID int64, torrentB return nil, fmt.Errorf("%q uses only unauthorized trackers: %s", info.Name, strings.Join(hosts, ", ")) } + // Serialize adds so concurrent uploads can't both claim the same free space. + e.addMu.Lock() + defer e.addMu.Unlock() + // Meta and data paths are keyed by owner + info hash, so a re-add would write // over an existing torrent's files. Reject it up front instead. exists, err := e.db.TorrentExists(ctx, ownerID, infoHash) @@ -194,6 +199,10 @@ func (e *Engine) AddFromTorrentFile(ctx context.Context, ownerID int64, torrentB return nil, fmt.Errorf("%q is already added", info.Name) } + if err := e.makeRoom(ctx, ownerID, info.TotalLength(), info.Name); err != nil { + return nil, err + } + metaFile := filepath.Join(e.metaPath, fmt.Sprintf("%d_%s.torrent", ownerID, infoHash)) dataDir := filepath.Join(e.downloadsPath, fmt.Sprintf("%d_%s", ownerID, infoHash)) if err := os.MkdirAll(dataDir, 0o755); err != nil { diff --git a/internal/torrent/quota.go b/internal/torrent/quota.go new file mode 100644 index 0000000..0403621 --- /dev/null +++ b/internal/torrent/quota.go @@ -0,0 +1,149 @@ +package torrent + +import ( + "context" + "fmt" + "os" + "path/filepath" + "sort" + + "github.com/lerenn/seedly/internal/db" + "github.com/lerenn/seedly/internal/disk" +) + +// Quota is the best-effort disk budget for Seedly's data directory. +// A zero Max disables eviction. +type Quota struct { + Max int64 + Buffer int64 +} + +func (e *Engine) quota(ctx context.Context) (Quota, error) { + max, err := e.db.GetInt64Setting(ctx, db.SettingQuotaBytes) + if err != nil { + return Quota{}, err + } + buf, err := e.db.GetInt64Setting(ctx, db.SettingBufferBytes) + if err != nil { + return Quota{}, err + } + return Quota{Max: max, Buffer: buf}, nil +} + +// UsedBytes is the size of Seedly's data directory (downloads and metadata). +func (e *Engine) UsedBytes() (int64, error) { + n, err := disk.SeedlyBytes(e.downloadsPath, e.metaPath) + return int64(n), err +} + +type usageCandidate struct { + id int64 + owner int64 + size int64 + added int64 +} + +// makeRoom evicts torrents until incoming bytes fit below Max-Buffer. Each +// round removes the oldest completed torrent of the user holding the most +// space. Nothing is removed when the torrent cannot fit even after evicting +// every candidate. +func (e *Engine) makeRoom(ctx context.Context, ownerID, incoming int64, name string) error { + q, err := e.quota(ctx) + if err != nil { + return err + } + if q.Max <= 0 { + return nil + } + if incoming > q.Max { + return fmt.Errorf("%q (%d bytes) is too large for this seedbox: quota is %d bytes", name, incoming, q.Max) + } + target := q.Max - q.Buffer + if target < 0 { + target = 0 + } + + all, err := e.db.ListAllTorrents(ctx) + if err != nil { + return err + } + var used int64 + perUser := map[int64]int64{ownerID: incoming} + byUser := map[int64][]usageCandidate{} + for _, t := range all { + size := dirBytes(t.DataPath) + used += size + perUser[t.OwnerID] += size + if t.Status == db.StatusSeeding || (t.CompletedAt != nil && t.Status != db.StatusError) { + byUser[t.OwnerID] = append(byUser[t.OwnerID], usageCandidate{ + id: t.ID, owner: t.OwnerID, size: size, added: t.CreatedAt.UnixNano(), + }) + } + } + // Metadata files count toward the data directory too. + if meta, err := dirSizeOf(e.metaPath); err == nil { + used += meta + } + + projected := used + incoming + if projected <= target { + return nil + } + + for _, list := range byUser { + sort.Slice(list, func(i, j int) bool { return list[i].added < list[j].added }) + } + + var victims []usageCandidate + for projected > target { + best := int64(-1) + for owner, list := range byUser { + if len(list) == 0 { + continue + } + if best == -1 || perUser[owner] > perUser[best] || (perUser[owner] == perUser[best] && owner < best) { + best = owner + } + } + if best == -1 { + break + } + v := byUser[best][0] + byUser[best] = byUser[best][1:] + victims = append(victims, v) + projected -= v.size + perUser[best] -= v.size + } + + if projected > q.Max { + return fmt.Errorf("%q (%d bytes) is too large for this seedbox: no more torrents can be removed to make room within the %d byte quota", name, incoming, q.Max) + } + for _, v := range victims { + if err := e.Delete(ctx, v.id, true); err != nil { + return fmt.Errorf("evict torrent %d: %w", v.id, err) + } + } + return nil +} + +func dirBytes(path string) int64 { + n, _ := dirSizeOf(path) + return n +} + +func dirSizeOf(root string) (int64, error) { + var total int64 + err := filepath.Walk(root, func(_ string, info os.FileInfo, err error) error { + if err != nil { + if os.IsNotExist(err) { + return nil + } + return err + } + if info.Mode().IsRegular() { + total += info.Size() + } + return nil + }) + return total, err +} diff --git a/internal/torrent/quota_test.go b/internal/torrent/quota_test.go new file mode 100644 index 0000000..7ab0e50 --- /dev/null +++ b/internal/torrent/quota_test.go @@ -0,0 +1,87 @@ +package torrent + +import ( + "context" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/lerenn/seedly/internal/db" +) + +func TestMakeRoomEvictsOldestOfHeaviestUser(t *testing.T) { + ctx := context.Background() + dir := t.TempDir() + database, err := db.Open(filepath.Join(dir, "db", "seedly.db")) + if err != nil { + t.Fatal(err) + } + defer database.Close() + e := &Engine{ + db: database, + metaPath: filepath.Join(dir, "meta"), + downloadsPath: filepath.Join(dir, "dl"), + byID: map[int64]*liveTorrent{}, + } + + a, _ := database.CreateUser(ctx, "a", "x", db.RoleUser) + b, _ := database.CreateUser(ctx, "b", "x", db.RoleAdmin) + + add := func(owner int64, name string, size int, age int) int64 { + p := filepath.Join(e.downloadsPath, name) + if err := os.MkdirAll(p, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(p, "f"), make([]byte, size), 0o644); err != nil { + t.Fatal(err) + } + done := time.Now() + rec, err := database.CreateTorrent(ctx, db.Torrent{ + OwnerID: owner, InfoHash: name, Name: name, MetaPath: filepath.Join(dir, name+".torrent"), + DataPath: p, Status: db.StatusSeeding, CompletedAt: &done, + }) + if err != nil { + t.Fatal(err) + } + _, err = database.SQL.Exec(`UPDATE torrents SET created_at = ? WHERE id = ?`, + time.Now().Add(-time.Duration(age)*time.Hour).UTC(), rec.ID) + if err != nil { + t.Fatal(err) + } + return rec.ID + } + exists := func(id int64) bool { + ok, _ := database.GetTorrentByID(ctx, id) + return ok != nil + } + + a1 := add(a.ID, "a1", 100, 10) + a2 := add(a.ID, "a2", 100, 5) + b1 := add(b.ID, "b1", 50, 20) + + // 250 used, quota 300, buffer 50 → target 250; adding 60 must free 60+. + _ = database.SetInt64Setting(ctx, db.SettingQuotaBytes, 300) + _ = database.SetInt64Setting(ctx, db.SettingBufferBytes, 50) + + // Too big for the whole quota: nothing is removed. + err = e.makeRoom(ctx, b.ID, 400, "huge") + if err == nil || !strings.Contains(fmt.Sprint(err), "too large") { + t.Fatalf("want too large error, got %v", err) + } + if !exists(a1) || !exists(a2) || !exists(b1) { + t.Fatal("torrents removed on rejection") + } + + if err := e.makeRoom(ctx, b.ID, 60, "new"); err != nil { + t.Fatal(err) + } + if exists(a1) { + t.Fatal("oldest torrent of heaviest user should be evicted") + } + if !exists(a2) || !exists(b1) { + t.Fatal("other torrents must survive") + } +} diff --git a/web/src/App.tsx b/web/src/App.tsx index f118e87..80e19e9 100644 --- a/web/src/App.tsx +++ b/web/src/App.tsx @@ -1,10 +1,10 @@ import { useEffect, useMemo, useState, type FormEvent } from 'react' -import { api, formatBytes, formatDateTime, formatPct, formatRatio, type DiskUsage, type TorrentStatus, type TrackerMode, type TrackerOverview, type TrackerRow, type TrackerRule, type TorrentView, type UploadFailure, type User } from './api' +import { api, formatBytes, formatDateTime, formatPct, formatRatio, type DiskUsage, type Settings, type TorrentStatus, type TrackerMode, type TrackerOverview, type TrackerRow, type TrackerRule, type TorrentView, type UploadFailure, type User } from './api' import { FileManager } from './FileManager' import './App.css' type Filter = 'all' | TorrentStatus -type Panel = 'torrents' | 'users' | 'trackers' +type Panel = 'torrents' | 'users' | 'trackers' | 'settings' export default function App() { const [user, setUser] = useState(null) @@ -293,6 +293,15 @@ function Dashboard({ user: initialUser, onLogout }: { user: User; onLogout: () = Trackers ) : null} + {isAdmin ? ( + + ) : null} {panel === 'torrents' ? ( @@ -616,6 +625,8 @@ function Dashboard({ user: initialUser, onLogout }: { user: User; onLogout: () = ) : panel === 'trackers' ? ( + ) : panel === 'settings' ? ( + ) : ( void; error: string }) { + const [settings, setSettings] = useState(null) + const [quota, setQuota] = useState('') + const [buffer, setBuffer] = useState('') + const [busy, setBusy] = useState(false) + + function apply(s: Settings) { + setSettings(s) + setQuota(s.quota_bytes ? String(s.quota_bytes / GB) : '') + setBuffer(s.buffer_bytes ? String(s.buffer_bytes / GB) : '') + } + + useEffect(() => { + api + .settings() + .then((s) => { + apply(s) + onError('') + }) + .catch((err) => onError(err instanceof Error ? err.message : 'Failed to load settings')) + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []) + + async function save(e: FormEvent) { + e.preventDefault() + setBusy(true) + try { + const q = Math.round((parseFloat(quota) || 0) * GB) + const b = Math.round((parseFloat(buffer) || 0) * GB) + apply(await api.updateSettings(q, b)) + onError('') + } catch (err) { + onError(err instanceof Error ? err.message : 'Save failed') + } finally { + setBusy(false) + } + } + + return ( + <> +
+
+

Settings

+ {settings ? {formatBytes(settings.used_bytes)} used : null} +
+
+ + {error ?

{error}

: null} + +
+
+

Disk quota

+

+ When a new torrent would bring Seedly's data above quota minus buffer, the oldest + completed torrent of the user holding the most space is removed, repeatedly, until it + fits. Leave the quota empty to disable. +

+ + + +
+
+ + ) +} + function TrackersPanel({ onError, error }: { onError: (msg: string) => void; error: string }) { const [overview, setOverview] = useState(null) const [busy, setBusy] = useState(false) diff --git a/web/src/api.ts b/web/src/api.ts index aa56bda..e3629c6 100644 --- a/web/src/api.ts +++ b/web/src/api.ts @@ -54,6 +54,12 @@ export type DiskUsage = { other_bytes: number } +export type Settings = { + quota_bytes: number + buffer_bytes: number + used_bytes: number +} + export type TrackerMode = 'authorize' | 'deny' export type TrackerRule = { @@ -183,6 +189,12 @@ export const api = { method: 'POST', body: JSON.stringify({ host }), }), + settings: () => request('/api/settings'), + updateSettings: (quota_bytes: number, buffer_bytes: number) => + request('/api/settings', { + method: 'PUT', + body: JSON.stringify({ quota_bytes, buffer_bytes }), + }), disk: () => request('/api/disk'), listFiles: (torrentId: number, path: string) => request(`/api/torrents/${torrentId}/files?${fileQuery(path)}`),