Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
68 changes: 68 additions & 0 deletions internal/api/api.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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)
}
39 changes: 39 additions & 0 deletions internal/db/settings.go
Original file line number Diff line number Diff line change
@@ -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
}
20 changes: 20 additions & 0 deletions internal/disk/disk.go
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
9 changes: 9 additions & 0 deletions internal/torrent/engine.go
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ type Engine struct {
mu sync.Mutex
byID map[int64]*liveTorrent
flushMu sync.Mutex
addMu sync.Mutex
done chan struct{}
}

Expand Down Expand Up @@ -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)
Expand All @@ -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 {
Expand Down
149 changes: 149 additions & 0 deletions internal/torrent/quota.go
Original file line number Diff line number Diff line change
@@ -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
}
Loading
Loading