FedP2P/t.go

275 lines
6.9 KiB
Go
Raw Permalink Normal View History

package torrent
2015-04-28 13:24:17 +08:00
import (
2019-02-16 15:33:14 +08:00
"strconv"
"strings"
2021-10-07 08:50:30 +08:00
"github.com/anacrolix/chansync/events"
2022-03-17 11:55:55 +08:00
"github.com/anacrolix/missinggo/v2/pubsub"
"github.com/anacrolix/sync"
2019-08-21 18:58:40 +08:00
2015-04-28 13:24:17 +08:00
"github.com/anacrolix/torrent/metainfo"
)
// The Torrent's infohash. This is fixed and cannot change. It uniquely identifies a torrent.
func (t *Torrent) InfoHash() metainfo.Hash {
2016-04-03 16:40:43 +08:00
return t.infoHash
2015-08-02 01:55:48 +08:00
}
// Returns a channel that is closed when the info (.Info()) for the torrent has become available.
2021-10-07 08:50:30 +08:00
func (t *Torrent) GotInfo() events.Done {
return t.gotMetainfoC
2015-04-28 13:24:17 +08:00
}
// Returns the metainfo info dictionary, or nil if it's not yet available.
2021-09-13 09:41:11 +08:00
func (t *Torrent) Info() (info *metainfo.Info) {
t.nameMu.RLock()
info = t.info
t.nameMu.RUnlock()
return
}
// 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.
2018-01-06 13:37:13 +08:00
func (t *Torrent) NewReader() Reader {
return t.newReader(0, t.length())
2021-09-09 15:41:12 +08:00
}
func (t *Torrent) newReader(offset, length int64) Reader {
2018-01-06 13:37:13 +08:00
r := reader{
2021-09-09 18:55:09 +08:00
mu: t.cl.locker(),
t: t,
offset: offset,
length: length,
}
2021-11-14 10:52:05 +08:00
r.readaheadFunc = defaultReadaheadFunc
2018-01-06 13:37:13 +08:00
t.addReader(&r)
return &r
}
2020-02-27 13:42:33 +08:00
type PieceStateRuns []PieceStateRun
func (me PieceStateRuns) String() (s string) {
if len(me) > 0 {
var sb strings.Builder
sb.WriteString(me[0].String())
for i := 1; i < len(me); i += 1 {
sb.WriteByte(' ')
sb.WriteString(me[i].String())
}
return sb.String()
2020-02-27 13:42:33 +08:00
}
return
2020-02-27 13:42:33 +08:00
}
// Returns the state of pieces of the torrent. They are grouped into runs of same state. The sum of
// the state run-lengths is the number of pieces in the torrent.
func (t *Torrent) PieceStateRuns() (runs PieceStateRuns) {
t.cl.rLock()
runs = t.pieceStateRuns()
t.cl.rUnlock()
return
}
2015-06-23 00:02:22 +08:00
func (t *Torrent) PieceState(piece pieceIndex) (ps PieceState) {
t.cl.rLock()
ps = t.pieceState(piece)
t.cl.rUnlock()
2021-10-05 14:48:52 +08:00
return
2016-02-07 18:57:57 +08:00
}
// The number of pieces in the torrent. This requires that the info has been
// obtained first.
func (t *Torrent) NumPieces() pieceIndex {
2016-04-03 16:40:43 +08:00
return t.numPieces()
2015-06-23 00:02:22 +08:00
}
// Get missing bytes count for specific piece.
func (t *Torrent) PieceBytesMissing(piece int) int64 {
2022-07-13 18:04:03 +08:00
t.cl.rLock()
defer t.cl.rUnlock()
return int64(t.pieces[piece].bytesLeft())
}
// Drop the torrent from the client, and close it. It's always safe to do
// this. No data corruption can, or should occur to either the torrent's data,
// or connected peers.
2016-04-03 16:40:43 +08:00
func (t *Torrent) Drop() {
var wg sync.WaitGroup
defer wg.Wait()
2018-07-25 11:41:50 +08:00
t.cl.lock()
defer t.cl.unlock()
t.cl.dropTorrent(t.infoHash, &wg)
2015-06-23 00:02:22 +08:00
}
2015-07-21 20:54:02 +08:00
2018-01-27 09:01:09 +08:00
// Number of bytes of the entire torrent we have completed. This is the sum of
// completed pieces, and dirtied chunks of incomplete pieces. Do not use this
// for download rate, as it can go down when pieces are lost or fail checks.
// Sample Torrent.Stats.DataBytesRead for actual file data download rate.
2016-04-03 16:40:43 +08:00
func (t *Torrent) BytesCompleted() int64 {
2018-07-25 11:41:50 +08:00
t.cl.rLock()
defer t.cl.rUnlock()
2016-04-03 16:40:43 +08:00
return t.bytesCompleted()
2015-07-21 20:54:02 +08:00
}
2015-12-12 11:00:07 +08:00
// 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.
2022-03-17 11:55:55 +08:00
func (t *Torrent) SubscribePieceStateChanges() *pubsub.Subscription[PieceStateChange] {
2016-04-03 16:40:43 +08:00
return t.pieceStateChanges.Subscribe()
}
2015-11-22 15:44:33 +08:00
2015-12-12 11:00:07 +08:00
// 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() (ret bool) {
2022-07-13 18:04:03 +08:00
t.cl.rLock()
ret = t.seeding()
2022-07-13 18:04:03 +08:00
t.cl.rUnlock()
return
2015-11-22 15:44:33 +08:00
}
2015-12-12 11:03:04 +08:00
// Clobbers the torrent display name if metainfo is unavailable.
// The display name is used as the torrent name while the metainfo is unavailable.
2016-04-03 16:40:43 +08:00
func (t *Torrent) SetDisplayName(dn string) {
t.nameMu.Lock()
if !t.haveInfo() {
t.displayName = dn
}
t.nameMu.Unlock()
2015-12-12 11:03:04 +08:00
}
// The current working name for the torrent. Either the name in the info dict,
// or a display name given such as by the dn value in a magnet link, or "".
2016-04-03 16:40:43 +08:00
func (t *Torrent) Name() string {
return t.name()
}
2016-04-20 18:10:10 +08:00
// The completed length of all the torrent data, in all its files. This is
// derived from the torrent info, when it is available.
2016-04-03 16:40:43 +08:00
func (t *Torrent) Length() int64 {
2022-06-20 09:37:25 +08:00
return t._length.Value
}
2016-01-16 22:49:04 +08:00
// 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 {
2022-07-13 18:04:03 +08:00
t.cl.rLock()
defer t.cl.rUnlock()
return t.newMetaInfo()
2016-01-16 22:49:04 +08:00
}
2018-01-06 13:37:13 +08:00
func (t *Torrent) addReader(r *reader) {
2018-07-25 11:41:50 +08:00
t.cl.lock()
defer t.cl.unlock()
2016-04-03 16:40:43 +08:00
if t.readers == nil {
2018-01-06 13:37:13 +08:00
t.readers = make(map[*reader]struct{})
}
2016-04-03 16:40:43 +08:00
t.readers[r] = struct{}{}
r.posChanged()
}
2018-01-06 13:37:13 +08:00
func (t *Torrent) deleteReader(r *reader) {
2016-04-03 16:40:43 +08:00
delete(t.readers, r)
t.readersChanged()
}
// Raise the priorities of pieces in the range [begin, end) to at least Normal
// priority. Piece indexes are not the same as bytes. Requires that the info
// has been obtained, see Torrent.Info and Torrent.GotInfo.
func (t *Torrent) DownloadPieces(begin, end pieceIndex) {
2018-07-25 11:41:50 +08:00
t.cl.lock()
2018-01-27 11:31:31 +08:00
t.downloadPiecesLocked(begin, end)
t.cl.unlock()
2018-01-27 11:31:31 +08:00
}
func (t *Torrent) downloadPiecesLocked(begin, end pieceIndex) {
for i := begin; i < end; i++ {
if t.pieces[i].priority.Raise(PiecePriorityNormal) {
t.updatePiecePriority(i, "Torrent.DownloadPieces")
}
}
2016-02-04 22:18:54 +08:00
}
func (t *Torrent) CancelPieces(begin, end pieceIndex) {
2018-07-25 11:41:50 +08:00
t.cl.lock()
t.cancelPiecesLocked(begin, end, "Torrent.CancelPieces")
t.cl.unlock()
2018-01-27 11:31:31 +08:00
}
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, reason)
}
2016-02-20 11:39:56 +08:00
}
2018-01-21 19:49:12 +08:00
func (t *Torrent) initFiles() {
var offset int64
2018-01-21 19:49:12 +08:00
t.files = new([]*File)
for _, fi := range t.info.UpvertedFiles() {
*t.files = append(*t.files, &File{
t,
2022-03-17 12:07:10 +08:00
strings.Join(append([]string{t.info.BestName()}, fi.BestPath()...), "/"),
offset,
fi.Length,
fi,
2022-03-17 12:07:10 +08:00
fi.DisplayPath(t.info),
2018-01-21 19:49:12 +08:00
PiecePriorityNone,
})
offset += fi.Length
}
2018-01-21 19:49:12 +08:00
}
// Returns handles to the files in the torrent. This requires that the Info is
// available first.
func (t *Torrent) Files() []*File {
return *t.files
}
func (t *Torrent) AddPeers(pp []PeerInfo) (n int) {
t.cl.lock()
n = t.addPeers(pp)
t.cl.unlock()
return
}
// Marks the entire torrent for download. Requires the info first, see
// GotInfo. Sets piece priorities for historical reasons.
2023-04-25 19:35:26 +08:00
// Announce which pieces should be downloaded
func (t *Torrent) DownloadAll() {
t.DownloadPieces(0, t.numPieces())
}
func (t *Torrent) String() string {
s := t.name()
if s == "" {
2019-02-16 15:33:14 +08:00
return t.infoHash.HexString()
} else {
return strconv.Quote(s)
}
}
2016-05-23 08:18:58 +08:00
func (t *Torrent) AddTrackers(announceList [][]string) {
2018-07-25 11:41:50 +08:00
t.cl.lock()
defer t.cl.unlock()
t.addTrackers(announceList)
2016-05-23 08:18:58 +08:00
}
func (t *Torrent) Piece(i pieceIndex) *Piece {
return t.piece(i)
}
func (t *Torrent) PeerConns() []*PeerConn {
2020-04-16 15:21:15 +08:00
t.cl.rLock()
defer t.cl.rUnlock()
ret := make([]*PeerConn, 0, len(t.conns))
for c := range t.conns {
ret = append(ret, c)
}
return ret
}