feat(seeding): wire seed ratio/time lifecycle into the torrent daemon
SeedRatio/SeedTime were declared on TorrentConfig but never consumed, and SeedEnabled was hardcoded false in both constructors — the daemon never seeded, and if forced it seeded forever. - config: [downloads] seed_enabled/seed_ratio/seed_time (opt-in, off by default) - daemon: parse seed_time + wire all three; startup log per target shape - engine: seedTargetReached() (pure) + seedAndDrop() background monitor on a downloader-scoped seedCtx (not the task ctx, which dies when Download returns); drops the torrent on ratio (uploaded/size) OR time, whichever first; no target = seed until shutdown. Configurable check interval (tests lower it). - fix: cleanup() now always drops — previously leaked the handle on error paths when seeding was enabled. - refactor: dropTracked() helper shared by cleanup + post-seeding drop. Tests: TestSeedTargetReached (9 cases) + ctx/no-target branches + loopback swarm smoke (-tags smoke). Roadmap hueco closed.
This commit is contained in:
Deivid Soto
parent
665ec0a34f
commit
132c88b3f0
8 changed files with 459 additions and 34 deletions
118
internal/engine/seed_lifecycle_smoke_test.go
Normal file
118
internal/engine/seed_lifecycle_smoke_test.go
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
//go:build smoke
|
||||
|
||||
package engine
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/anacrolix/torrent"
|
||||
"github.com/anacrolix/torrent/bencode"
|
||||
"github.com/anacrolix/torrent/metainfo"
|
||||
)
|
||||
|
||||
// TestSeedLifecycleSmoke spins up a real loopback BitTorrent swarm: a seeder
|
||||
// client serving a small file, and our TorrentDownloader's client leeching it.
|
||||
// Once the leecher completes, the torrent is handed to seedAndDrop with a short
|
||||
// SeedTime; the test asserts the lifecycle fires and the handle is dropped
|
||||
// (removed from d.active). Exercises the real anacrolix Stats/Drop/ticker path,
|
||||
// not mocks. Run with: go test -tags smoke -run TestSeedLifecycleSmoke ./internal/engine/
|
||||
func TestSeedLifecycleSmoke(t *testing.T) {
|
||||
// --- seeder: a real client serving a 4 MiB file over loopback ---
|
||||
seedDir := t.TempDir()
|
||||
payload := make([]byte, 4<<20)
|
||||
for i := range payload {
|
||||
payload[i] = byte(i)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(seedDir, "movie.bin"), payload, 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var info metainfo.Info
|
||||
info.PieceLength = 256 << 10
|
||||
if err := info.BuildFromFilePath(filepath.Join(seedDir, "movie.bin")); err != nil {
|
||||
t.Fatalf("build info: %v", err)
|
||||
}
|
||||
var mi metainfo.MetaInfo
|
||||
var err error
|
||||
if mi.InfoBytes, err = bencode.Marshal(info); err != nil {
|
||||
t.Fatalf("marshal info: %v", err)
|
||||
}
|
||||
|
||||
scfg := torrent.NewDefaultClientConfig()
|
||||
scfg.DataDir = seedDir
|
||||
scfg.Seed = true
|
||||
scfg.NoDHT = true
|
||||
scfg.DisableTrackers = true
|
||||
scfg.ListenPort = 0 // random — never collides with the leecher's 42069
|
||||
seeder, err := torrent.NewClient(scfg)
|
||||
if err != nil {
|
||||
t.Fatalf("seeder client: %v", err)
|
||||
}
|
||||
defer seeder.Close()
|
||||
st, err := seeder.AddTorrent(&mi)
|
||||
if err != nil {
|
||||
t.Fatalf("seeder add: %v", err)
|
||||
}
|
||||
<-st.GotInfo()
|
||||
st.DownloadAll() // verifies the existing pieces so the seeder is "complete"
|
||||
|
||||
// --- leecher: our downloader, seeding enabled, very short seed time ---
|
||||
leechDir := t.TempDir()
|
||||
dl, err := NewTorrentDownloader(TorrentConfig{
|
||||
DataDir: leechDir,
|
||||
SeedEnabled: true,
|
||||
SeedTime: 1 * time.Second, // time target fires fast (no peers pull from us, so ratio stays 0)
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("downloader: %v", err)
|
||||
}
|
||||
dl.seedCheckInterval = 200 * time.Millisecond // poll fast so the 1s target is noticed promptly
|
||||
defer dl.Shutdown(context.Background())
|
||||
|
||||
lt, err := dl.client.AddTorrent(&mi)
|
||||
if err != nil {
|
||||
t.Fatalf("leecher add: %v", err)
|
||||
}
|
||||
<-lt.GotInfo()
|
||||
lt.AddClientPeer(seeder) // loopback peer — no DHT/tracker needed
|
||||
lt.DownloadAll()
|
||||
|
||||
deadline := time.After(30 * time.Second)
|
||||
for lt.BytesMissing() > 0 {
|
||||
select {
|
||||
case <-deadline:
|
||||
t.Fatalf("download did not complete (missing %d bytes)", lt.BytesMissing())
|
||||
case <-time.After(100 * time.Millisecond):
|
||||
}
|
||||
}
|
||||
t.Logf("leecher completed %d bytes", lt.BytesCompleted())
|
||||
|
||||
// Track it as the daemon would for a seeding torrent, then run the lifecycle.
|
||||
const taskID = "smoke-seed-task-0001"
|
||||
dl.activeMu.Lock()
|
||||
dl.active[taskID] = lt
|
||||
dl.activeMu.Unlock()
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
dl.seedAndDrop(taskID, lt, info.Length)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(10 * time.Second):
|
||||
t.Fatal("seedAndDrop did not return within 10s")
|
||||
}
|
||||
|
||||
dl.activeMu.Lock()
|
||||
_, stillTracked := dl.active[taskID]
|
||||
dl.activeMu.Unlock()
|
||||
if stillTracked {
|
||||
t.Error("torrent still tracked after seedAndDrop — lifecycle did not drop it")
|
||||
}
|
||||
}
|
||||
|
|
@ -16,6 +16,7 @@ import (
|
|||
alog "github.com/anacrolix/log"
|
||||
"github.com/anacrolix/torrent"
|
||||
"github.com/anacrolix/torrent/storage"
|
||||
"github.com/torrentclaw/unarr/internal/agent"
|
||||
"github.com/torrentclaw/unarr/internal/config"
|
||||
"github.com/torrentclaw/unarr/internal/vpn"
|
||||
"golang.org/x/term"
|
||||
|
|
@ -61,21 +62,21 @@ var defaultTrackers = []string{
|
|||
|
||||
// TorrentConfig holds settings for the BitTorrent downloader.
|
||||
type TorrentConfig struct {
|
||||
DataDir string
|
||||
DataDir string
|
||||
// PieceCompletionDir, when non-empty, stores the piece-completion SQLite DB
|
||||
// in this directory instead of DataDir. Use the agent's local state dir
|
||||
// (not the download dir) so the DB never lands on NFS/SMB volumes where
|
||||
// SQLite locking times out.
|
||||
PieceCompletionDir string
|
||||
MetadataTimeout time.Duration // how long to wait for torrent metadata (default 15m, 0 = unlimited)
|
||||
StallTimeout time.Duration // no progress during download for this long = stall (default 10m)
|
||||
MaxTimeout time.Duration // absolute maximum per torrent (default 0 = unlimited)
|
||||
MaxDownloadRate int64 // bytes/s, 0 = unlimited
|
||||
MaxUploadRate int64 // bytes/s, 0 = unlimited
|
||||
ListenPort int // fixed port for incoming peers (default 42069, 0 = random)
|
||||
SeedEnabled bool
|
||||
SeedRatio float64 // target seed ratio (default 0, meaning seed until SeedTime)
|
||||
SeedTime time.Duration // min seed time after completion (default 0)
|
||||
PieceCompletionDir string
|
||||
MetadataTimeout time.Duration // how long to wait for torrent metadata (default 15m, 0 = unlimited)
|
||||
StallTimeout time.Duration // no progress during download for this long = stall (default 10m)
|
||||
MaxTimeout time.Duration // absolute maximum per torrent (default 0 = unlimited)
|
||||
MaxDownloadRate int64 // bytes/s, 0 = unlimited
|
||||
MaxUploadRate int64 // bytes/s, 0 = unlimited
|
||||
ListenPort int // fixed port for incoming peers (default 42069, 0 = random)
|
||||
SeedEnabled bool
|
||||
SeedRatio float64 // target seed ratio (default 0, meaning seed until SeedTime)
|
||||
SeedTime time.Duration // min seed time after completion (default 0)
|
||||
|
||||
// VPNTunnel, when set, split-tunnels the torrent client's peer + tracker
|
||||
// traffic through an in-process userspace WireGuard tunnel (managed-VPN
|
||||
|
|
@ -91,6 +92,15 @@ type TorrentDownloader struct {
|
|||
activeMu sync.Mutex
|
||||
active map[string]*torrent.Torrent // taskID -> torrent handle
|
||||
|
||||
// seedCtx scopes the background seeders. Cancelled at Shutdown so they stop
|
||||
// uploading and exit; it must outlive any single download's task context
|
||||
// (which is cancelled the moment Download returns and the queue slot frees).
|
||||
seedCtx context.Context
|
||||
seedCancel context.CancelFunc
|
||||
// seedCheckInterval is how often the background seeder re-checks its stop
|
||||
// condition. Defaults to defaultSeedCheckInterval; tests lower it.
|
||||
seedCheckInterval time.Duration
|
||||
|
||||
minFreeBytes int64 // disk reserve for the pre-flight space check (0 = reserve disabled)
|
||||
}
|
||||
|
||||
|
|
@ -278,10 +288,14 @@ func NewTorrentDownloader(cfg TorrentConfig) (*TorrentDownloader, error) {
|
|||
}
|
||||
}
|
||||
|
||||
seedCtx, seedCancel := context.WithCancel(context.Background())
|
||||
return &TorrentDownloader{
|
||||
client: client,
|
||||
cfg: cfg,
|
||||
active: make(map[string]*torrent.Torrent),
|
||||
client: client,
|
||||
cfg: cfg,
|
||||
active: make(map[string]*torrent.Torrent),
|
||||
seedCtx: seedCtx,
|
||||
seedCancel: seedCancel,
|
||||
seedCheckInterval: defaultSeedCheckInterval,
|
||||
}, nil
|
||||
}
|
||||
|
||||
|
|
@ -304,14 +318,11 @@ func (d *TorrentDownloader) Download(ctx context.Context, task *Task, outputDir
|
|||
d.active[task.ID] = t
|
||||
d.activeMu.Unlock()
|
||||
|
||||
cleanup := func() {
|
||||
d.activeMu.Lock()
|
||||
delete(d.active, task.ID)
|
||||
d.activeMu.Unlock()
|
||||
if !d.cfg.SeedEnabled {
|
||||
t.Drop()
|
||||
}
|
||||
}
|
||||
// cleanup drops the torrent and stops tracking it. Used by every error path
|
||||
// (metadata timeout, disk guard, poll failure) and by the non-seeding success
|
||||
// path — all of which must drop. The seeding success path deliberately does
|
||||
// NOT call cleanup (it hands off to seedAndDrop).
|
||||
cleanup := func() { d.dropTracked(task.ID, t) }
|
||||
|
||||
// 1. Wait for metadata (0 = unlimited, like qBittorrent)
|
||||
if d.cfg.MetadataTimeout > 0 {
|
||||
|
|
@ -396,9 +407,14 @@ func (d *TorrentDownloader) Download(ctx context.Context, task *Task, outputDir
|
|||
// readable mode is preserved through the rename.
|
||||
makeReadable(filePath)
|
||||
|
||||
// If seeding enabled, keep alive (don't cleanup).
|
||||
// The manager handles seeding lifecycle.
|
||||
if !d.cfg.SeedEnabled {
|
||||
// Seeding handoff: with seeding enabled, keep the torrent uploading in the
|
||||
// background — seedAndDrop drops it once the ratio/time target is hit (or at
|
||||
// shutdown). Otherwise drop now. seedAndDrop must NOT use ctx: the task
|
||||
// context is cancelled the moment Download returns and the manager frees the
|
||||
// queue slot, which would kill the seeder instantly.
|
||||
if d.cfg.SeedEnabled {
|
||||
go d.seedAndDrop(task.ID, t, totalBytes)
|
||||
} else {
|
||||
cleanup()
|
||||
}
|
||||
|
||||
|
|
@ -503,6 +519,97 @@ func (d *TorrentDownloader) pollDownload(ctx context.Context, t *torrent.Torrent
|
|||
}
|
||||
}
|
||||
|
||||
// dropTracked stops tracking taskID and drops the torrent handle. The delete is
|
||||
// guarded on the entry still being this handle, so a concurrent Pause/Cancel that
|
||||
// already removed/replaced it isn't clobbered; t.Drop() is idempotent. Shared by
|
||||
// the error/non-seeding cleanup path and the post-seeding drop.
|
||||
func (d *TorrentDownloader) dropTracked(taskID string, t *torrent.Torrent) {
|
||||
d.activeMu.Lock()
|
||||
if cur, ok := d.active[taskID]; ok && cur == t {
|
||||
delete(d.active, taskID)
|
||||
}
|
||||
d.activeMu.Unlock()
|
||||
t.Drop()
|
||||
}
|
||||
|
||||
// defaultSeedCheckInterval is how often the background seeder re-evaluates the
|
||||
// ratio / time stop condition. Seeding is long-running and low-urgency, so a
|
||||
// coarse interval keeps the overhead negligible. Stored on the downloader so
|
||||
// tests can lower it.
|
||||
const defaultSeedCheckInterval = 30 * time.Second
|
||||
|
||||
// seedTargetReached reports why seeding should stop, or "" to keep going.
|
||||
// Ratio is uploaded-data / selected-size ("uploaded N× the content"), which is
|
||||
// stable across resumes — unlike uploaded/downloaded-this-session. The two
|
||||
// targets are independent: whichever of ratio (>0) or time (>0) fires first
|
||||
// wins; with both unset nothing ever fires (the caller seeds indefinitely).
|
||||
func seedTargetReached(ratioTarget float64, timeTarget time.Duration, uploaded, size int64, elapsed time.Duration) string {
|
||||
var ratio float64
|
||||
if size > 0 {
|
||||
ratio = float64(uploaded) / float64(size)
|
||||
}
|
||||
switch {
|
||||
case ratioTarget > 0 && ratio >= ratioTarget:
|
||||
return fmt.Sprintf("ratio %.2f reached (target %.2f)", ratio, ratioTarget)
|
||||
case timeTarget > 0 && elapsed >= timeTarget:
|
||||
return fmt.Sprintf("seed time %s reached (target %s)", elapsed.Round(time.Second), timeTarget)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// seedAndDrop keeps a completed torrent uploading until the configured ratio or
|
||||
// time target is reached, then drops it (stops seeding, releases the handle and
|
||||
// its queue tracking). Runs detached on d.seedCtx — see the Download call site
|
||||
// for why it can't use the task context. With no ratio/time target it returns
|
||||
// immediately and the torrent seeds until Shutdown (or a user cancel/pause drops
|
||||
// it). It exits without dropping if the handle was already removed elsewhere, so
|
||||
// it never reads stats off a closed torrent nor double-drops.
|
||||
func (d *TorrentDownloader) seedAndDrop(taskID string, t *torrent.Torrent, totalBytes int64) {
|
||||
sid := agent.ShortID(taskID)
|
||||
|
||||
ratioTarget := d.cfg.SeedRatio
|
||||
timeTarget := d.cfg.SeedTime
|
||||
if ratioTarget <= 0 && timeTarget <= 0 {
|
||||
log.Printf("[%s] seeding indefinitely (no ratio/time target) — drops at shutdown", sid)
|
||||
return
|
||||
}
|
||||
log.Printf("[%s] seeding (ratio target: %.2f, time target: %s)", sid, ratioTarget, timeTarget)
|
||||
|
||||
interval := d.seedCheckInterval
|
||||
if interval <= 0 {
|
||||
interval = defaultSeedCheckInterval
|
||||
}
|
||||
start := time.Now()
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-d.seedCtx.Done():
|
||||
return // daemon shutting down — Shutdown drops the handle
|
||||
case <-ticker.C:
|
||||
// Bail if the handle was dropped elsewhere (user cancel/pause).
|
||||
d.activeMu.Lock()
|
||||
cur, ok := d.active[taskID]
|
||||
d.activeMu.Unlock()
|
||||
if !ok || cur != t {
|
||||
return
|
||||
}
|
||||
|
||||
stats := t.Stats()
|
||||
uploaded := stats.BytesWrittenData.Int64()
|
||||
reason := seedTargetReached(ratioTarget, timeTarget, uploaded, totalBytes, time.Since(start))
|
||||
if reason == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
log.Printf("[%s] seeding complete: %s, uploaded %s — dropping", sid, reason, formatBytes(uploaded))
|
||||
d.dropTracked(taskID, t)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// makeReadable relaxes permissions on a completed download so it can be
|
||||
// re-opened by streaming/ffprobe/organize. anacrolix mmap storage creates
|
||||
// files with mode 0000; we set files to 0644 and directories to 0755. Errors
|
||||
|
|
@ -588,6 +695,12 @@ func (d *TorrentDownloader) Cancel(taskID string) error {
|
|||
}
|
||||
|
||||
func (d *TorrentDownloader) Shutdown(ctx context.Context) error {
|
||||
// Stop background seeders first so they don't read stats off / re-drop the
|
||||
// handles we're about to close.
|
||||
if d.seedCancel != nil {
|
||||
d.seedCancel()
|
||||
}
|
||||
|
||||
// Save DHT nodes in binary format for next session (warm start)
|
||||
saveDhtNodesBinary(d.client)
|
||||
|
||||
|
|
|
|||
|
|
@ -264,3 +264,114 @@ func TestTorrentDownloader_DownloadTimeout_MetadataCancel(t *testing.T) {
|
|||
func TestTorrentDownloader_ImplementsInterface(t *testing.T) {
|
||||
var _ Downloader = (*TorrentDownloader)(nil)
|
||||
}
|
||||
|
||||
// TestSeedTargetReached cubre la lógica pura de parada del seeding: ratio,
|
||||
// tiempo, ninguno, ambos (el primero que se cumple gana) y la guarda de tamaño
|
||||
// cero (no debe dividir por cero ni parar por ratio).
|
||||
func TestSeedTargetReached(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
ratioTarget float64
|
||||
timeTarget time.Duration
|
||||
uploaded int64
|
||||
size int64
|
||||
elapsed time.Duration
|
||||
wantStop bool
|
||||
}{
|
||||
{"ratio reached", 2.0, 0, 200, 100, time.Minute, true},
|
||||
{"ratio not reached", 2.0, 0, 150, 100, time.Minute, false},
|
||||
{"ratio exactly met", 1.0, 0, 100, 100, time.Minute, true},
|
||||
{"time reached", 0, time.Hour, 10, 100, 2 * time.Hour, true},
|
||||
{"time not reached", 0, time.Hour, 10, 100, 30 * time.Minute, false},
|
||||
{"no targets never stops", 0, 0, 9999, 100, 99 * time.Hour, false},
|
||||
{"ratio wins when both set", 2.0, time.Hour, 200, 100, time.Second, true},
|
||||
{"time wins when ratio short", 5.0, time.Hour, 100, 100, 2 * time.Hour, true},
|
||||
{"zero size guards div", 2.0, 0, 200, 0, time.Minute, false},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
reason := seedTargetReached(tc.ratioTarget, tc.timeTarget, tc.uploaded, tc.size, tc.elapsed)
|
||||
if got := reason != ""; got != tc.wantStop {
|
||||
t.Errorf("seedTargetReached(ratio=%.1f time=%s up=%d size=%d el=%s) stop=%v (reason %q), want %v",
|
||||
tc.ratioTarget, tc.timeTarget, tc.uploaded, tc.size, tc.elapsed, got, reason, tc.wantStop)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestTorrentDownloader_SeedRatioTime verifica que SeedRatio y SeedTime se
|
||||
// propagan a la config del downloader.
|
||||
func TestTorrentDownloader_SeedRatioTime(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
dl, err := NewTorrentDownloader(TorrentConfig{
|
||||
DataDir: dir,
|
||||
SeedEnabled: true,
|
||||
SeedRatio: 1.5,
|
||||
SeedTime: 2 * time.Hour,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("NewTorrentDownloader: %v", err)
|
||||
}
|
||||
defer dl.Shutdown(context.Background())
|
||||
|
||||
if dl.cfg.SeedRatio != 1.5 {
|
||||
t.Errorf("SeedRatio = %v, want 1.5", dl.cfg.SeedRatio)
|
||||
}
|
||||
if dl.cfg.SeedTime != 2*time.Hour {
|
||||
t.Errorf("SeedTime = %v, want 2h", dl.cfg.SeedTime)
|
||||
}
|
||||
if dl.seedCtx == nil || dl.seedCancel == nil {
|
||||
t.Error("seedCtx/seedCancel must be initialised by the constructor")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSeedAndDrop_NoTargetReturnsImmediately verifica que sin ratio ni tiempo
|
||||
// objetivo, seedAndDrop retorna de inmediato (siembra indefinida) sin tocar el
|
||||
// handle — por eso es seguro pasar un torrent nil.
|
||||
func TestSeedAndDrop_NoTargetReturnsImmediately(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
dl, err := NewTorrentDownloader(TorrentConfig{DataDir: dir, SeedEnabled: true}) // ratio 0, time 0
|
||||
if err != nil {
|
||||
t.Fatalf("NewTorrentDownloader: %v", err)
|
||||
}
|
||||
defer dl.Shutdown(context.Background())
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
dl.seedAndDrop("no-target-task-id", nil, 1000)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("seedAndDrop with no target should return immediately")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSeedAndDrop_StopsOnSeedCtxCancel verifica que seedAndDrop sale cuando se
|
||||
// cancela seedCtx (ruta de Shutdown), incluso con un objetivo de ratio alto y el
|
||||
// tick deshabilitado — el único camino de salida es seedCtx.Done().
|
||||
func TestSeedAndDrop_StopsOnSeedCtxCancel(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
dl, err := NewTorrentDownloader(TorrentConfig{DataDir: dir, SeedEnabled: true, SeedRatio: 99})
|
||||
if err != nil {
|
||||
t.Fatalf("NewTorrentDownloader: %v", err)
|
||||
}
|
||||
defer dl.Shutdown(context.Background())
|
||||
|
||||
dl.seedCheckInterval = time.Hour // el ticker no disparará; solo seedCtx.Done() puede terminar
|
||||
dl.seedCancel() // cancela antes de arrancar el monitor
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
dl.seedAndDrop("ctx-cancel-task-id", nil, 1000)
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("seedAndDrop should return when seedCtx is cancelled")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue