test(download): cover deletion during preparation and late callbacks

internal/fetcher/fetcher.go

@@ -46,10 +46,6 @@ type Uploader interface {
 	WaitUpload() error
 }
 
-type DownloadCounter interface {
-	ReceivedBytes() int64
-}
-
 // FetcherMeta defines the meta information of a fetcher.
 type FetcherMeta struct {
 	Req  *base.Request  `json:"req"`

internal/protocol/bt/download_test.go

@@ -290,82 +290,6 @@ func TestBTDownloadSelectedFiles(t *testing.T) {
 	if f.Meta().Res.Size != 48*1024 {
 		t.Fatal("selected resource size is incorrect")
 	}
-	if downloaded := f.Progress().TotalDownloaded(); downloaded != 48*1024 || f.ReceivedBytes() <= downloaded {
-		t.Fatalf("selected progress = %d, received traffic = %d; want 48 KiB of progress and traffic across the shared piece", downloaded, f.ReceivedBytes())
-	}
-}
-
-func TestBTProgressOnlyCountsVerifiedFileBytes(t *testing.T) {
-	const fileSize = 56 * 1024
-	fixture := makeBTFixtureWithPieceSize(t, map[string][]byte{
-		"a.bin": btPayload(fileSize, "verified-a"),
-		"b.bin": btPayload(fileSize, "verified-b"),
-	}, 16*1024, false, true, 64*1024)
-	f := btDownloadFetcher(t, nil)
-	btResolve(t, f, fixture.Magnet)
-	dir := t.TempDir()
-	f.Meta().Opts = &base.Options{Path: dir}
-	btStart(t, f)
-	deadline := time.Now().Add(8 * time.Second)
-	for f.torrent.Files()[0].BytesCompleted() == 0 && time.Now().Before(deadline) {
-		time.Sleep(10 * time.Millisecond)
-	}
-	btPause(t, f)
-	if f.torrent.Files()[0].BytesCompleted() == 0 || f.torrent.Piece(0).State().Complete {
-		t.Fatal("expected some received bytes in a piece that is still incomplete")
-	}
-	if f.ReceivedBytes() == 0 {
-		t.Fatal("received traffic must be visible before a piece is verified")
-	}
-	if progress := f.Progress(); len(progress) != 2 || progress[0] != 0 {
-		t.Errorf("progress before the first file's piece is verified = %v, want zero for the first file", progress)
-	}
-	fixture.Limiter.SetLimit(rate.Inf)
-	btStart(t, f)
-	btAwaitDone(t, f)
-	fixture.AssertFiles(t, dir)
-	progress := f.Progress()
-	if len(progress) != 2 || progress[0] != fileSize || progress[1] != fileSize {
-		t.Fatalf("verified progress at completion = %v, want %d for each file", progress, fileSize)
-	}
-}
-
-func TestBTUploadedBytesSamplesLiveTraffic(t *testing.T) {
-	payload := btPayload(48*1024, "upload-counter")
-	fixture := newBTFixture(t, map[string][]byte{"": payload}, 0)
-	const saved = 1024
-	f := &Fetcher{
-		torrent:       fixture.Torrent,
-		data:          &fetcherData{SeedBytes: saved},
-		seedBaseBytes: saved,
-	}
-	f.torrentReady.Store(true)
-	f.torrentUpload.Store(true)
-
-	cfg := torrent.TestingConfig(t)
-	cfg.DataDir = t.TempDir()
-	cfg.DisableTrackers = true
-	cfg.DisableUTP = true
-	cfg.DisableIPv6 = true
-	peer, err := torrent.NewClient(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { peer.Close() })
-	download, _, err := peer.AddTorrentSpec(torrent.TorrentSpecFromMetaInfo(fixture.MetaInfo))
-	if err != nil {
-		t.Fatal(err)
-	}
-	download.AddPeers([]torrent.PeerInfo{{Addr: fixture.Seeder.ListenAddrs()[0]}})
-	download.DownloadAll()
-	select {
-	case <-download.Complete().On():
-	case <-time.After(10 * time.Second):
-		t.Fatal("loopback peer did not complete")
-	}
-	if got, want := f.UploadedBytes(), int64(saved+len(payload)); got != want {
-		t.Fatalf("uploaded bytes = %d, want %d including the saved bytes", got, want)
-	}
 }
 
 func TestBTPauseAndResume(t *testing.T) {

internal/protocol/bt/fetcher.go

@@ -10,7 +10,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -46,7 +45,6 @@ type Fetcher struct {
 	torrent *torrent.Torrent
 	meta    *fetcher.FetcherMeta
 	data    *fetcherData
-	seedBaseBytes int64
 
 	torrentReady    atomic.Bool
 	torrentUpload   atomic.Bool
@@ -465,46 +463,14 @@ func (f *Fetcher) Progress() fetcher.Progress {
 	if !f.torrentReady.Load() {
 		return append(fetcher.Progress(nil), f.data.Progress...)
 	}
-	pieceSize := f.torrent.Info().PieceLength
-	var offset int64
-	var verified []verifiedByteRange
-	for _, run := range f.torrent.PieceStateRuns() {
-		end := offset + int64(run.Length)*pieceSize
-		if pieceVerified(run.PieceState) {
-			verified = append(verified, verifiedByteRange{start: offset, end: end})
-		}
-		offset = end
-	}
-	files := f.torrent.Files()
 	for i := range f.data.Progress {
 		selectIndex := f.meta.Opts.SelectFiles[i]
-		file := files[selectIndex]
+		file := f.torrent.Files()[selectIndex]
-		f.data.Progress[i] = verifiedFileBytes(verified, file.Offset(), file.Length())
+		f.data.Progress[i] = file.BytesCompleted()
 	}
 	return append(fetcher.Progress(nil), f.data.Progress...)
 }
 
-type verifiedByteRange struct {
-	start, end int64
-}
-
-func verifiedFileBytes(verified []verifiedByteRange, offset, length int64) int64 {
-	first := sort.Search(len(verified), func(i int) bool { return verified[i].end > offset })
-	fileEnd := offset + length
-	var completed int64
-	for _, run := range verified[first:] {
-		if run.start >= fileEnd {
-			break
-		}
-		completed += min(fileEnd, run.end) - max(offset, run.start)
-	}
-	return completed
-}
-
-func pieceVerified(state torrent.PieceState) bool {
-	return state.Ok && state.Complete && !state.Hashing && !state.QueuedForHash
-}
-
 func (f *Fetcher) Wait() error {
 	f.mu.Lock()
 	var closed <-chan struct{}
@@ -621,7 +587,7 @@ func (f *Fetcher) isDoneLocked() bool {
 		file := f.torrent.Files()[index]
 		for i := file.BeginPieceIndex(); i < file.EndPieceIndex(); i++ {
 			state := f.torrent.Piece(i).State()
-			if !pieceVerified(state) {
+			if !state.Ok || !state.Complete || state.Hashing || state.QueuedForHash {
 				return false
 			}
 		}
@@ -719,13 +685,11 @@ func (f *Fetcher) Upload() (err error) {
 }
 
 func (f *Fetcher) doUpload(fromUpload bool) {
-	f.mu.Lock()
 	if !f.torrentUpload.CompareAndSwap(false, true) {
-		f.mu.Unlock()
 		return
 	}
-	f.seedBaseBytes = f.data.SeedBytes
+	f.mu.Lock()
-	initialTime := f.data.SeedTime
+	initialBytes, initialTime := f.data.SeedBytes, f.data.SeedTime
 	torrentClosed := f.torrent.Closed()
 	f.mu.Unlock()
 	var doneTime int64
@@ -743,7 +707,8 @@ func (f *Fetcher) doUpload(fromUpload bool) {
 				f.mu.Unlock()
 				continue
 			}
-			f.refreshSeedBytesLocked()
+			stats := f.torrentStats()
+			f.data.SeedBytes = initialBytes + stats.BytesWrittenData.Int64()
 			if !fromUpload && !f.isDoneLocked() {
 				f.mu.Unlock()
 				continue
@@ -776,27 +741,9 @@ func (f *Fetcher) torrentStats() torrent.TorrentStats {
 func (f *Fetcher) UploadedBytes() int64 {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	if f.torrentReady.Load() && f.torrentUpload.Load() {
-		f.refreshSeedBytesLocked()
-	}
 	return f.data.SeedBytes
 }
 
-func (f *Fetcher) refreshSeedBytesLocked() {
-	stats := f.torrentStats()
-	f.data.SeedBytes = max(f.data.SeedBytes, f.seedBaseBytes+stats.BytesWrittenData.Int64())
-}
-
-func (f *Fetcher) ReceivedBytes() int64 {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	if !f.torrentReady.Load() {
-		return 0
-	}
-	stats := f.torrentStats()
-	return stats.BytesReadUsefulData.Int64()
-}
-
 func (f *Fetcher) WaitUpload() (err error) {
 	<-f.uploadDoneCh
 	return nil

internal/protocol/bt/fixture_test.go

@@ -46,11 +46,6 @@ func newBTHybridFixture(t testing.TB, payload []byte) *btFixture {
 }
 
 func makeBTFixture(t testing.TB, files map[string][]byte, bytesPerSecond int, v2, private bool) *btFixture {
-	t.Helper()
-	return makeBTFixtureWithPieceSize(t, files, bytesPerSecond, v2, private, 16*1024)
-}
-
-func makeBTFixtureWithPieceSize(t testing.TB, files map[string][]byte, bytesPerSecond int, v2, private bool, pieceSize int64) *btFixture {
 	t.Helper()
 	source := t.TempDir()
 	name := "payload.bin"
@@ -69,7 +64,7 @@ func makeBTFixtureWithPieceSize(t testing.TB, files map[string][]byte, bytesPerS
 		}
 		expected[filepath.Join(name, filepath.FromSlash(path))] = append([]byte(nil), data...)
 	}
-	info := metainfo.Info{PieceLength: pieceSize}
+	info := metainfo.Info{PieceLength: 16 * 1024}
 	if err := info.BuildFromFilePath(root); err != nil {
 		t.Fatal(err)
 	}

pkg/download/delete_lifecycle_test.go

@@ -0,0 +1,259 @@
+package download
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/GopeedLab/gopeed/internal/fetcher"
+	"github.com/GopeedLab/gopeed/pkg/base"
+)
+
+type deleteResolveManager struct {
+	*generationTestManager
+	returned chan struct{}
+}
+
+func (m *deleteResolveManager) Build() fetcher.Fetcher {
+	return &deleteResolveFetcher{generationTestFetcher: m.generationTestManager.Build().(*generationTestFetcher), returned: m.returned}
+}
+
+type deleteResolveFetcher struct {
+	*generationTestFetcher
+	returned chan struct{}
+}
+
+func (f *deleteResolveFetcher) Resolve(req *base.Request) error {
+	defer close(f.returned)
+	return f.generationTestFetcher.Resolve(req)
+}
+func waitDeleteTest(t *testing.T, ch <-chan struct{}) {
+	t.Helper()
+	select {
+	case <-ch:
+	case <-time.After(3 * time.Second):
+		t.Fatal("operation did not finish")
+	}
+}
+func TestDeleteDuringResolveCannotRestartOrPersist(t *testing.T) {
+	for _, force := range []bool{false, true} {
+		for _, resolveErr := range []error{nil, errors.New("late resolve error")} {
+			t.Run(fmt.Sprintf("force=%v/error=%v", force, resolveErr != nil), func(t *testing.T) {
+				release := make(chan struct{})
+				var once sync.Once
+				defer once.Do(func() { close(release) })
+				m := &deleteResolveManager{generationTestManager: &generationTestManager{resolveStarted: make(chan struct{}), resolveRelease: release, resolveErr: resolveErr}, returned: make(chan struct{})}
+				d := NewDownloader(&DownloaderConfig{Storage: NewMemStorage(), StorageDir: t.TempDir(), TempDir: t.TempDir(), FetchManagers: []fetcher.FetcherManager{m}})
+				if err := d.Setup(); err != nil {
+					t.Fatal(err)
+				}
+				defer d.Close()
+				id, err := d.CreateDirect(&base.Request{URL: "generation://delete"}, &base.Options{Path: t.TempDir(), Name: "delete.bin"})
+				if err != nil {
+					t.Fatal(err)
+				}
+				waitDeleteTest(t, m.resolveStarted)
+				task := d.GetTask(id)
+				if err := d.Delete(&TaskFilter{IDs: []string{id}}, force); err != nil {
+					t.Fatal(err)
+				}
+				once.Do(func() { close(release) })
+				waitDeleteTest(t, m.returned)
+				task.lock.Lock()
+				task.lock.Unlock()
+				// A stale error callback can run immediately after the startup handler exits.
+				d.doOnError(task, errors.New("late callback"))
+				if got := m.starts.Load(); got != 0 {
+					t.Errorf("deleted task started %d time(s)", got)
+				}
+				if d.GetTask(id) != nil {
+					t.Error("deleted task is still listed")
+				}
+				for _, bucket := range []string{bucketTask, bucketSave, bucketTaskStats} {
+					var value any
+					present, err := d.storage.Get(bucket, id, &value)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if present {
+						t.Errorf("deleted task resurrected in %s", bucket)
+					}
+				}
+			})
+		}
+	}
+}
+
+type blockedTaskStorage struct {
+	Storage
+	entered chan struct{}
+	release chan struct{}
+	blockID string
+	once    sync.Once
+}
+
+func (s *blockedTaskStorage) Put(bucket, key string, value any) error {
+	if bucket == bucketTask && key == s.blockID {
+		s.once.Do(func() { close(s.entered); <-s.release })
+	}
+	return s.Storage.Put(bucket, key, value)
+}
+func TestDeleteSerializesInFlightTaskCheckpoint(t *testing.T) {
+	s := &blockedTaskStorage{Storage: NewMemStorage(), entered: make(chan struct{}), release: make(chan struct{})}
+	d := NewDownloader(&DownloaderConfig{Storage: s, StorageDir: t.TempDir(), TempDir: t.TempDir(), FetchManagers: []fetcher.FetcherManager{&generationTestManager{}}})
+	if err := d.Setup(); err != nil {
+		t.Fatal(err)
+	}
+	defer d.Close()
+	d.cfg.MaxRunning = 0
+	id, err := d.CreateDirect(&base.Request{URL: "generation://checkpoint"}, &base.Options{Path: t.TempDir()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := d.GetTask(id)
+	s.blockID = id
+	saved := make(chan struct{})
+	go func() { defer close(saved); _ = d.saveTask(task) }()
+	waitDeleteTest(t, s.entered)
+	deleted := make(chan struct{})
+	go func() { defer close(deleted); _ = d.Delete(&TaskFilter{IDs: []string{id}}, false) }()
+	deadline := time.Now().Add(3 * time.Second)
+	for d.GetTask(id) != nil && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	close(s.release)
+	waitDeleteTest(t, saved)
+	waitDeleteTest(t, deleted)
+	var value any
+	present, err := s.Get(bucketTask, id, &value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if present {
+		t.Fatal("in-flight checkpoint restored a deleted task")
+	}
+}
+
+func TestDeleteDuringPreparationCannotStartOrPersist(t *testing.T) {
+	s := &blockedTaskStorage{Storage: NewMemStorage(), entered: make(chan struct{}), release: make(chan struct{})}
+	m := &generationTestManager{}
+	d := NewDownloader(&DownloaderConfig{Storage: s, StorageDir: t.TempDir(), TempDir: t.TempDir(), FetchManagers: []fetcher.FetcherManager{m}})
+	if err := d.Setup(); err != nil {
+		t.Fatal(err)
+	}
+	defer d.Close()
+	d.cfg.MaxRunning = 0
+	id, err := d.CreateDirect(&base.Request{URL: "generation://preparation"}, &base.Options{Path: t.TempDir()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := d.GetTask(id)
+	s.blockID = id
+	d.cfg.MaxRunning = 1
+	if err := d.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
+		t.Fatal(err)
+	}
+	waitDeleteTest(t, s.entered)
+	done := make(chan struct{})
+	go func() { defer close(done); _ = d.Delete(&TaskFilter{IDs: []string{id}}, true) }()
+	deadline := time.Now().Add(2 * time.Second)
+	for d.GetTask(id) != nil && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	close(s.release)
+	waitDeleteTest(t, done)
+	task.lock.Lock()
+	task.lock.Unlock()
+	if m.starts.Load() != 0 {
+		t.Fatal("deleted preparation started downloading")
+	}
+	var saved Task
+	if exists, err := s.Get(bucketTask, id, &saved); err != nil || exists {
+		t.Fatalf("deleted preparation persisted: exists=%v err=%v", exists, err)
+	}
+}
+func TestDeletedTaskRejectsLateSnapshotsAndCompletion(t *testing.T) {
+	d := NewDownloader(&DownloaderConfig{Storage: NewMemStorage(), StorageDir: t.TempDir(), TempDir: t.TempDir(), FetchManagers: []fetcher.FetcherManager{&generationTestManager{}}})
+	if err := d.Setup(); err != nil {
+		t.Fatal(err)
+	}
+	defer d.Close()
+	d.cfg.MaxRunning = 0
+	id, err := d.CreateDirect(&base.Request{URL: "generation://late"}, &base.Options{Path: t.TempDir()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := d.GetTask(id)
+	snapshot := task.clone()
+	task.fetcher.(*generationTestFetcher).stats = &fetcher.Stats{Snapshot: map[string]any{"bytes": 1}}
+	if err := d.Delete(&TaskFilter{IDs: []string{id}}, false); err != nil {
+		t.Fatal(err)
+	}
+	if err := d.putTaskRecord(task, snapshot); err != nil {
+		t.Fatal(err)
+	}
+	if err := d.captureTaskStats(task, false, true); err != nil {
+		t.Fatal(err)
+	}
+	if err := d.saveTask(task); err != nil {
+		t.Fatal(err)
+	}
+	if d.markTaskDone(task) {
+		t.Error("deleted task accepted a late completion")
+	}
+	for _, bucket := range []string{bucketTask, bucketSave, bucketTaskStats} {
+		var value any
+		if exists, err := d.storage.Get(bucket, id, &value); err != nil || exists {
+			t.Errorf("late callback restored %s: exists=%v err=%v", bucket, exists, err)
+		}
+	}
+}
+
+type singleFailureTaskDeleteStorage struct {
+	Storage
+	fail atomic.Bool
+}
+
+func (s *singleFailureTaskDeleteStorage) Delete(bucket, key string) error {
+	if bucket == bucketTask && s.fail.Swap(false) {
+		return errors.New("task deletion failed")
+	}
+	return s.Storage.Delete(bucket, key)
+}
+
+func TestFailedDeleteCanBeRetriedWithoutRevivingOldRun(t *testing.T) {
+	s := &singleFailureTaskDeleteStorage{Storage: NewMemStorage()}
+	m := &generationTestManager{holdOpen: true}
+	d := NewDownloader(&DownloaderConfig{Storage: s, StorageDir: t.TempDir(), TempDir: t.TempDir(), FetchManagers: []fetcher.FetcherManager{m}})
+	if err := d.Setup(); err != nil {
+		t.Fatal(err)
+	}
+	defer d.Close()
+	d.cfg.MaxRunning = 0
+	id, err := d.CreateDirect(&base.Request{URL: "generation://failed-delete"}, &base.Options{Path: t.TempDir()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	s.fail.Store(true)
+	if err := d.Delete(&TaskFilter{IDs: []string{id}}, false); err == nil {
+		t.Fatal("expected storage deletion failure")
+	}
+	task := d.GetTask(id)
+	if task == nil || d.taskStatus(task) != base.DownloadStatusWait {
+		t.Fatal("failed deletion did not restore queued task")
+	}
+	d.cfg.MaxRunning = 1
+	if err := d.Continue(&TaskFilter{IDs: []string{id}}); err != nil {
+		t.Fatal(err)
+	}
+	deadline := time.Now().Add(time.Second)
+	for m.starts.Load() < 1 && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	if m.starts.Load() != 1 {
+		t.Fatal("failed deletion could not be retried")
+	}
+}

pkg/download/downloader.go

@@ -345,12 +345,7 @@ func (d *Downloader) Setup() error {
 						}
 
 						current := task.fetcher.Progress().TotalDownloaded()
-						delta := max(0, current-task.Progress.Downloaded)
+						delta := current - task.Progress.Downloaded
-						if counter, ok := task.fetcher.(fetcher.DownloadCounter); ok && task.Status == base.DownloadStatusRunning {
-							received := counter.ReceivedBytes()
-							delta = received - task.receivedBytes
-							task.receivedBytes = received
-						}
 						if task.Meta != nil && task.Meta.Req != nil {
 							if producer := d.blob.Production(task.Meta.Req.URL); producer != nil {
 								downloaded, received := producer.Progress()
@@ -358,20 +353,19 @@ func (d *Downloader) Setup() error {
 									task.producer = producer
 									task.producerReceived = 0
 									task.speedArr = nil
-									task.downloadSampledAt = time.Time{}
 								}
 								current = downloaded
 								delta = max(0, received-task.producerReceived)
 								task.producerReceived = received
 							}
 						}
+						tick := float64(d.cfg.RefreshInterval) / 1000
 						downloadDataChanged := false
 						uploading := task.Uploading
 						if task.Status == base.DownloadStatusRunning {
 							downloadDataChanged = current != task.Progress.Downloaded
 							task.Progress.Used = task.timer.Used()
-							elapsed := sampleSeconds(&task.downloadSampledAt, time.Now())
+							task.Progress.Speed = task.updateSpeed(max(0, delta), tick)
-							task.Progress.Speed = task.updateSpeed(delta, elapsed)
 							task.Progress.Downloaded = current
 						}
 
@@ -380,8 +374,7 @@ func (d *Downloader) Setup() error {
 							uploader := task.fetcher.(fetcher.Uploader)
 							currentUploaded := uploader.UploadedBytes()
 							uploadDataChanged = currentUploaded != task.Progress.Uploaded
-							elapsed := sampleSeconds(&task.uploadSampledAt, time.Now())
+							task.Progress.UploadSpeed = task.updateUploadSpeed(currentUploaded-task.Progress.Uploaded, tick)
-							task.Progress.UploadSpeed = task.updateUploadSpeed(currentUploaded-task.Progress.Uploaded, elapsed)
 							task.Progress.Uploaded = currentUploaded
 						}
 						task.statusLock.Unlock()
@@ -515,7 +508,31 @@ func (d *Downloader) setupFetcher(fm fetcher.FetcherManager, fetcher fetcher.Fet
 	fetcher.Setup(ctl)
 }
 
+// putTaskValue serializes late progress/completion callbacks with deletion.
+// A snapshot may have been captured before Delete removed the task.
+func (d *Downloader) putTaskValue(task *Task, bucket string, value any) error {
+	if task.lifetime != nil {
+		task.lifetime.mu.Lock()
+		defer task.lifetime.mu.Unlock()
+		if task.lifetime.deleted.Load() {
+			return nil
+		}
+	}
+	return d.storage.Put(bucket, task.ID, value)
+}
+
+func (d *Downloader) putTaskRecord(task *Task, snapshot *Task) error {
+	return d.putTaskValue(task, bucketTask, snapshot)
+}
+
 func (d *Downloader) saveTask(task *Task) error {
+	if task.lifetime != nil {
+		task.lifetime.mu.Lock()
+		defer task.lifetime.mu.Unlock()
+		if task.lifetime.deleted.Load() {
+			return nil
+		}
+	}
 	data, err := task.fetcherManager.Store(task.fetcher)
 	if err != nil {
 		d.Logger.Error().Stack().Err(err).Msgf("serialize fetcher failed: %s", task.ID)
@@ -1227,7 +1244,7 @@ func (d *Downloader) Delete(filter *TaskFilter, force bool) error {
 	for _, task := range tasks {
 		if err := d.doDelete(task, force); err != nil {
 			// Deletion can fail after removing bucketTask. Keep recovery durable.
-			if saveErr := d.storage.Put(bucketTask, task.ID, task.clone()); saveErr != nil {
+			if saveErr := d.putTaskRecord(task, task.clone()); saveErr != nil {
 				d.Logger.Error().Err(saveErr).Msg("restore failed task deletion failed")
 				if firstErr == nil {
 					firstErr = saveErr
@@ -1419,7 +1436,7 @@ func (d *Downloader) captureTaskStats(task *Task, live, force bool) error {
 		return nil
 	}
 
-	if err := d.storage.Put(bucketTaskStats, task.ID, &storedTaskStats{Snapshot: snapshot}); err != nil {
+	if err := d.putTaskValue(task, bucketTaskStats, &storedTaskStats{Snapshot: snapshot}); err != nil {
 		return err
 	}
 	task.statsSnapshot = append(task.statsSnapshot[:0], snapshot...)
@@ -1525,6 +1542,18 @@ func (d *Downloader) RuntimeStatus(id string) (*TaskRuntimeStatus, error) {
 }
 
 func (d *Downloader) doDelete(task *Task, force bool) (err error) {
+	task.lifetime.deleted.Store(true)
+	task.statusLock.Lock()
+	task.runGeneration++
+	task.statusLock.Unlock()
+	task.lifetime.mu.Lock()
+	defer task.lifetime.mu.Unlock()
+	defer func() {
+		if err != nil {
+			// Keep failed deletions recoverable without validating the old run.
+			task.lifetime.deleted.Store(false)
+		}
+	}()
 	defer d.releaseBlobTask(task)
 	err = func() error {
 		if err := d.storage.Delete(bucketTask, task.ID); err != nil {
@@ -1882,7 +1911,7 @@ func (d *Downloader) watch(task *Task) {
 				// Check if the task is deleted
 				if d.GetTask(task.ID) != nil {
 					task.Uploading = false
-					d.storage.Put(bucketTask, task.ID, task.clone())
+					d.putTaskRecord(task, task.clone())
 				}
 			}()
 		}
@@ -1937,7 +1966,7 @@ func (d *Downloader) watch(task *Task) {
 		task.statusLock.Lock()
 		snapshot := task.clone()
 		task.statusLock.Unlock()
-		d.storage.Put(bucketTask, task.ID, snapshot)
+		d.putTaskRecord(task, snapshot)
 		d.emit(EventKeyDone, task)
 		d.emit(EventKeyFinally, task, err)
 		d.notifyRunning()
@@ -2080,7 +2109,7 @@ func (d *Downloader) handleOnError(task *Task, err error, resetFetcher bool) {
 		d.Logger.Warn().Err(statsErr).Msgf("persist failed task stats failed, task id: %s", task.ID)
 	}
 	if d.taskStatus(task) == base.DownloadStatusError {
-		if persistErr := d.storage.Put(bucketTask, task.ID, task.clone()); persistErr != nil {
+		if persistErr := d.putTaskRecord(task, task.clone()); persistErr != nil {
 			d.Logger.Error().Stack().Err(persistErr).Msgf("persist failed task failed, task id: %s", task.ID)
 		}
 	}
@@ -2208,7 +2237,7 @@ func (d *Downloader) doCreate(f fetcher.Fetcher, opts *base.Options, groupID str
 				return
 			}
 		}
-		if err = d.storage.Put(bucketTask, task.ID, task.clone()); err != nil {
+		if err = d.putTaskRecord(task, task.clone()); err != nil {
 			return
 		}
 		taskId = task.ID
@@ -2375,7 +2404,7 @@ func (d *Downloader) prepareTask(task *Task) error {
 func (d *Downloader) doStart(task *Task) (err error) {
 	var generation uint64
 	isReturn, err := d.statusMut(task, func() (isReturn bool, err error) {
-		if task.Status == base.DownloadStatusRunning || task.Status == base.DownloadStatusDone {
+		if task.lifetime.deleted.Load() || task.Status == base.DownloadStatusRunning || task.Status == base.DownloadStatusDone {
 			isReturn = true
 			return
 		}
@@ -2430,6 +2459,9 @@ func (d *Downloader) doStart(task *Task) (err error) {
 			if err != nil {
 				return err
 			}
+			if !d.taskIsRunningGeneration(task, generation) {
+				return nil
+			}
 			task.Meta.Res = task.fetcher.Meta().Res
 		}
 
@@ -2454,18 +2486,24 @@ func (d *Downloader) doStart(task *Task) (err error) {
 			return err
 		}
 
+		task.lifetime.mu.Lock()
+		if task.lifetime.deleted.Load() {
+			task.lifetime.mu.Unlock()
+			return nil
+		}
 		task.statusLock.Lock()
 		if task.Status != base.DownloadStatusRunning || task.runGeneration != generation {
+			task.lifetime.mu.Unlock()
 			task.statusLock.Unlock()
 			return nil
 		}
 		task.Progress.Speed = 0
-		task.speedArr = nil
-		task.downloadSampledAt = time.Time{}
 		task.timer.Start()
 		task.statusLock.Unlock()
-		if err := task.fetcher.Start(); err != nil {
+		startErr := task.fetcher.Start()
-			return err
+		task.lifetime.mu.Unlock()
+		if startErr != nil {
+			return startErr
 		}
 		started = true
 		if err := d.captureTaskStats(task, true, true); err != nil {
@@ -2576,7 +2614,7 @@ func (d *Downloader) runPauseHandler(task *Task, generation uint64, pauseFetcher
 			return false, err
 		}
 	} else {
-		if err := d.storage.Put(bucketTask, task.ID, task.clone()); err != nil {
+		if err := d.putTaskRecord(task, task.clone()); err != nil {
 			return false, err
 		}
 	}
@@ -2589,7 +2627,7 @@ func (d *Downloader) taskIsRunningGeneration(task *Task, generation uint64) bool
 	}
 	task.statusLock.Lock()
 	defer task.statusLock.Unlock()
-	return task.Status == base.DownloadStatusRunning && task.runGeneration == generation
+	return !task.lifetime.deleted.Load() && task.Status == base.DownloadStatusRunning && task.runGeneration == generation
 }
 
 func (d *Downloader) taskIsPausedGeneration(task *Task, generation uint64) bool {
@@ -2598,7 +2636,7 @@ func (d *Downloader) taskIsPausedGeneration(task *Task, generation uint64) bool
 	}
 	task.statusLock.Lock()
 	defer task.statusLock.Unlock()
-	return (task.Status == base.DownloadStatusPause || task.Status == base.DownloadStatusWait) && task.runGeneration == generation
+	return !task.lifetime.deleted.Load() && (task.Status == base.DownloadStatusPause || task.Status == base.DownloadStatusWait) && task.runGeneration == generation
 }
 
 func (d *Downloader) taskStatus(task *Task) base.Status {
@@ -2618,7 +2656,7 @@ func (d *Downloader) markTaskDone(task *Task) bool {
 	defer task.lock.Unlock()
 	task.statusLock.Lock()
 	defer task.statusLock.Unlock()
-	if task.Status != base.DownloadStatusRunning {
+	if task.lifetime.deleted.Load() || task.Status != base.DownloadStatusRunning {
 		return false
 	}
 	task.Progress.Used = task.timer.Used()
@@ -2646,7 +2684,7 @@ func (d *Downloader) markTaskError(task *Task) bool {
 	}
 	task.statusLock.Lock()
 	defer task.statusLock.Unlock()
-	if task.Status != base.DownloadStatusRunning {
+	if task.lifetime.deleted.Load() || task.Status != base.DownloadStatusRunning {
 		return false
 	}
 	task.updateStatus(base.DownloadStatusError)
@@ -2707,7 +2745,7 @@ func (d *Downloader) enqueueSingleExtraction(task *Task, downloadFilePath string
 	// Set extraction status to queued
 	task.Progress.ExtractStatus = ExtractStatusQueued
 	d.emit(EventKeyProgress, task)
-	d.storage.Put(bucketTask, task.ID, task.clone())
+	d.putTaskRecord(task, task.clone())
 	d.Logger.Info().Msgf("extraction queued, task id: %s, job id: %s", task.ID, jobID)
 
 	// Create and enqueue the extraction job
@@ -2736,7 +2774,7 @@ func (d *Downloader) enqueueMultiPartExtraction(task *Task, downloadFilePath str
 		// Not all parts are ready yet - just set status to waiting, don't queue anything
 		task.Progress.ExtractStatus = ExtractStatusWaitingParts
 		d.emit(EventKeyProgress, task)
-		d.storage.Put(bucketTask, task.ID, task.clone())
+		d.putTaskRecord(task, task.clone())
 		d.Logger.Info().Msgf("multi-part archive waiting for other parts, task id: %s, missing: %v", task.ID, missingParts)
 		return
 	}
@@ -2752,14 +2790,14 @@ func (d *Downloader) enqueueMultiPartExtraction(task *Task, downloadFilePath str
 		task.Progress.ExtractStatus = ExtractStatusDone
 		task.Progress.ExtractProgress = 100
 		d.emit(EventKeyProgress, task)
-		d.storage.Put(bucketTask, task.ID, task.clone())
+		d.putTaskRecord(task, task.clone())
 		d.Logger.Info().Msgf("multi-part archive extraction already handled by another part, task id: %s", task.ID)
 		return
 	}
 
 	// This task claimed the extraction - status already set to queued in tryClaimMultiPartExtraction
 	d.emit(EventKeyProgress, task)
-	d.storage.Put(bucketTask, task.ID, task.clone())
+	d.putTaskRecord(task, task.clone())
 
 	jobID := "multipart:" + fullBaseName
 	d.Logger.Info().Msgf("multi-part extraction queued, task id: %s, job id: %s", task.ID, jobID)
@@ -2848,7 +2886,7 @@ func (d *Downloader) performExtraction(task *Task, archivePath string, destDir s
 	task.Progress.ExtractStatus = ExtractStatusExtracting
 	task.Progress.ExtractProgress = 0
 	d.emit(EventKeyProgress, task)
-	d.storage.Put(bucketTask, task.ID, task.clone())
+	d.putTaskRecord(task, task.clone())
 
 	// Extract the archive
 	extractErr := extractArchive(archivePath, destDir, opts.ArchivePassword, func(extractedFiles int, totalFiles int, progress int) {
@@ -2868,7 +2906,7 @@ func (d *Downloader) performMultiPartExtraction(task *Task, firstPartPath string
 	task.Progress.ExtractStatus = ExtractStatusExtracting
 	task.Progress.ExtractProgress = 0
 	d.emit(EventKeyProgress, task)
-	d.storage.Put(bucketTask, task.ID, task.clone())
+	d.putTaskRecord(task, task.clone())
 
 	d.Logger.Info().Msgf("starting multi-part archive extraction, first part: %s, task id: %s", firstPartPath, task.ID)
 
@@ -3012,13 +3050,13 @@ func (d *Downloader) handleExtractionResult(task *Task, extractErr error, archiv
 		d.Logger.Error().Err(extractErr).Msgf("auto extract archive failed, task id: %s", task.ID)
 		task.Progress.ExtractStatus = ExtractStatusError
 		d.emit(EventKeyProgress, task)
-		d.storage.Put(bucketTask, task.ID, task.clone())
+		d.putTaskRecord(task, task.clone())
 	} else {
 		d.Logger.Info().Msgf("auto extract archive completed, task id: %s", task.ID)
 		task.Progress.ExtractStatus = ExtractStatusDone
 		task.Progress.ExtractProgress = 100
 		d.emit(EventKeyProgress, task)
-		d.storage.Put(bucketTask, task.ID, task.clone())
+		d.putTaskRecord(task, task.clone())
 
 		// Delete archive files after successful extraction if enabled
 		if deleteAfterExtract {
@@ -3058,22 +3096,23 @@ func (d *Downloader) updateMultiPartTasksStatus(sourceTask *Task, extractErr err
 			task.Progress.ExtractStatus = status
 			task.Progress.ExtractProgress = progress
 			d.emit(EventKeyProgress, task)
-			d.storage.Put(bucketTask, task.ID, task.clone())
+			d.putTaskRecord(task, task.clone())
 		}
 	}
 }
 
 func initTask(task *Task) {
+	if task.lifetime == nil {
+		task.lifetime = &taskLifetime{}
+	}
 	task.timer = util.NewTimer(task.Progress.Used)
 
 	task.statusLock = &sync.Mutex{}
 	task.lock = &sync.Mutex{}
 	task.statsLock = &sync.Mutex{}
 	task.blobRefLock = &sync.Mutex{}
-	task.speedArr = nil
+	task.speedArr = make([]int64, 0)
-	task.uploadSpeedArr = nil
+	task.uploadSpeedArr = make([]int64, 0)
-	task.downloadSampledAt = time.Time{}
-	task.uploadSampledAt = time.Time{}
 }
 
 func (d *Downloader) releaseBlobTask(task *Task) {

pkg/download/model.go

@@ -3,6 +3,7 @@ package download
 import (
 	"encoding/json"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/GopeedLab/gopeed/internal/controller"
@@ -46,6 +47,14 @@ type CreateTaskBatchResult struct {
 // Task represents a download unit.
 // Options flow path:
 // REST Request (model.CreateTask/ResolveTask) -> pkg/download Downloader -> Task.Meta.Opts (base.Options) -> Fetcher.Resolve/Start (e.g. internal/protocol/http/fetcher.go)
+// taskLifetime is shared with preparation candidates. Its mutex serializes
+// physical starts and persistence with deletion; the tombstone also invalidates
+// work that is currently outside that mutex (for example Resolve).
+type taskLifetime struct {
+	mu      sync.Mutex
+	deleted atomic.Bool
+}
+
 type Task struct {
 	ID       string               `json:"id"`
 	Protocol string               `json:"protocol"`
@@ -87,11 +96,9 @@ type Task struct {
 	blobRefLock    *sync.Mutex
 	blobURL        string
 	runGeneration  uint64
-	speedArr          []speedSample
+	lifetime       *taskLifetime
-	uploadSpeedArr    []speedSample
+	speedArr       []int64
-	downloadSampledAt time.Time
+	uploadSpeedArr []int64
-	uploadSampledAt   time.Time
-	receivedBytes     int64
 }
 
 // TaskRuntimeStatus is the lightweight, frequently refreshed view of a task.
@@ -126,6 +133,7 @@ func NewTask() *Task {
 	}
 	return &Task{
 		ID:        id,
+		lifetime:  &taskLifetime{},
 		Status:    base.DownloadStatusReady,
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
@@ -198,21 +206,7 @@ func (t *Task) updateUploadSpeed(downloaded int64, usedTime float64) int64 {
 	return calcSpeed(&t.uploadSpeedArr, downloaded, usedTime)
 }
 
-type speedSample struct {
+func calcSpeed(speedArr *[]int64, downloaded int64, usedTime float64) int64 {
-	bytes   int64
-	seconds float64
-}
-
-func sampleSeconds(lastSample *time.Time, now time.Time) float64 {
-	previous := *lastSample
-	*lastSample = now
-	if previous.IsZero() {
-		return 0
-	}
-	return now.Sub(previous).Seconds()
-}
-
-func calcSpeed(speedArr *[]speedSample, downloaded int64, usedTime float64) int64 {
 	if usedTime <= 0 {
 		return 0
 	}
@@ -221,18 +215,18 @@ func calcSpeed(speedArr *[]speedSample, downloaded int64, usedTime float64) int6
 		return 0
 	}
 
-	*speedArr = append(*speedArr, speedSample{bytes: downloaded, seconds: usedTime})
+	*speedArr = append(*speedArr, downloaded)
-	var total int64
+	// Record last 5 seconds of download speed to calculate the average speed
-	var elapsed float64
+	if len(*speedArr) > int(5.0/usedTime) {
-	first := len(*speedArr)
+		*speedArr = (*speedArr)[1:]
-	for first > 0 && elapsed < 5 {
-		first--
-		sample := (*speedArr)[first]
-		total += sample.bytes
-		elapsed += sample.seconds
 	}
-	*speedArr = (*speedArr)[first:]
+
-	return int64(float64(total) / elapsed)
+	var total int64
+	for _, v := range *speedArr {
+		total += v
+	}
+
+	return int64(float64(total) / float64(len(*speedArr)) / usedTime)
 }
 
 type TaskFilter struct {

pkg/download/model_test.go

@@ -1,32 +1,9 @@
 package download
 
-import (
+import "testing"
-	"testing"
-	"time"
-)
-
-func TestTransferSpeedWithUnevenSamples(t *testing.T) {
-	var task Task
-	for _, sample := range []struct {
-		bytes   int64
-		seconds float64
-	}{
-		{1000, 1},
-		{2000, 2},
-		{4000, 4},
-		{6000, 6},
-	} {
-		if got := task.updateSpeed(sample.bytes, sample.seconds); got != 1000 {
-			t.Errorf("download speed after %v seconds = %d, want 1000", sample.seconds, got)
-		}
-		if got := task.updateUploadSpeed(sample.bytes, sample.seconds); got != 1000 {
-			t.Errorf("upload speed after %v seconds = %d, want 1000", sample.seconds, got)
-		}
-	}
-}
 
 func TestCalcSpeedResetOnRollback(t *testing.T) {
-	speedArr := []speedSample{{1024, 1}, {2048, 1}, {4096, 1}}
+	speedArr := []int64{1024, 2048, 4096}
 
 	if got := calcSpeed(&speedArr, -512, 1); got != 0 {
 		t.Fatalf("calcSpeed() = %d, want 0 after rollback", got)
@@ -39,17 +16,3 @@ func TestCalcSpeedResetOnRollback(t *testing.T) {
 		t.Fatalf("calcSpeed() = %d, want 1024 after reset", got)
 	}
 }
-
-func TestSampleSecondsUsesThePreviousSuccessfulSample(t *testing.T) {
-	start := time.Now()
-	var last time.Time
-	if got := sampleSeconds(&last, start); got != 0 {
-		t.Fatalf("first sample elapsed = %v, want 0", got)
-	}
-	if got := sampleSeconds(&last, start.Add(1500*time.Millisecond)); got != 1.5 {
-		t.Fatalf("elapsed after a delayed sample = %v, want 1.5", got)
-	}
-	if got := sampleSeconds(&last, start.Add(2*time.Second)); got != 0.5 {
-		t.Fatalf("elapsed after the next sample = %v, want 0.5", got)
-	}
-}

ui/flutter/lib/app/application/app_runtime_controller.dart

@@ -53,7 +53,6 @@ class AppRuntimeState {
 class AppRuntimeController extends AsyncNotifier<AppRuntimeState> {
   static StartConfig? _defaultStartConfig;
   Future<void> _preferenceWrites = Future<void>.value();
-  bool _analyticsStarted = false;
 
   @override
   Future<AppRuntimeState> build() async {
@@ -74,7 +73,6 @@ class AppRuntimeController extends AsyncNotifier<AppRuntimeState> {
       startConfig
         ..apiEnable = true
         ..mcpEnable = config.api.mcpEnable;
-      await _initAnalytics(config);
     } else {
       startConfig
         ..apiEnable = config.api.enable
@@ -255,8 +253,7 @@ class AppRuntimeController extends AsyncNotifier<AppRuntimeState> {
   }
 
   Future<void> _initAnalytics(DownloaderConfig config) async {
-    if (_analyticsStarted || !AnalyticsConfig.isConfigured || !config.extra.analyticsEnabled) return;
+    if (!AnalyticsConfig.isConfigured || !config.extra.analyticsEnabled) return;
-    _analyticsStarted = true;
     try {
       final generatedClientId = await Analytics.instance.init(fallbackClientId: config.extra.deviceId);
       if (generatedClientId != null) {
@@ -265,7 +262,6 @@ class AppRuntimeController extends AsyncNotifier<AppRuntimeState> {
       }
       unawaited(Analytics.instance.logAppOpen());
     } catch (error, stackTrace) {
-      _analyticsStarted = false;
       logger.w('GA4 init failed', error, stackTrace);
     }
   }

ui/flutter/lib/app/application/downloader_config_init.dart

@@ -19,7 +19,7 @@ Future<DownloaderConfig> loadDownloaderConfig({
     config = await load();
   } catch (error, stackTrace) {
     onLoadError?.call(error, stackTrace);
-    config = DownloaderConfig()..extra.analyticsEnabled = false;
+    config = DownloaderConfig();
     loaded = false;
   }
   final changed = await initDownloaderConfig(config, defaultDownloadDir: defaultDownloadDir);

ui/flutter/test/app/application/downloader_config_init_test.dart

@@ -32,22 +32,8 @@ void main() {
       // The in-memory fallback still gets usable defaults.
       expect(config.downloadDir, '/downloads');
       expect(config.categories, hasLength(4));
-      expect(config.extra.analyticsEnabled, isFalse);
     });
 
-    for (final analyticsEnabled in [false, true]) {
-      test('preserves the saved analytics preference ($analyticsEnabled)', () async {
-        final stored = configWith()..extra.analyticsEnabled = analyticsEnabled;
-        final config = await loadDownloaderConfig(
-          load: () async => stored,
-          save: (_) async {},
-          defaultDownloadDir: () async => '/downloads',
-        );
-
-        expect(config.extra.analyticsEnabled, analyticsEnabled);
-      });
-    }
-
     test('skips persist when init changed nothing', () async {
       var saved = 0;
       await loadDownloaderConfig(