Приём: гард дедуп-дозаписи хешей (F1) и апгрейд catched-magnet до torrent (F6)
Два дефекта дедуп-веток приёма (ревью Fable 2026-07-08), оба про инвариант
«≤1 активная загрузка на infohash» и сохранность источника.
F1: дедуп-ветка CreateDownloadIfNoActive дописывала все хеши входящего
источника в найденную активную задачу без пер-хеш гарда владения (в отличие
от AddInfohashes). Гибрид {v1,v2}, дедупнувшись на задачу B (владелец v2),
крал v1 у активной A → две активные владели v1. Теперь дозапись под тем же
гардом: хеш, которым владеет другая активная задача, не дописывается.
F6: при дедупе .torrent-байт на пойманную magnet-задачу (catched) байты
выбрасывались, source_type оставался magnet → worker добавлял по magnet-URL →
вечный metaDL → failed (magnet закрытого трекера без DHT метаданные не
докачает). Новый guarded-метод UpgradeCatchedMagnetToTorrent атомарно
сохраняет байты и меняет source_type magnet→torrent, но только пока задача в
catched (worker источник ещё не отдал). Ingest зовёт апгрейд на обоих
дедуп-путях. Это целевое исключение из правила спеки «при дедупе байты не
сохраняем» — оформлено MODIFIED-дельтой ingest.
Схема БД не меняется (download_torrent и source_type уже есть).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
@@ -35,6 +35,11 @@ type Store interface {
|
||||
// AddInfohashes доносит задаче недостающие хеши (guarded). Нужен на
|
||||
// быстром дедуп-пути, который не доходит до CreateDownloadIfNoActive.
|
||||
AddInfohashes(ctx context.Context, downloadID string, hashes []string) error
|
||||
// UpgradeCatchedMagnetToTorrent при дедупе входящих байтов `.torrent` на
|
||||
// пойманную (`catched`) magnet-задачу сохраняет байты и меняет source_type
|
||||
// на torrent (атомарно). No-op, если задача уже добавлена/не magnet. Чинит
|
||||
// magnet закрытого трекера, который иначе застрянет в metaDL.
|
||||
UpgradeCatchedMagnetToTorrent(ctx context.Context, downloadID string, torrentBlob []byte) (bool, error)
|
||||
}
|
||||
|
||||
// Service — реализация быстрого приёма.
|
||||
@@ -109,14 +114,9 @@ func (s *Service) Ingest(ctx context.Context, req Request) (Result, error) {
|
||||
if existing != nil {
|
||||
// Гонка с параллельным приёмом/discover: активная задача появилась
|
||||
// после быстрого чека — присоединяемся к ней (хеши донёс сам
|
||||
// CreateDownloadIfNoActive).
|
||||
// CreateDownloadIfNoActive; existing уже с подгруженными хешами).
|
||||
log.Info("download attached to active", "download_id", existing.ID, "state", existing.State)
|
||||
return Result{
|
||||
DownloadID: existing.ID,
|
||||
Infohashes: src.infohashes,
|
||||
State: existing.State,
|
||||
Deduplicated: true,
|
||||
}, nil
|
||||
return s.attached(ctx, src, existing), nil
|
||||
}
|
||||
|
||||
log.Info("download catched", "download_id", d.ID)
|
||||
@@ -208,6 +208,17 @@ func (s *Service) attached(ctx context.Context, src parsedSource, existing *stor
|
||||
logctx.FromOr(ctx, s.log).Warn("ingest top-up infohashes failed", "error", err)
|
||||
}
|
||||
}
|
||||
// F6: входящее — байты `.torrent`, а активная задача поймана как magnet и
|
||||
// ещё не отдана в qBittorrent (catched) → сохраняем байты и переключаем
|
||||
// источник на torrent, чтобы воркер добавил раздачу файлом (magnet
|
||||
// закрытого трекера иначе застрянет в metaDL). Best-effort: не валит приём.
|
||||
if src.sourceType == store.SourceTorrent && len(src.torrentBlob) > 0 {
|
||||
if upgraded, err := s.store.UpgradeCatchedMagnetToTorrent(ctx, existing.ID, src.torrentBlob); err != nil {
|
||||
logctx.FromOr(ctx, s.log).Warn("ingest torrent upgrade failed", "error", err)
|
||||
} else if upgraded {
|
||||
logctx.FromOr(ctx, s.log).Info("catched magnet upgraded to torrent", "download_id", existing.ID)
|
||||
}
|
||||
}
|
||||
return Result{
|
||||
DownloadID: existing.ID,
|
||||
Infohashes: src.infohashes,
|
||||
|
||||
@@ -16,11 +16,14 @@ const sampleMagnet = "magnet:?xt=urn:btih:541ADCFF3B6DD5DBA7088EA83317D9D6FAC331
|
||||
const sampleInfohash = "541adcff3b6dd5dba7088ea83317d9d6fac331d6"
|
||||
|
||||
type fakeStore struct {
|
||||
active *store.Download
|
||||
created []store.Download
|
||||
hashes [][]string
|
||||
blobs [][]byte
|
||||
toppedUp []string
|
||||
active *store.Download
|
||||
created []store.Download
|
||||
hashes [][]string
|
||||
blobs [][]byte
|
||||
toppedUp []string
|
||||
upgradeID string // downloadID последнего вызова UpgradeCatchedMagnetToTorrent
|
||||
upgradeBlob []byte // байты, переданные в апгрейд
|
||||
upgradeUp bool // что вернуть из UpgradeCatchedMagnetToTorrent
|
||||
}
|
||||
|
||||
func (f *fakeStore) FindActiveByInfohash(_ context.Context, _ ...string) (*store.Download, error) {
|
||||
@@ -44,6 +47,12 @@ func (f *fakeStore) AddInfohashes(_ context.Context, id string, hashes []string)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *fakeStore) UpgradeCatchedMagnetToTorrent(_ context.Context, id string, blob []byte) (bool, error) {
|
||||
f.upgradeID = id
|
||||
f.upgradeBlob = blob
|
||||
return f.upgradeUp, nil
|
||||
}
|
||||
|
||||
func newService(st Store) *Service {
|
||||
return New(st, slog.New(slog.NewTextHandler(io.Discard, nil)))
|
||||
}
|
||||
|
||||
@@ -83,6 +83,45 @@ func TestIngestTorrentDedupNoBlob(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// F6: дедуп .torrent на пойманную (catched) magnet-задачу вызывает апгрейд —
|
||||
// сохранение байтов и смену источника (magnet закрытого трекера иначе застрянет
|
||||
// в metaDL).
|
||||
func TestIngestTorrentUpgradesCatchedMagnet(t *testing.T) {
|
||||
data, hash := buildTorrent(t, "Dune", "http://t/ann")
|
||||
existing := &store.Download{
|
||||
ID: "cm",
|
||||
State: store.StateCatched,
|
||||
SourceType: store.SourceMagnet,
|
||||
Infohashes: []store.Infohash{{Infohash: hash, Kind: store.HashV1}},
|
||||
}
|
||||
fs := &fakeStore{active: existing, upgradeUp: true}
|
||||
res, err := newService(fs).Ingest(context.Background(), Request{TorrentData: data})
|
||||
if err != nil {
|
||||
t.Fatalf("Ingest: %v", err)
|
||||
}
|
||||
if !res.Deduplicated || res.DownloadID != "cm" {
|
||||
t.Errorf("ожидался дедуп на cm, res = %+v", res)
|
||||
}
|
||||
if fs.upgradeID != "cm" {
|
||||
t.Errorf("апгрейд не вызван для существующей задачи (upgradeID=%q)", fs.upgradeID)
|
||||
}
|
||||
if !bytes.Equal(fs.upgradeBlob, data) {
|
||||
t.Errorf("в апгрейд переданы не те байты")
|
||||
}
|
||||
}
|
||||
|
||||
// Дедуп magnet-ссылки (не .torrent) апгрейд не вызывает — нечего сохранять.
|
||||
func TestIngestMagnetDedupNoUpgrade(t *testing.T) {
|
||||
existing := &store.Download{ID: "cm", State: store.StateCatched, SourceType: store.SourceMagnet}
|
||||
fs := &fakeStore{active: existing}
|
||||
if _, err := newService(fs).Ingest(context.Background(), Request{Source: sampleMagnet}); err != nil {
|
||||
t.Fatalf("Ingest: %v", err)
|
||||
}
|
||||
if fs.upgradeID != "" {
|
||||
t.Errorf("апгрейд не должен вызываться для magnet-дедупа")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIngestTorrentTooLarge(t *testing.T) {
|
||||
fs := &fakeStore{}
|
||||
big := make([]byte, MaxTorrentSize+1)
|
||||
|
||||
@@ -272,8 +272,18 @@ func (s *Store) CreateDownloadIfNoActive(ctx context.Context, d *Download, hashe
|
||||
// Дедуп нашёл активного владельца по одному из хешей — остальные хеши
|
||||
// norm принадлежат тому же торренту (гибридный magnet): дописываем
|
||||
// недостающие, иначе второй хеш молча теряется и последующий приём по
|
||||
// нему создал бы вторую активную задачу.
|
||||
// нему создал бы вторую активную задачу. Дозапись — под тем же пер-хеш
|
||||
// гардом владения, что и AddInfohashes: хеш, которым владеет ДРУГАЯ
|
||||
// активная задача (split-identity/крафт-магнет), не дописываем, иначе
|
||||
// две активные владели бы одним инфохэшем (нарушение инварианта).
|
||||
for _, h := range norm {
|
||||
owner, err := findActiveByInfohash(ctx, tx, []string{h}, existing.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create download: %w", err)
|
||||
}
|
||||
if owner != nil {
|
||||
continue // чужой активный владелец — не крадём хеш
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
`INSERT OR IGNORE INTO download_infohash (download_id, infohash, kind, created_at) VALUES (?, ?, ?, ?)`,
|
||||
existing.ID, h, HashKind(h), now); err != nil {
|
||||
@@ -335,6 +345,57 @@ func (s *Store) GetTorrentData(ctx context.Context, downloadID string) ([]byte,
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// UpgradeCatchedMagnetToTorrent апгрейдит пойманную magnet-задачу до torrent
|
||||
// при дедупе входящих байтов `.torrent`: в одной write-транзакции сохраняет
|
||||
// байты и меняет source_type magnet→torrent, но ТОЛЬКО пока задача в `catched`
|
||||
// (воркер источник ещё не отдал в qBittorrent) и её source_type всё ещё
|
||||
// `magnet`. Это целевое исключение из правила «при дедупе байты не сохраняем»:
|
||||
// magnet на закрытом трекере без DHT метаданные не докачает и застрянет в
|
||||
// metaDL, а поданный пользователем `.torrent` их несёт. Возвращает true, если
|
||||
// апгрейд применён; (false, nil) — если задача не подходит (уже добавлена,
|
||||
// отменена или не magnet) либо байты пусты (защитный no-op). Гард через
|
||||
// RowsAffected UPDATE — та же ре-валидация состояния, что у PromoteCatched.
|
||||
func (s *Store) UpgradeCatchedMagnetToTorrent(ctx context.Context, downloadID string, torrentBlob []byte) (bool, error) {
|
||||
if len(torrentBlob) == 0 {
|
||||
return false, nil
|
||||
}
|
||||
tx, err := s.DB.BeginTxx(ctx, nil)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: begin tx: %w", downloadID, err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback() }()
|
||||
|
||||
res, err := tx.ExecContext(ctx, `
|
||||
UPDATE download
|
||||
SET source_type = ?, updated_at = ?
|
||||
WHERE id = ? AND source_type = ? AND state = ?`,
|
||||
string(SourceTorrent), FormatTime(Now()), downloadID, string(SourceMagnet), string(StateCatched))
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: %w", downloadID, err)
|
||||
}
|
||||
n, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: %w", downloadID, err)
|
||||
}
|
||||
if n == 0 {
|
||||
// Не catched-magnet (уже добавлена/отменена/torrent) — апгрейд не нужен.
|
||||
if err := tx.Commit(); err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: commit: %w", downloadID, err)
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
// У magnet-задачи блоба не было; OR REPLACE — страховка идемпотентности.
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
`INSERT OR REPLACE INTO download_torrent (download_id, data) VALUES (?, ?)`,
|
||||
downloadID, torrentBlob); err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: store blob: %w", downloadID, err)
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
return false, fmt.Errorf("upgrade %s to torrent: commit: %w", downloadID, err)
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// ActivateIfNoOtherActive атомарно возвращает загрузку в активное состояние
|
||||
// (retry/восстановление сверкой/relink): в одной write-транзакции проверяет,
|
||||
// что никакая ДРУГАЯ активная загрузка не владеет любым из хешей этой, и
|
||||
|
||||
@@ -3,6 +3,7 @@ package store
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
@@ -167,6 +168,50 @@ func TestFindActiveByInfohash(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// F1: дедуп-ветка CreateDownloadIfNoActive доносит недостающие хеши под пер-хеш
|
||||
// гардом владения — хеш, которым владеет ДРУГАЯ активная задача (split-identity
|
||||
// гибрида), красть не должна, иначе две активные владели бы одним инфохэшем.
|
||||
func TestDedupTopUpDoesNotStealForeignHash(t *testing.T) {
|
||||
st := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
v1 := hashN(1)
|
||||
v2 := hashN(2)
|
||||
|
||||
// A владеет v1, B владеет v2 — две активные задачи одного гибрида (split).
|
||||
idA := mustCreate(t, st, v1)
|
||||
idB := mustCreate(t, st, v2)
|
||||
|
||||
// Приём гибрида {v1, v2} → дедуп на одну из активных; чужой хеш не крадём.
|
||||
existing, err := st.CreateDownloadIfNoActive(ctx, newDownloading(), []string{v1, v2}, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
if existing == nil {
|
||||
t.Fatal("ожидался дедуп на активную задачу")
|
||||
}
|
||||
|
||||
assertHashes(t, st, idA, v1) // A по-прежнему владеет только v1
|
||||
assertHashes(t, st, idB, v2) // B по-прежнему владеет только v2
|
||||
}
|
||||
|
||||
// assertHashes проверяет точный набор инфохэшей загрузки.
|
||||
func assertHashes(t *testing.T, st *Store, id string, want ...string) {
|
||||
t.Helper()
|
||||
d, err := st.GetDownload(context.Background(), id)
|
||||
if err != nil {
|
||||
t.Fatalf("get %s: %v", id, err)
|
||||
}
|
||||
got := d.HashList()
|
||||
if len(got) != len(want) {
|
||||
t.Fatalf("%s hashes = %v, want %v", id, got, want)
|
||||
}
|
||||
for _, w := range want {
|
||||
if !slices.Contains(got, w) {
|
||||
t.Fatalf("%s hashes = %v, want содержит %s", id, got, w)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Состояния рассинхрона (target_missing/orphaned/deleted) терминальны: задача
|
||||
// в них не должна считаться «активной» (иначе relink/ingest-дедуп решат, что
|
||||
// для infohash уже есть активная задача). Регрессия: FindActiveByInfohash и
|
||||
|
||||
@@ -65,3 +65,110 @@ func TestTorrentBlobMissing(t *testing.T) {
|
||||
t.Errorf("ожидался ErrNotFound, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// F6: апгрейд пойманного magnet до torrent сохраняет байты и меняет source_type.
|
||||
func TestUpgradeCatchedMagnetToTorrent(t *testing.T) {
|
||||
st := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
d := &Download{SourceType: SourceMagnet, SourceRef: "magnet:?xt=urn:btih:" + hashN(1), State: StateCatched}
|
||||
if _, err := st.CreateDownloadIfNoActive(ctx, d, []string{hashN(1)}, nil); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
blob := []byte("d8:announce…real torrent")
|
||||
upgraded, err := st.UpgradeCatchedMagnetToTorrent(ctx, d.ID, blob)
|
||||
if err != nil || !upgraded {
|
||||
t.Fatalf("upgrade: upgraded=%v err=%v", upgraded, err)
|
||||
}
|
||||
|
||||
got, err := st.GetDownload(ctx, d.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if got.SourceType != SourceTorrent {
|
||||
t.Errorf("source_type = %q, want torrent", got.SourceType)
|
||||
}
|
||||
data, err := st.GetTorrentData(ctx, d.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get torrent data: %v", err)
|
||||
}
|
||||
if string(data) != string(blob) {
|
||||
t.Errorf("blob = %q, want %q", data, blob)
|
||||
}
|
||||
}
|
||||
|
||||
// Апгрейд применим только в catched: уже добавленный (downloading) magnet не
|
||||
// трогаем — его судьба решается retry/сверкой, а не приёмом.
|
||||
func TestUpgradeSkippedWhenNotCatched(t *testing.T) {
|
||||
st := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
d := &Download{SourceType: SourceMagnet, SourceRef: "m", State: StateDownloading}
|
||||
if _, err := st.CreateDownloadIfNoActive(ctx, d, []string{hashN(2)}, nil); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
upgraded, err := st.UpgradeCatchedMagnetToTorrent(ctx, d.ID, []byte("bytes"))
|
||||
if err != nil {
|
||||
t.Fatalf("upgrade: %v", err)
|
||||
}
|
||||
if upgraded {
|
||||
t.Error("downloading-magnet апгрейдить не должны")
|
||||
}
|
||||
got, err := st.GetDownload(ctx, d.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if got.SourceType != SourceMagnet {
|
||||
t.Errorf("source_type сменился на %q, а не должен", got.SourceType)
|
||||
}
|
||||
if _, err := st.GetTorrentData(ctx, d.ID); !errors.Is(err, ErrNotFound) {
|
||||
t.Errorf("байты не должны сохраняться, got err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Не-magnet источник апгрейд не трогает (гард source_type=magnet), байты не
|
||||
// перезаписывает.
|
||||
func TestUpgradeSkippedForTorrentSource(t *testing.T) {
|
||||
st := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
d := &Download{SourceType: SourceTorrent, SourceRef: "Rel", State: StateCatched}
|
||||
if _, err := st.CreateDownloadIfNoActive(ctx, d, []string{hashN(3)}, []byte("orig")); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
upgraded, err := st.UpgradeCatchedMagnetToTorrent(ctx, d.ID, []byte("new"))
|
||||
if err != nil {
|
||||
t.Fatalf("upgrade: %v", err)
|
||||
}
|
||||
if upgraded {
|
||||
t.Error("torrent-источник апгрейдить не нужно")
|
||||
}
|
||||
data, err := st.GetTorrentData(ctx, d.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get torrent data: %v", err)
|
||||
}
|
||||
if string(data) != "orig" {
|
||||
t.Errorf("байты перезаписаны: %q", data)
|
||||
}
|
||||
}
|
||||
|
||||
// Пустые байты — защитный no-op.
|
||||
func TestUpgradeEmptyBlobNoOp(t *testing.T) {
|
||||
st := newTestStore(t)
|
||||
ctx := context.Background()
|
||||
d := &Download{SourceType: SourceMagnet, SourceRef: "m", State: StateCatched}
|
||||
if _, err := st.CreateDownloadIfNoActive(ctx, d, []string{hashN(4)}, nil); err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
upgraded, err := st.UpgradeCatchedMagnetToTorrent(ctx, d.ID, nil)
|
||||
if err != nil || upgraded {
|
||||
t.Fatalf("пустой блоб: upgraded=%v err=%v", upgraded, err)
|
||||
}
|
||||
got, err := st.GetDownload(ctx, d.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if got.SourceType != SourceMagnet {
|
||||
t.Errorf("source_type сменился на %q при пустом блобе", got.SourceType)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
schema: spec-driven
|
||||
created: 2026-07-08
|
||||
@@ -0,0 +1,79 @@
|
||||
## Context
|
||||
|
||||
Приём дедуплицирует входящий источник по активной задаче двумя путями:
|
||||
|
||||
1. **Быстрый чек** — `Ingest` вызывает `FindActiveByInfohash`, при попадании
|
||||
уходит в `attached()` (дозапись недостающих хешей через `AddInfohashes`).
|
||||
Это основной путь.
|
||||
2. **Гонка** — быстрый чек пуст, но пока выводили имя/готовили запись,
|
||||
активная задача появилась; `CreateDownloadIfNoActive` внутри своей
|
||||
транзакции находит её и возвращает как дедуп (дозапись хешей внутри той же
|
||||
tx).
|
||||
|
||||
F1 живёт в пути 2 (неохраняемая дозапись). F6 задевает ОБА пути: в реальном
|
||||
сценарии первым отрабатывает быстрый чек (путь 1), поэтому апгрейд обязан
|
||||
работать и там.
|
||||
|
||||
## F1 — пер-хеш гард дозаписи в дедуп-ветке
|
||||
|
||||
**Решение.** В дедуп-ветке `CreateDownloadIfNoActive` заменяем безусловный
|
||||
цикл `INSERT OR IGNORE` на тот же гард, что в `AddInfohashes`: для каждого
|
||||
хеша `h` проверяем `findActiveByInfohash(ctx, tx, {h}, existing.ID)`; если
|
||||
другая активная задача владеет `h` — пропускаем (не дописываем), иначе
|
||||
`INSERT OR IGNORE`. Транзакция уже открыта, `excludeID = existing.ID`
|
||||
исключает саму дедуп-цель (её собственные хеши не конфликтуют с ней самой).
|
||||
|
||||
**Почему пропуск, а не ошибка.** Дедуп по контракту не падает — возвращает
|
||||
существующую задачу. Конфликтный хеш принадлежит другой активной задаче;
|
||||
молча его не трогаем — это и есть сохранение инварианта. В отличие от
|
||||
`AddInfohashes`, который сигналит `ErrInfohashTaken` вызывающему (там это
|
||||
осмысленно), у дедуп-ветки наблюдаемого канала ошибки нет и он не нужен:
|
||||
поведение — «присоединиться к найденной задаче, чужое не красть».
|
||||
|
||||
## F6 — апгрейд catched-magnet до torrent
|
||||
|
||||
**Решение.** Новый guarded-метод хранилища:
|
||||
|
||||
```
|
||||
UpgradeCatchedMagnetToTorrent(ctx, downloadID string, torrentBlob []byte) (bool, error)
|
||||
```
|
||||
|
||||
в одной write-транзакции:
|
||||
|
||||
1. Пустой `torrentBlob` → `(false, nil)` (защитный no-op).
|
||||
2. Гардированный UPDATE:
|
||||
`UPDATE download SET source_type='torrent', updated_at=?
|
||||
WHERE id=? AND source_type='magnet' AND state='catched'`.
|
||||
`RowsAffected==0` → задача не подходит (уже `downloading`/отменена/не
|
||||
magnet) → коммит без эффекта, `(false, nil)`.
|
||||
3. `RowsAffected==1` → `INSERT OR REPLACE INTO download_torrent(download_id,
|
||||
data)` (у magnet блоба нет; `OR REPLACE` — страховка идемпотентности),
|
||||
коммит, `(true, nil)`.
|
||||
|
||||
**Почему гард `state='catched'`.** Апгрейд имеет смысл только пока worker ещё
|
||||
не отдал источник в qBittorrent. В `catched` worker на шаге добавления
|
||||
выбирает способ по `source_type` (`internal/worker/worker.go:sourceAddParts`):
|
||||
после смены на `torrent` он добавит файлом — метаданные приедут сразу. Если
|
||||
задача уже `downloading`, magnet давно в qBittorrent (застрял в metaDL), и
|
||||
смена `source_type` его не переотдаст; это отдельная забота retry/desync, не
|
||||
приёма. Тот же паттерн ре-валидации, что у `PromoteCatched`: если задачу
|
||||
успели отменить, UPDATE не заденет строк и апгрейд просто не применится.
|
||||
|
||||
**Где вызываем.** Оба дедуп-пути `Ingest` сводим к `attached()` (в ветке
|
||||
гонки `existing` от `CreateDownloadIfNoActive` уже с подгруженными хешами, так
|
||||
что переиспользование безопасно). В `attached()` после дозаписи хешей: если
|
||||
входящий источник — `torrent` и есть байты, зовём
|
||||
`UpgradeCatchedMagnetToTorrent`. Вызов best-effort: ошибка/неуспех логируются
|
||||
`Warn`/`Info`, приём не валится (как и дозапись хешей). Результат приёма
|
||||
по-прежнему несёт `State` существующей задачи (остаётся `catched`) — меняется
|
||||
лишь способ будущего добавления.
|
||||
|
||||
**Идемпотентность и повтор.** Повторный `.torrent` того же хеша: первый
|
||||
апгрейд перевёл задачу в `torrent`, гард `source_type='magnet'` на втором даст
|
||||
`RowsAffected==0` → no-op. Байты уже сохранены при создании torrent-ветки —
|
||||
`OR REPLACE` перезапишет теми же данными без вреда.
|
||||
|
||||
## Границы
|
||||
|
||||
Схему не трогаем: `download_torrent` и колонка `source_type` уже есть. ER-схема
|
||||
`docs/specs/database.md` без изменений. Апгрейд — операция над данными.
|
||||
@@ -0,0 +1,56 @@
|
||||
## Why
|
||||
|
||||
Ревью приёма (Fable, 2026-07-08) вскрыло два дефекта в дедуп-ветках приёма,
|
||||
оба про инвариант «≤1 активная загрузка на infohash» и про сохранность
|
||||
источника:
|
||||
|
||||
- **F1 — неохраняемая дозапись хешей.** Дедуп-ветка
|
||||
`CreateDownloadIfNoActive` (`internal/store/download.go`) безусловно
|
||||
дописывает ВСЕ хеши входящего источника в найденную активную задачу
|
||||
(`INSERT OR IGNORE`) без пер-хеш гарда владения — в отличие от
|
||||
`AddInfohashes`, где гард есть. Это единственная неохраняемая запись хешей,
|
||||
и она в авторитетном методе инварианта. Сценарий: активная A владеет `v1`,
|
||||
активная B владеет `v2` того же гибридного торрента; приём гибрида
|
||||
`{v1,v2}`, дедупнувшись на B, допишет `v1` в B → две активные владеют `v1`.
|
||||
Инвариант нарушен.
|
||||
|
||||
- **F6 — потерянный upgrade-путь `.torrent` поверх magnet.** Пользователь
|
||||
сначала ловит magnet с закрытого трекера (задача `catched`,
|
||||
`source_type=magnet`), понимает, что без DHT метаданные не докачаются, и
|
||||
грузит правильный `.torrent`. Приём дедупит по infohash на magnet-задачу; по
|
||||
текущей спеке байты при дедупе НЕ сохраняются, `source_type` остаётся
|
||||
`magnet`. Worker добавляет раздачу по magnet-URL → вечный metaDL → failed.
|
||||
Ровно тот артефакт, который бы починил загрузку, выбрасывается с «уже в
|
||||
работе».
|
||||
|
||||
## What Changes
|
||||
|
||||
- **F1:** дедуп-ветка `CreateDownloadIfNoActive` применяет тот же пер-хеш
|
||||
гард, что и `AddInfohashes`: хеш, которым владеет ДРУГАЯ активная задача,
|
||||
не дописывается. Транзакция уже открыта — правка внутри неё.
|
||||
|
||||
- **F6:** при дедупе, где входящее — байты `.torrent`, а активная задача
|
||||
поймана как `magnet` и ещё не добавлена в qBittorrent (состояние
|
||||
`catched`), система сохраняет байты и меняет `source_type` на `torrent` в
|
||||
одной транзакции. Тогда worker добавит раздачу файлом и метаданные не
|
||||
придётся докачивать по DHT. Это ПРОТИВОРЕЧИТ действующему правилу спеки
|
||||
ingest «при дедупликации байты сохраняться SHALL NOT» — правило смягчается
|
||||
этим целевым исключением (MODIFIED-дельта).
|
||||
|
||||
Схема БД не меняется: таблица `download_torrent` уже есть, `source_type` —
|
||||
существующая колонка; апгрейд — изменение данных, не структуры.
|
||||
|
||||
## Capabilities
|
||||
|
||||
### Modified Capabilities
|
||||
- `ingest`: уточняется поведение дедупа (пер-хеш гард дозаписи; сохранение
|
||||
`.torrent`-байт и смена источника при апгрейде `catched`-magnet).
|
||||
|
||||
## Impact
|
||||
|
||||
- Код: `internal/store/download.go` (гард F1 + новый guarded-метод апгрейда),
|
||||
`internal/ingest/ingest.go` (вызов апгрейда на обоих дедуп-путях).
|
||||
- Тесты: `internal/store`, `internal/ingest`.
|
||||
- Совместимость: изменение только ужесточает инвариант (F1) и добавляет
|
||||
целевой апгрейд (F6); существующие потоки без `.torrent`-поверх-magnet
|
||||
ведут себя как прежде.
|
||||
@@ -0,0 +1,154 @@
|
||||
## MODIFIED Requirements
|
||||
|
||||
### Requirement: Атомарность возврата загрузки в активное состояние
|
||||
|
||||
Система SHALL атомарно (в одной write-транзакции) проверять на каждом пути,
|
||||
возвращающем загрузку из терминального состояния в активное (ручной retry,
|
||||
воскрешение фоновой сверкой, повторная раскладка/relink) или создающем её
|
||||
(приём, adopt чужой раздачи), что никакая другая активная загрузка не
|
||||
владеет любым из хешей этой, и при владении SHALL отказывать в переходе,
|
||||
сохраняя инвариант «не более одной активной загрузки на infohash».
|
||||
Отказ SHALL происходить до побочных эффектов во внешних системах
|
||||
(повторного добавления торрента в qBittorrent).
|
||||
|
||||
Та же проверка SHALL применяться к дозаписи хешей загрузке (раскрытие
|
||||
гибридного торрента) на ВСЕХ путях дозаписи, включая дедуп-дозапись при
|
||||
приёме: хеш, которым владеет другая активная загрузка, дописан быть SHALL
|
||||
NOT — ни отдельным методом дозаписи, ни дедуп-веткой атомарного заведения,
|
||||
которая доносит недостающие хеши найденной активной задаче. Прямой перевод
|
||||
терминальной загрузки в активное состояние в обход этой проверки SHALL
|
||||
отклоняться хранилищем (механический бэкстоп вместо удалённого
|
||||
unique-индекса).
|
||||
|
||||
#### Scenario: Retry при занятом хеше
|
||||
|
||||
- **GIVEN** загрузка #1 в `failed` с хешем `h`, и другая активная загрузка
|
||||
#2 с тем же `h`
|
||||
- **WHEN** пользователь вызывает retry для #1
|
||||
- **THEN** переход отклоняется с пояснением, #1 остаётся в `failed`
|
||||
- **AND** активной по `h` остаётся #2
|
||||
|
||||
#### Scenario: Дедуп-дозапись не крадёт чужой хеш
|
||||
|
||||
- **GIVEN** активная загрузка A владеет хешем `v1`, активная загрузка B
|
||||
владеет хешем `v2` того же гибридного торрента
|
||||
- **WHEN** принимается источник с обоими хешами `{v1, v2}` и дедупится на B
|
||||
- **THEN** B получает только незанятые хеши, а `v1` (в собственности A) B не
|
||||
дописывается
|
||||
- **AND** инвариант «не более одной активной загрузки на infohash»
|
||||
сохраняется (по `v1` активна только A)
|
||||
|
||||
### Requirement: Приём источника из .torrent-файла
|
||||
|
||||
Приём SHALL принимать источник в виде **байтов `.torrent`-файла** (наряду с
|
||||
magnet-ссылкой) — тем же быстрым use-case, общим для транспортов. Получив
|
||||
непустые байты торрента, система SHALL разобрать их локально (без сети),
|
||||
извлечь инфохэш(и) и завести загрузку с `source_type = torrent`, после чего
|
||||
сразу вернуть ответ транспорту (синхронный путь к qBittorrent не обращается —
|
||||
добавление делает воркер, см. `download-tracking`).
|
||||
|
||||
Инфохэши система SHALL извлекать такими, какими их сообщает qBittorrent, чтобы
|
||||
сопоставление раздач и дедупликация работали: v1-хеш (для v1/гибридного файла)
|
||||
SHALL вычисляться как SHA1 **исходных** байтов info-словаря (без переэнкода);
|
||||
v2-хеш (для v2/гибридного файла, BEP52) SHALL извлекаться как 64-hex `infohash_v2`.
|
||||
Для чистого v2-only файла система SHALL записывать v2-хеш (v1 у него нет).
|
||||
Извлечение всех известных хешей и дозапись недостающих подчиняются требованию
|
||||
«Множество инфохэшей загрузки».
|
||||
|
||||
Дедупликацию по активной задаче, атомарное заведение (`download` в состоянии
|
||||
`catched` + записи `download_infohash`) и инвариант «не более одной активной
|
||||
загрузки на infohash» torrent-приём SHALL проходить тем же атомарным путём, что
|
||||
и magnet (см. «Приём источника и заведение загрузки», «Дедупликация приёма по
|
||||
любому из хешей», «Атомарность возврата загрузки в активное состояние»).
|
||||
|
||||
Байты `.torrent` система SHALL сохранять персистентно, привязанными к загрузке,
|
||||
чтобы воркер мог добавить источник в qBittorrent именно файлом (не по magnet):
|
||||
раздачи закрытых трекеров и торренты без DHT по magnet-хешу метаданные не
|
||||
получат. Сохранение байтов SHALL выполняться в той же write-транзакции, что и
|
||||
заведение загрузки; при дедупликации (новая загрузка не создана) байты в общем
|
||||
случае сохраняться SHALL NOT.
|
||||
|
||||
**Исключение — апгрейд пойманной magnet-задачи до torrent.** Если входящий
|
||||
источник — байты `.torrent`, а дедуп попал на активную загрузку с
|
||||
`source_type = magnet`, ещё НЕ отданную в qBittorrent (состояние `catched`),
|
||||
система SHALL в одной write-транзакции сохранить байты `.torrent`,
|
||||
привязав их к этой загрузке, и сменить её `source_type` на `torrent`. Тем
|
||||
самым воркер добавит раздачу файлом, а не magnet-хешем (иначе на закрытом
|
||||
трекере без DHT метаданные не докачаются, а magnet застрянет в metaDL →
|
||||
failed). Апгрейд SHALL применяться ТОЛЬКО пока загрузка в `catched` (воркер
|
||||
источник ещё не добавил); для уже добавленной (`downloading` и далее)
|
||||
загрузки смена `source_type` при дедупе выполняться SHALL NOT — её судьба
|
||||
решается путями retry/сверки, а не приёмом. Апгрейд SHALL быть best-effort:
|
||||
его неуспех приём не прерывает.
|
||||
|
||||
Из полей `.torrent` система SHALL синтезировать контекст распознавания (имя
|
||||
раздачи, суммарный размер, сигнал по дереву файлов, домен трекера, комментарий)
|
||||
и **дополнять** им контекст транспорта — тем же правилом слияния, что и синтез
|
||||
из полей magnet (пользовательский текст первым; при пустом тексте — только
|
||||
синтез). Обогащённый контекст система SHALL сохранять в `download.Context`.
|
||||
Синтез SHALL выполняться без сетевых запросов.
|
||||
|
||||
`source_ref` у torrent-загрузки SHALL быть человекочитаемым референсом (имя
|
||||
раздачи или файла), а НЕ адресом добавления: добавление в qBittorrent идёт
|
||||
байтами, и трактовать `source_ref` как magnet/URL для добавления система SHALL
|
||||
NOT.
|
||||
|
||||
#### Scenario: Быстрый приём .torrent-файла
|
||||
|
||||
- **GIVEN** валидные байты `.torrent`-файла и (опц.) текст контекста
|
||||
- **WHEN** вызывается приём
|
||||
- **THEN** из файла извлекаются инфохэши и создаётся `download` в состоянии
|
||||
`catched` (`source_type = torrent`) с записями `download_infohash`
|
||||
- **AND** байты файла сохраняются привязанными к загрузке
|
||||
- **AND** ответ транспорту отдан без обращения к qBittorrent
|
||||
|
||||
#### Scenario: Инфохэш из исходных байтов info
|
||||
|
||||
- **WHEN** система разбирает v1/гибридный `.torrent`-файл
|
||||
- **THEN** инфохэш v1 вычисляется как SHA1 исходных байтов info-словаря
|
||||
- **AND** совпадает с хешем, по которому qBittorrent позже сопоставит раздачу
|
||||
|
||||
#### Scenario: v2-only файл записывается под v2-хешем
|
||||
|
||||
- **WHEN** система разбирает `.torrent` только с метаданными v2 (без v1)
|
||||
- **THEN** у загрузки записывается v2-хеш (64-hex), совпадающий с `infohash_v2`
|
||||
qBittorrent
|
||||
- **AND** сопоставление раздачи работает по нему
|
||||
|
||||
#### Scenario: Дубль .torrent по активной torrent-задаче
|
||||
|
||||
- **GIVEN** уже есть активная (в т.ч. `catched`) загрузка с тем же infohash и
|
||||
`source_type = torrent`
|
||||
- **WHEN** принимается `.torrent` с тем же инфохэшем
|
||||
- **THEN** новая загрузка не создаётся, возвращается существующая
|
||||
- **AND** байты торрента повторно не сохраняются (дубль)
|
||||
|
||||
#### Scenario: Апгрейд catched-magnet до torrent
|
||||
|
||||
- **GIVEN** активная загрузка в `catched` с `source_type = magnet` и хешем `h`
|
||||
(magnet-задача ещё не отдана в qBittorrent)
|
||||
- **WHEN** принимается `.torrent` с тем же инфохэшем `h`
|
||||
- **THEN** новая загрузка не создаётся, возвращается существующая
|
||||
- **AND** байты `.torrent` сохраняются привязанными к ней, а её `source_type`
|
||||
становится `torrent` — в одной транзакции
|
||||
- **AND** воркер добавит раздачу файлом (не по magnet)
|
||||
|
||||
#### Scenario: Magnet-задача уже добавлена — апгрейда нет
|
||||
|
||||
- **GIVEN** активная загрузка с `source_type = magnet` уже в `downloading`
|
||||
(отдана в qBittorrent)
|
||||
- **WHEN** принимается `.torrent` с тем же инфохэшем
|
||||
- **THEN** возвращается существующая загрузка, её `source_type` остаётся
|
||||
`magnet`, байты `.torrent` не сохраняются
|
||||
|
||||
#### Scenario: Контекст из полей файла
|
||||
|
||||
- **WHEN** принят `.torrent` с именем раздачи, деревом файлов и трекерами
|
||||
- **THEN** в `download.Context` добавляется синтез (имя, размер, сигнал по
|
||||
файлам, домен трекера), дополняющий текст транспорта
|
||||
- **AND** синтез выполнен без сетевых запросов
|
||||
|
||||
#### Scenario: Слишком большой .torrent отклоняется
|
||||
|
||||
- **WHEN** принимаемый `.torrent`-файл превышает ограничение размера
|
||||
- **THEN** приём отклоняется с ошибкой, загрузка не создаётся
|
||||
@@ -0,0 +1,29 @@
|
||||
## 1. F1 — пер-хеш гард дедуп-дозаписи
|
||||
|
||||
- [x] 1.1 В `CreateDownloadIfNoActive` (`internal/store/download.go`) заменить
|
||||
безусловный цикл `INSERT OR IGNORE` дедуп-ветки на пер-хеш гард как в
|
||||
`AddInfohashes`: пропускать хеш, которым владеет другая активная задача
|
||||
(`findActiveByInfohash(..., existing.ID)`), внутри уже открытой tx.
|
||||
- [x] 1.2 Тест в `internal/store`: гибридный дедуп на B не крадёт хеш,
|
||||
принадлежащий активной A (инвариант сохранён).
|
||||
|
||||
## 2. F6 — апгрейд catched-magnet до torrent
|
||||
|
||||
- [x] 2.1 Добавить guarded-метод хранилища
|
||||
`UpgradeCatchedMagnetToTorrent(ctx, downloadID, torrentBlob) (bool, error)`:
|
||||
в одной tx гардированным UPDATE `source_type='torrent'` при
|
||||
`source_type='magnet' AND state='catched'`, затем сохранить байты в
|
||||
`download_torrent`; вернуть, был ли апгрейд.
|
||||
- [x] 2.2 В `internal/ingest/ingest.go` свести оба дедуп-пути к `attached()` и
|
||||
вызвать апгрейд, когда входящий источник — torrent с байтами
|
||||
(best-effort: неуспех логируется, приём не валится).
|
||||
- [x] 2.3 Обновить интерфейс `ingest.Store` и `fakeStore` в тестах.
|
||||
- [x] 2.4 Тесты в `internal/store`: апгрейд из `catched`+magnet сохраняет байты
|
||||
и меняет `source_type`; из `downloading`/не-magnet — no-op. Тест в
|
||||
`internal/ingest`: дедуп `.torrent` на catched-magnet вызывает апгрейд.
|
||||
|
||||
## 3. Проверки
|
||||
|
||||
- [x] 3.1 `openspec validate --strict ingest-dedup-integrity`
|
||||
- [x] 3.2 `task test`
|
||||
- [x] 3.3 `task lint`
|
||||
Reference in New Issue
Block a user