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.

tracker/udp: Panic on read errors if ConnClient not closed

There's nothing exposed to handle this error currently, and if it occurs, it's better not to fail in silence. I'm currently debugging a situation where ConnClients stop working, this would be a condition we'd want to know about.

Improve logging of UDP tracker packet dispatch error

Wrap UDP tracker response error

Don't dial in UDP tracking

This could fix an issue where tracker addresses change, but we're already bound to a particular address and so fail to receive any more responses.
It should also make it easier to share UDP sockets between UDP tracker clients, although that's not currently implemented.

Doc comments

Remove CGO build flags for pure-Go squirrel branch

Use zombiezen branch of squirrel

gofumpt

Use zombiezen sqlite for piece completion

Quote peer extension names to expvar

Pull synchronous firewall callback performance improvement

Reduces CPU overhead when receiving lot of UDP traffic.

Optimize PeerConn.peerHasAllPieces

Avoid calling net.Conn methods with the Client mutex locked

The utp firewall callback might want to use it. I can't think of a better way to determine with an incoming connection request should be blocked.

Use tagged version of github.com/anacrolix/fuse

Switch to github.com/anacrolix/fuse

Remove dependency on and exclude of github.com/willf/bitset

Provide context to readahead func

Add Reader.SetReadaheadFunc

Fixes https://github.com/anacrolix/torrent/issues/687.

Add a comment about not discarding in webseed OK response bodies

Don't log legitimate non-range requests

Should fix failing go1.16 CI build

Improve error handling for bad webseeds

DNS "no such host" errors didn't interrupt the stream of outbound requests.

Pass HTTP Proxy config into webseeding HTTP client

Remove unused Client.updateRequests

Boost webseed max requests

Increment webseed peer piece availability

Allow non-partial webseed part responses for small files

webseed: Close unused part responses after error

Also don't bother to read their response bodies.

Don't use non-directory webseed URLs for multi-file torrents

Make TorrentSpecFromMetaInfoErr still usable on info error