request_strategy

Documentation

Index

• func GetRequestablePieces(input Input, f func(t *Torrent, p *Piece, pieceIndex int))
• func Run(input Input) map[PeerId]PeerNextRequestState
• type ChunkIndex
• type ChunkSpec
• type ChunksIter
• type ChunksIterFunc
• type ClientPieceOrder
• type Input
• type Peer
  • func (p *Peer) HasPiece(i pieceIndex) bool
• type PeerId
• type PeerNextRequestState
• type Piece
• type Request
• type RequestIndex
• type Torrent

Functions

func GetRequestablePieces

func GetRequestablePieces(input Input, f func(t *Torrent, p *Piece, pieceIndex int))

Calls f with requestable pieces in order.

func Run

func Run(input Input) map[PeerId]PeerNextRequestState

TODO: We could do metainfo requests here.

Types

type ChunkIndex

type ChunkIndex = uint32

type ChunkSpec

type ChunkSpec = types.ChunkSpec

This can be made into a type-param later, will be great for testing.

type ChunksIter

type ChunksIter interface {
	Iter(func(ChunkIndex))
}

type ChunksIterFunc

type ChunksIterFunc func(func(ChunkIndex))

type ClientPieceOrder

type ClientPieceOrder struct{}

type Input

type Input struct {
	Torrents           []Torrent
	MaxUnverifiedBytes int64
}

type Peer

type Peer struct {
	Pieces           roaring.Bitmap
	MaxRequests      int
	ExistingRequests roaring.Bitmap
	Choking          bool
	PieceAllowedFast roaring.Bitmap
	DownloadRate     float64
	Age              time.Duration
	// This is passed back out at the end, so must support equality. Could be a type-param later.
	Id PeerId
}

func (*Peer) HasPiece

func (p *Peer) HasPiece(i pieceIndex) bool

type PeerId

type PeerId interface {
	Uintptr() uintptr
}

type PeerNextRequestState

type PeerNextRequestState struct {
	Interested bool
	Requests   roaring.Bitmap
}

type Piece

type Piece struct {
	Request           bool
	Priority          piecePriority
	Partial           bool
	Availability      int64
	Length            int64
	NumPendingChunks  int
	IterPendingChunks ChunksIter
}

type Request

type Request = types.Request

type RequestIndex

type RequestIndex = uint32

type Torrent

type Torrent struct {
	Pieces   []Piece
	Capacity storage.TorrentCapacity
	// Unclosed Peers. Not necessary for getting requestable piece ordering.
	Peers []Peer
	// Some value that's unique and stable between runs. Could even use the infohash?
	InfoHash       metainfo.Hash
	ChunksPerPiece int

	MaxUnverifiedBytes int64
}