Pull GO_LOG support from anacrolix/log

Merge branch 'master' into go1.18

Checkout go from github

Run tests on tip

Fix and add caching to gotip CI actions

Fix and add caching to gotip CI actions

go CI: Use common action and parallel jobs

Fix and add caching to gotip CI actions

Merge branch 'master' into go1.18

go CI: Use common action and parallel jobs

Align Peer stats for webseed peers

fs/test.sh: Fail if hash does not match

Re-enable CI wasm/js package build checks

Pull webrtc SCTP Transport wasm support

Ensure gotip bin is used for go

go CI: Add GOPATH bin to GITHUB_PATH

This should fix godo not being in the path in a later step.

Merge branch 'master' into go1.18

test: use `T.TempDir` to create temporary test directory (#718)

The directory created by `T.TempDir` is automatically removed when the
test and all its subtests complete.

Reference: https://pkg.go.dev/testing#T.TempDir
Signed-off-by: Eng Zer Jun <engzerjun@gmail.com>

fs/test.sh: Add torrents before mounting

Make use of the lazylog branch of anacrolix/log

This avoids significant allocations and overhead.

Debug CI godo installation

Continue on wasm build error

Run fs/test.sh on 32 bit

fs/test.sh: Use Sintel file so webrtc is tested

Revert "fs/test.sh: Use go run instead of godo"

This reverts commit e8bd16257c40a5b53ac19c4f8b7669eb41b699e2.

Include peer net.Conn endpoint addresses in webrtc conn string

When banning an IP drop peers that match

Fix v4 in v6 IPs from being banned as IPv4

Ban peers for dirtying pieces if they are solely responsible

Merge branch 'lazylog' into smartban

Merge branch 'master' into lazylog

Include peer net.Conn endpoint addresses in webrtc conn string

Resolve deps

Lazy logging

Switch to external anacrolix/generics

Forget smart ban blocks after piece passes hash check

Apply smart bans under Client lock

Do smart banning on existing badPeerIPs

Add some generic map helpers

Implement smart ban using generics

Use gotip for CI build

Switch to ajwerner/btree in piece request ordering

Add AjwernerBtree as an alternative btree backing for piece request order

Also add some scans to benchmarks. Make a few changes to reduce allocations using piece request order.

Benchmark PieceRequestOrder with varying styles of path hint usage

Add per-piece piece request order path hints

Use tidwall/btree generics for piece request ordering

Use webrtc selected ICE candidate for peer addresses

Rename webtorrent source files

Use tagged anacrolix/squirrel

Switch from missinggo/MultiLess to anacrolix/multiless

Add tests for preferred network direction

Add const noCacheBlobs in sqlite storage benchmarks

go mod tidy

bencode: Support decoding "" as dict key

bencode: Return ErrUnexpectedEOF instead of EOF in the middle of values

Add bencode.Decoder.MaxStrLen

fs/test.sh: Use go run instead of godo

tracker/udp.ConnClient: Make logging configurable

Should fix https://github.com/anacrolix/torrent/issues/701#issue-1088130173

Reject peer requests on data read failures

Reduce some logging

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