remove

Fix TestTorrentDroppedDuringResponsiveRead flakiness

Allow stealing from slower connections within priority classes

Dynamic outbound max requests

This might be one solution to https://github.com/anacrolix/torrent/issues/698.

Include requests pending cancel in current request count

This fix a situation where peers might be dropping our requests, and since we depend on all requests being satisfied before re-requesting, we get stuck waiting for the request to be filled.

Replace piece availability with frequencies in Torrent status

Revert go directive to 1.16

cmd/torrent: Add --linear-discard

Fix panic in webseeds updating requests when Torrent is closed

I think this was caused by PieceRequestOrder being removed if all pieces in a storage capacity key are deleted.

cmd/torrent: Lower burst when there's a download rate limit

Apply download rate limiter to webseeds

Don't wait for DHT pings

Fixes a growing backlog of pings if DHT servers are rate-limited in their queries.

Make Torrent.cancelRequestsForPiece more efficient

Use relative availabilities to determine piece request order

Most overhead comes from peers that connect that have everything, and we just increment every single piece's availability. There may be some unresolved determinism with torrents that share the same ordering.

gofumpt -extra

Add TestHaveAllThenBitfield

The result of a misguided attempt to reduce piece peer availability increment and decrement overhead for have all/full-bitfield and conn closes.

fix http tracker arg position (#700)

Co-authored-by: Bot Git <bot@example.com>

* set proxy of websocket tracker to the proxy used by client config

Fix leaked mmap storage in test

Fix race in TextPexConnState

Fix go-libutp import when CGO is disabled

Test benchmarks in a separate step and limit executions

Fix BenchmarkUpdatePiecePriorities

Fix BenchmarkConnectionMainReadLoop

Broken by piece request order changes.

Some optimizations in PieceRequestOrder.Update and item comparisons

Retract v1.39.0

Tidy up request heaping comments

Add Peer.cancelAllRequests for webseedPeer

Update requests after deleting all in some corner cases

Choked by non-fast PeerConn, deleted PeerConn. They're not exactly guarded as strictly as they could be, so there's plenty of room for performance improvements here.

Assert that a request isn't cancelled before requesting it again

Update peer requests if not interested when piece priorities change

This should fix a starvation issue where we don't signal interest to a peer that has us choked.

Explicitly use go-libutp synchronous firewall callback

Merge branch 'request-strategy-experiments'

This should bring in significant performance improvements that fix issues with the peer-requesting that existed from v1.34.0.

More consistent cancellation management

Remove unused request strategy code

Don't group Torrent piece request orders without a storage capacity together

Minimize allocations due to heap escapes

Only steal an odd request if the stealer more recently received a chunk

This helps break the stealing cycle during endgame, and lets us trickle the request to the peer conn with the best record. It might not be sufficient but works nice in testing so far.

Only use last requested when both requests are already pending

Add Torrent-level request cancel for consistency

Update peer cancel assumptions and return

Improve panic message

Try request stealing

Don't try to request anything without the torrent info

Wait between duplicate requests

Stop iterating pieces when storage is exhausted

Use interfaces to lazily expose the bare minimum inputs to GetRequestablePieces

Provide mapping from infohash to Torrent in Input

Implement piece request ordering with retained state

Avoid reflection sorting request pieces

Use indices to lookup pieces for comparison

Cache piece request orderings

Retract last few minor versions with peer-requesting issues

(cherry picked from commit 85a436a5ca75a47a52dcab9648d85f3c3fb53e35)

Revert "Link to godocs.io for documentation"

This reverts commit c2ed60f9f2d100ddd15a38a6c260121a9ad6e893.

Partition piece request strategy by storage capacity key

Do webseed request updates asynchronously

Fixes a bug where received chunks are immediately requested while still being processed.

Add more identifying information to PeerConn.String

Some logs for unexpected protocol violations could be helped by them.

Add generalized decodeJsonByteString and a fuzz target for it

Add failing bencode fuzz input

Transmission does not reject cancelled requests

Don't log webseed request context cancellation results

bencode: Avoid allocating interface string up front

This should fix crashes during fuzzing. It's not a complete fix, we really want to limit the amount a given Decode can allocate. Maybe Go isn't the right language for this.

bencode: Fix decoding integer with leading +

bencode: Enforce dict key ordering

Fix bencode dict key ordering in HTTP tracker test

bencode incorrectly parsed integers with leading zeroes

Add bencode FuzzInterfaceRoundTrip

Shuffle duplicate requests

Add missing import

Generate full sintel magnet link in fs test

Add sintel.torrent

Fix races using resources on Close

Don't use the Client's IP blocklist after the Client is closed

Fixes a segfault due to using a memory mapped blocklist in confluence.

Remove unused torrent_pending_pieces.go

Unfortunately github.com/elliotchance/orderedmap is still used in ./analysis, so no deps are removed.

Filter update requests on piece priority change by peer choking and allowed fast

Ensure peerRequests.torrentStrategyInput is set

PEX: remove workaround for krpc marshaller

PEX: use new NodeAddr search methods in krpc

PEX: fluid event log

Fix wasm build

This was broken in the move to zombiezen sqlite, which still doesn't work on WASM/JS.

Don't fail-fast on go versions

Handle 503 returns from webseed peer endpoints

Record an observation about why webseed peers are doing most of the work in recent testing

Do webseed request parts sequentially

This means we can treat the number of bytes in the result with enough accuracy to decide if we should count it as a wasted chunk. Also I'm not sure why it was a good idea to do parts of a request in parallel anyway, it could just lead to spikes in outstanding requests to the webseed, rather than sticking to the predictable maxRequests limit.

Handle cancelled webseed peer requests if they're not active

Check if Torrent is closed before receiving webseed chunks

Fix minimum peer extensions error message

Reduce idle request updates due to choke and unchoke messages

Merge branch 'udp-tracker-no-dial' into te

Remove unused peer stuff in request strategy

Optimize the use of worstConnSlice again

Optimize Torrent.haveAnyPieces

Announce to DHT if we want conns, not just peers

Wanting peers is a subset of wanting conns

Don't want conns for seeding unless we have a piece

Peers with all pieces have wanted pieces only if we want any piece

Abstract worseConn comparisons and add tests

Rename worst_conns.go

Merge branch 'bsi-pending-requests' into te

Use modernc.org/sqlite version that fixes temp dir race

Comment out pending requests tests and asserts

These need to be updated. BSI for pending requests removes an enormous amount of memory use for very large torrents.

Revert "Use a flat slice for pending request counts"

This reverts commit dfc421824ce6c146ff9d9062ad25748c0f8c9990.