"strconv"
"strings"
- "github.com/anacrolix/missinggo/pubsub"
+ "github.com/anacrolix/chansync/events"
+ "github.com/anacrolix/missinggo/v2/pubsub"
"github.com/anacrolix/sync"
"github.com/anacrolix/torrent/metainfo"
}
// Returns a channel that is closed when the info (.Info()) for the torrent has become available.
-func (t *Torrent) GotInfo() (ret <-chan struct{}) {
- // TODO: We shouldn't need to lock to take a channel here, if the event is only ever set.
- t.nameMu.RLock()
- ret = t.gotMetainfoC
- t.nameMu.RUnlock()
- return
+func (t *Torrent) GotInfo() events.Done {
+ return t.gotMetainfoC
}
// Returns the metainfo info dictionary, or nil if it's not yet available.
// Returns a Reader bound to the torrent's data. All read calls block until the data requested is
// actually available. Note that you probably want to ensure the Torrent Info is available first.
func (t *Torrent) NewReader() Reader {
- return t.newReader(0, *t.length)
+ return t.newReader(0, t.length())
}
func (t *Torrent) newReader(offset, length int64) Reader {
offset: offset,
length: length,
}
- r.readaheadFunc = r.defaultReadaheadFunc
+ r.readaheadFunc = defaultReadaheadFunc
t.addReader(&r)
return &r
}
t.cl.rLock()
ps = t.pieceState(piece)
t.cl.rUnlock()
- return
+ return
}
// The number of pieces in the torrent. This requires that the info has been
// Get missing bytes count for specific piece.
func (t *Torrent) PieceBytesMissing(piece int) int64 {
- t.cl.lock()
- defer t.cl.unlock()
+ t.cl.rLock()
+ defer t.cl.rUnlock()
return int64(t.pieces[piece].bytesLeft())
}
// The subscription emits as (int) the index of pieces as their state changes.
// A state change is when the PieceState for a piece alters in value.
-func (t *Torrent) SubscribePieceStateChanges() *pubsub.Subscription {
+func (t *Torrent) SubscribePieceStateChanges() *pubsub.Subscription[PieceStateChange] {
return t.pieceStateChanges.Subscribe()
}
// Returns true if the torrent is currently being seeded. This occurs when the
// client is willing to upload without wanting anything in return.
-func (t *Torrent) Seeding() bool {
- t.cl.lock()
- defer t.cl.unlock()
- return t.seeding()
+func (t *Torrent) Seeding() (ret bool) {
+ t.cl.rLock()
+ ret = t.seeding()
+ t.cl.rUnlock()
+ return
}
// Clobbers the torrent display name if metainfo is unavailable.
// The completed length of all the torrent data, in all its files. This is
// derived from the torrent info, when it is available.
func (t *Torrent) Length() int64 {
- return *t.length
+ return t._length.Value
}
// Returns a run-time generated metainfo for the torrent that includes the
// info bytes and announce-list as currently known to the client.
func (t *Torrent) Metainfo() metainfo.MetaInfo {
- t.cl.lock()
- defer t.cl.unlock()
+ t.cl.rLock()
+ defer t.cl.rUnlock()
return t.newMetaInfo()
}
func (t *Torrent) downloadPiecesLocked(begin, end pieceIndex) {
for i := begin; i < end; i++ {
if t.pieces[i].priority.Raise(PiecePriorityNormal) {
- t.updatePiecePriority(i)
+ t.updatePiecePriority(i, "Torrent.DownloadPieces")
}
}
}
func (t *Torrent) CancelPieces(begin, end pieceIndex) {
t.cl.lock()
- t.cancelPiecesLocked(begin, end)
+ t.cancelPiecesLocked(begin, end, "Torrent.CancelPieces")
t.cl.unlock()
}
-func (t *Torrent) cancelPiecesLocked(begin, end pieceIndex) {
+func (t *Torrent) cancelPiecesLocked(begin, end pieceIndex, reason string) {
for i := begin; i < end; i++ {
p := &t.pieces[i]
if p.priority == PiecePriorityNone {
continue
}
p.priority = PiecePriorityNone
- t.updatePiecePriority(i)
+ t.updatePiecePriority(i, reason)
}
}
var offset int64
t.files = new([]*File)
for _, fi := range t.info.UpvertedFiles() {
- var path []string
- if len(fi.PathUTF8) != 0 {
- path = fi.PathUTF8
- } else {
- path = fi.Path
- }
- dp := t.info.Name
- if len(fi.Path) != 0 {
- dp = strings.Join(fi.Path, "/")
- }
*t.files = append(*t.files, &File{
t,
- strings.Join(append([]string{t.info.Name}, path...), "/"),
+ strings.Join(append([]string{t.info.BestName()}, fi.BestPath()...), "/"),
offset,
fi.Length,
fi,
- dp,
+ fi.DisplayPath(t.info),
PiecePriorityNone,
})
offset += fi.Length
}
-
}
// Returns handles to the files in the torrent. This requires that the Info is