feat: new ui (#1455)

This commit is contained in:
Levi authored and GitHub committed 2026-09-05 19:53:41 +08:00
1 parent 3be8db664c
commit 177c225f16
742 files changed
+59951 -5934

No files matched your search

+198 -8
View File
@@ -18,6 +18,7 @@ import (
"github.com/GopeedLab/gopeed/pkg/base"
"github.com/GopeedLab/gopeed/pkg/protocol/bt"
"github.com/GopeedLab/gopeed/pkg/util"
"github.com/RoaringBitmap/roaring"
"github.com/anacrolix/torrent"
"github.com/anacrolix/torrent/metainfo"
"github.com/anacrolix/torrent/storage"
@@ -162,20 +163,209 @@ func (f *Fetcher) Meta() *fetcher.FetcherMeta {
return f.meta
}
func (f *Fetcher) Stats() any {
func (f *Fetcher) Stats() *fetcher.Stats {
var stats torrent.TorrentStats
var pieceMap *base.PieceMap
pieceMapReady := false
peers := make([]*base.PeerStats, 0)
if f.torrent != nil {
stats = f.torrent.Stats()
pieceMap, pieceMapReady = buildBTPieceMap(f.torrent)
peers = buildBTPeers(f.torrent)
} else {
stats = torrent.TorrentStats{}
}
return &bt.Stats{
TotalPeers: stats.TotalPeers,
ActivePeers: stats.ActivePeers,
ConnectedSeeders: stats.ConnectedSeeders,
SeedBytes: f.data.SeedBytes,
SeedRatio: f.seedRadio(),
SeedTime: f.data.SeedTime,
var snapshot any
if pieceMapReady {
snapshot = &bt.StatsSnapshot{
SeedBytes: f.data.SeedBytes,
SeedRatio: f.seedRadio(),
SeedTime: f.data.SeedTime,
PieceMap: pieceMap.Clone(),
}
}
// When completion is temporarily unknown while anacrolix restores storage
// or verifies pieces, the nil Snapshot tells Downloader to retain the last
// trusted bitset instead of replacing it with an all-empty map.
return &fetcher.Stats{
Snapshot: snapshot,
Runtime: &bt.StatsRuntime{
TotalPeers: stats.TotalPeers,
ActivePeers: stats.ActivePeers,
ConnectedSeeders: stats.ConnectedSeeders,
ConnectedLeechers: stats.ActivePeers - stats.ConnectedSeeders,
Peers: peers,
},
}
}
// buildBTPieceMap converts anacrolix's ordered completion runs to Gopeed's
// one-bit map. ready is false until storage knows the completion state of every
// piece; this prevents initial hash checking from briefly replacing a restored
// map with an all-empty value.
func buildBTPieceMap(t *torrent.Torrent) (pieceMap *base.PieceMap, ready bool) {
info := t.Info()
if info == nil {
return nil, false
}
pieceMap = base.NewPieceMap(info.NumPieces(), info.PieceLength)
ready = applyBTPieceRuns(pieceMap, t.PieceStateRuns())
return pieceMap, ready
}
func applyBTPieceRuns(pieceMap *base.PieceMap, runs []torrent.PieceStateRun) (ready bool) {
ready = true
pieceIndex := 0
for _, run := range runs {
if !run.Ok {
ready = false
}
completed := run.Ok && run.Complete
for range run.Length {
if pieceIndex >= pieceMap.PieceCount() {
return ready
}
_ = pieceMap.Update(pieceIndex, completed)
pieceIndex++
}
}
return ready && pieceIndex == pieceMap.PieceCount()
}
func buildBTPeers(t *torrent.Torrent) []*base.PeerStats {
connections := t.PeerConns()
totalPieces := 0
var missingWantedPieces *roaring.Bitmap
// Magnet torrents can connect to peers before their metadata arrives. Keep
// those runtime peer stats, but leave completion and relevance unavailable
// until the metadata provides a trusted total piece count.
if info := t.Info(); info != nil {
totalPieces = info.NumPieces()
missingWantedPieces = btMissingWantedPieces(t.PieceStateRuns(), totalPieces)
}
peers := make([]*base.PeerStats, 0, len(connections))
for _, connection := range connections {
peerStats := connection.Stats()
peers = append(peers, &base.PeerStats{
Address: safeBTPeerAddress(connection),
Client: btPeerClient(connection),
DownloadSpeed: int64(peerStats.DownloadRate),
UploadSpeed: int64(peerStats.LastWriteUploadRate),
PieceCount: peerStats.RemotePieceCount,
Completion: btPeerCompletion(peerStats.RemotePieceCount, totalPieces),
Relevance: btPeerRelevance(connection.PeerPieces(), missingWantedPieces),
Source: normalizeBTPeerSource(connection.Discovery),
Transport: normalizeBTTransport(connection.Network),
})
}
return peers
}
// btPeerCompletion converts anacrolix's remote piece count into the ratio the
// API exposes. A nil value distinguishes unavailable metadata from a real 0%.
func btPeerCompletion(pieceCount, totalPieces int) *float64 {
if totalPieces <= 0 {
return nil
}
if pieceCount < 0 {
pieceCount = 0
} else if pieceCount > totalPieces {
pieceCount = totalPieces
}
completion := float64(pieceCount) / float64(totalPieces)
return &completion
}
// btMissingWantedPieces builds the denominator used by peer relevance. Pieces
// belonging only to skipped files are excluded because their priority is none.
func btMissingWantedPieces(runs []torrent.PieceStateRun, totalPieces int) *roaring.Bitmap {
if totalPieces <= 0 {
return nil
}
missing := roaring.New()
pieceIndex := 0
for _, run := range runs {
for range run.Length {
if pieceIndex >= totalPieces {
return nil
}
if run.Priority != torrent.PiecePriorityNone && !(run.Ok && run.Complete) {
missing.Add(uint32(pieceIndex))
}
pieceIndex++
}
}
if pieceIndex != totalPieces {
return nil
}
return missing
}
// btPeerRelevance reports how much of the local wanted, missing set the remote
// peer can provide. A zero value is meaningful; nil means there is no denominator.
func btPeerRelevance(peerPieces, missingWantedPieces *roaring.Bitmap) *float64 {
if peerPieces == nil || missingWantedPieces == nil || missingWantedPieces.IsEmpty() {
return nil
}
relevantPieces := roaring.And(peerPieces, missingWantedPieces).GetCardinality()
relevance := float64(relevantPieces) / float64(missingWantedPieces.GetCardinality())
return &relevance
}
// A uTP socket may close between PeerConns and this snapshot. Some uTP address
// implementations panic after close, so one disappearing address must not make
// the entire stats endpoint fail.
func safeBTPeerAddress(connection *torrent.PeerConn) (address string) {
defer func() {
if recover() != nil {
address = ""
}
}()
if connection.RemoteAddr == nil {
return ""
}
return connection.RemoteAddr.String()
}
func btPeerClient(connection *torrent.PeerConn) string {
value := connection.PeerClientName.Load()
if value == nil {
return ""
}
return fmt.Sprint(value)
}
func normalizeBTPeerSource(source torrent.PeerSource) string {
switch source {
case torrent.PeerSourceTracker:
return "tracker"
case torrent.PeerSourceDhtGetPeers, torrent.PeerSourceDhtAnnouncePeer:
return "dht"
case torrent.PeerSourcePex:
return "pex"
case torrent.PeerSourceIncoming:
return "incoming"
case torrent.PeerSourceDirect:
return "direct"
case torrent.PeerSourceUtHolepunch:
return "holepunch"
default:
return "unknown"
}
}
func normalizeBTTransport(network string) string {
network = strings.ToLower(network)
switch {
case strings.Contains(network, "webrtc"):
return "webrtc"
case strings.Contains(network, "udp"):
// anacrolix labels uTP sockets with their underlying udp network.
return "utp"
case strings.Contains(network, "tcp"):
return "tcp"
default:
return "unknown"
}
}
+199
View File
@@ -0,0 +1,199 @@
package bt
import (
"testing"
"github.com/GopeedLab/gopeed/internal/fetcher"
"github.com/GopeedLab/gopeed/pkg/base"
protocolbt "github.com/GopeedLab/gopeed/pkg/protocol/bt"
"github.com/RoaringBitmap/roaring"
"github.com/anacrolix/torrent"
"github.com/anacrolix/torrent/storage"
)
func TestStatsSeparatesSnapshotAndRuntime(t *testing.T) {
frame := (&Fetcher{
meta: &fetcher.FetcherMeta{Res: &base.Resource{Size: 256}},
data: &fetcherData{SeedBytes: 128, SeedTime: 64},
}).Stats()
if frame.Snapshot != nil {
t.Fatalf("snapshot = %T, want nil until piece completion is known", frame.Snapshot)
}
runtime, ok := frame.Runtime.(*protocolbt.StatsRuntime)
if !ok {
t.Fatalf("runtime type = %T", frame.Runtime)
}
if len(runtime.Peers) != 0 || runtime.TotalPeers != 0 {
t.Fatalf("unexpected runtime: %+v", runtime)
}
}
func TestStatsBeforeTorrentMetadataIsAvailable(t *testing.T) {
config := torrent.TestingConfig(t)
config.DisableTCP = true
config.DisableUTP = true
client, err := torrent.NewClient(config)
if err != nil {
t.Fatal(err)
}
defer client.Close()
torrentWithoutMetadata, err := client.AddMagnet(
"magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567",
)
if err != nil {
t.Fatal(err)
}
if info := torrentWithoutMetadata.Info(); info != nil {
t.Fatalf("torrent info = %+v, want nil before metadata is available", info)
}
frame := (&Fetcher{
torrent: torrentWithoutMetadata,
meta: &fetcher.FetcherMeta{},
data: &fetcherData{},
}).Stats()
if frame.Snapshot != nil {
t.Fatalf("snapshot = %T, want nil before metadata is available", frame.Snapshot)
}
runtime, ok := frame.Runtime.(*protocolbt.StatsRuntime)
if !ok {
t.Fatalf("runtime type = %T", frame.Runtime)
}
if len(runtime.Peers) != 0 || runtime.TotalPeers != 0 {
t.Fatalf("unexpected runtime before metadata is available: %+v", runtime)
}
}
func TestApplyBTPieceRunsPublishesVerifiedCompletionOnly(t *testing.T) {
pieceMap := base.NewPieceMap(4, 1024)
ready := applyBTPieceRuns(pieceMap, []torrent.PieceStateRun{
{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
{PieceState: torrent.PieceState{Completion: torrentCompletion(true, false), Partial: true}, Length: 2},
{PieceState: torrent.PieceState{Completion: torrentCompletion(false, false), Hashing: true}, Length: 1},
})
if ready {
t.Fatal("piece map became ready while one completion is unknown")
}
want := []bool{true, false, false, false}
for index, expected := range want {
got, err := pieceMap.Get(index)
if err != nil || got != expected {
t.Fatalf("piece %d = %v, %v; want %v", index, got, err, expected)
}
}
knownMap := base.NewPieceMap(2, 1024)
if !applyBTPieceRuns(knownMap, []torrent.PieceStateRun{
{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
{PieceState: torrent.PieceState{Completion: torrentCompletion(true, false)}, Length: 1},
}) {
t.Fatal("fully known completion map was not ready")
}
if applyBTPieceRuns(base.NewPieceMap(2, 1024), []torrent.PieceStateRun{
{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
}) {
t.Fatal("incomplete piece runs were published")
}
}
func torrentCompletion(ok, complete bool) storage.Completion {
return storage.Completion{Ok: ok, Complete: complete}
}
func TestNormalizeBTPeerMetadata(t *testing.T) {
if got := normalizeBTPeerSource(torrent.PeerSourceDhtGetPeers); got != "dht" {
t.Fatalf("DHT source = %q", got)
}
if got := normalizeBTPeerSource(torrent.PeerSourcePex); got != "pex" {
t.Fatalf("PEX source = %q", got)
}
transports := map[string]string{
"udp4": "utp",
"udp6": "utp",
"tcp4": "tcp",
"tcp6": "tcp",
"webrtc": "webrtc",
"unix": "unknown",
}
for network, want := range transports {
if got := normalizeBTTransport(network); got != want {
t.Errorf("normalizeBTTransport(%q) = %q, want %q", network, got, want)
}
}
}
func TestBTPeerCompletion(t *testing.T) {
if got := btPeerCompletion(1, 4); got == nil || *got != 0.25 {
t.Fatalf("completion = %v, want 0.25", got)
}
if got := btPeerCompletion(5, 4); got == nil || *got != 1 {
t.Fatalf("clamped completion = %v, want 1", got)
}
if got := btPeerCompletion(-1, 4); got == nil || *got != 0 {
t.Fatalf("negative completion = %v, want 0", got)
}
if got := btPeerCompletion(0, 0); got != nil {
t.Fatalf("completion without metadata = %v, want nil", *got)
}
}
func TestBTPeerRelevanceUsesWantedMissingPieces(t *testing.T) {
missing := btMissingWantedPieces([]torrent.PieceStateRun{
{
PieceState: torrent.PieceState{
Completion: torrentCompletion(true, true),
Priority: torrent.PiecePriorityNormal,
},
Length: 2,
},
{
PieceState: torrent.PieceState{
Completion: torrentCompletion(true, false),
Priority: torrent.PiecePriorityNormal,
},
Length: 2,
},
{
PieceState: torrent.PieceState{
Completion: torrentCompletion(true, false),
Priority: torrent.PiecePriorityNone,
},
Length: 2,
},
}, 6)
if missing == nil || !missing.Equals(roaring.BitmapOf(2, 3)) {
t.Fatalf("missing wanted pieces = %v, want {2, 3}", missing)
}
if got := btPeerRelevance(roaring.BitmapOf(0, 2, 4), missing); got == nil || *got != 0.5 {
t.Fatalf("relevance = %v, want 0.5", got)
}
if got := btPeerRelevance(roaring.BitmapOf(0, 1, 4), missing); got == nil || *got != 0 {
t.Fatalf("zero relevance = %v, want 0", got)
}
if got := btPeerRelevance(roaring.BitmapOf(2, 3), roaring.New()); got != nil {
t.Fatalf("relevance with no missing pieces = %v, want nil", *got)
}
if got := btMissingWantedPieces(nil, 6); got != nil {
t.Fatalf("incomplete piece states = %v, want nil", got)
}
}
func TestBTPeerRelevanceTracksRemainingDownload(t *testing.T) {
missing := roaring.BitmapOf(90, 91, 92, 93, 94, 95, 96, 97, 98, 99)
if got := btPeerRelevance(missing.Clone(), missing); got == nil || *got != 1 {
t.Fatalf("peer covering every missing piece = %v, want 1", got)
}
oneRelevantPiece := roaring.BitmapOf(90)
if got := btPeerRelevance(oneRelevantPiece, missing); got == nil || *got != 0.1 {
t.Fatalf("peer covering one of ten missing pieces = %v, want 0.1", got)
}
missingAfterTransfer := missing.Clone()
missingAfterTransfer.Remove(90)
if got := btPeerRelevance(oneRelevantPiece, missingAfterTransfer); got == nil || *got != 0 {
t.Fatalf("peer after transferring its only relevant piece = %v, want 0", got)
}
}