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)}`),