Factor out internal/string_limiter

Rework active announce limiter to reduce contention

Don't send keepalives if a connection isn't useful to us

This might help break the situation where anacrolix/torrent Clients that are connected to each other never release a connection until there's new connections that look more promising.

Update metainfo.go

delete "yoloham" so that is no longer the default comment string on torrents made without a comment specified. Should resolve https://github.com/anacrolix/torrent/issues/342

Strictly adher to tracker announce response intervals if a torrent is private

cmd/torrent: Add spew-bencoding command

cmd/torrent: Fix download command default flags

Log announce return

cmd/torrent: Add file pick flag

Update github.com/anacrolix/dht/v2

cmd/torrent: Use alexflint/go-arg for argument parsing

Also add list-files command to test it out.

Update required go version

I believe 1.15 is required for testing.T.TempDir.

piece resource storage: Delete incomplete chunks concurrently after writing complete piece

Use ConsecutiveChunkWriter in MarkComplete for piece resource storage if available

Track piece marking state separately

sqlite storage: Ensure that chunks are consecutive

Readme: downstream projects info.

sqlite storage: Remove num batched write queries log message

Update to race fixes in filecache and sqlite

sqlite storage: Buffer write requests

sqlite storage: Add some expvars

sqlite storage: Add error return from withConn

Fix panic in when bbolt storage has Closed

Mark piece complete without Client lock

Read peer request data without Client lock

Add support for the x.pe magnet link parameter

optimise PEX by avoiding intermediate storage while preparing PEX messages

optimise generation of the initial PEX

simplify pexMsgFactory

add test covering a recently fixed regression in initial PEX

Fix excessive logging from mmap-backed storage (anacrolix/torrent#436)

Implement fmt.Formatter for metainfo.Hash

It's so easy to make mistakes by specifying %x when printing these.

Improve cmd/tracker-announce

Add -tracker flag, support specifying infohashes directly, spew announce responses so they're more readable.

Tidy up doc, file names, naming

Update README.md

Fix initial pex message regression

As pointed out by @yarikk https://github.com/anacrolix/torrent/commit/c1d189ed31af99cbf6f10d9ffdc2cc4e19a73b91#r43920706

Replace storage.IncompletePieceToWriter with io.Writer

It was incorrect to assume piece hashing only operates on incomplete chunk data. This actually uncovered a bug where duplicate hash checks occurred, and the redundant checks would fail due to not reading the completed data.

Fix PkgGoDev reference in README

Fix piece getting queued for hash multiple times

Pieces could get queued for hash multiple times when we receive chunks if the piece starts getting hashed before we're done writing all the chunks out. This was only found because piece hashing currently only checks the incomplete data, which is missing after the first piece hash passes, the data is marked complete, then the subsequently queued hash has nothing to read.

Add the ReceiveEncryptedHandshakeSkeys callback

mse/cmd/mse: Fail on missing subcommand

Remove old comment

sqlite storage: Add capacity management

sqlite storage: Batch writes synchronously instead of buffering them first

Comment on storage.IncompletePieceToWriter

sqlite storage: Init schema in NewPool instead of NewProvider and add an option to disable

sqlite storage: Track total blob data size manually

Works around possible full table scan at startup, and possible lack of caching around cast(data as blob).

Update the readahead window on read failure

Add write incomplete/consecutive chunks interfaces

sqlite storage: Add batched writes

sqlite storage: Set mmap_size to a very large size

Seems to fall back to ~2GiB on my system.

sqlite storage: Provide helpers and reasonable defaults

Don't delete requests until after they're written to disk

This prevents too many pending writes building up. Webseed peers re-request synchronously, and the writes are done asynchronously, so they download too quickly and there was no backpressure. The backpressure now is provided by the upper limit on outstanding requests per connection.

sqlite storage: Force data to be used as a blob

There's a bug in crawshaw.io/sqlite, and some forks where inserting []byte results in a text type instead of blob. To ensure things work correctly, we coerce data to blob wherever we can. See https://github.com/crawshaw/sqlite/issues/94 and the fork that fixes it.

Include a null byte in the middle of the Greeting test

Fix peer request sleepiness

New requests weren't being issued to the current peer when being deleted. For webseeds, this would cause them to not bother issuing new requests indefinitely.

(cherry picked from commit 146a16df4ea26d33b0ce0391c8220de14c9e18f4)

Don't fail on 386 tests in CI

Looks like crawshaw.io/sqlite fails to build, possibly due to cross-compiling.

Switch CI to go1.15

Remove some unused code

Performance fiddling on sqlite storage

Return errors from Reader if data downloading won't occur

Chunk write errors to storage can disable data download. Previously Readers would wait indefinitely for the data to become available. This change returns an error instead of stalling.

Don't block trying to fill entire Reader.Read

This conforms more to the contract in io.Reader. It's possible the old behaviour was better in reducing overhead, but that can be iterated on (or added as comments next time).

Read from more than a single piece in each read to Torrent storage

Remove separate readable/available in Reader

sqlite storage: Include capacity management

sqlite storage: Do ReadAt without using incremental I/O

sqlite storage: Working recursive CTE for excess data

sqlite storage: Add NewProviderPool

sqlite storage: Rename table to blob

Avoiding plural table names.

Performance improvements to PEX

Fix error handling for bad torrent adds with safe file handling

Sanitize metainfo file paths for file-based storage

Fixes exploit where specially crafted infos can cause the client to write files to arbitrary locations on local storage when using file-based storages like mmap and file.

Don't update requests for the current connection first when a request is deleted

We might want to close webseed peers on response errors

webseed: Handle http response status codes

Ensure PeerConn._close is called for incoming connections

This fixes missing calls to PeerConnClosed callback.

Test both sqlite file and in-memory leecher storages

Move pexConnState from peer to PeerConn

Add PeerConnClosed callback

Add last_used to sqlite storage

Use bind-blob fix for crawshaw.io/sqlite

Fix some log levels

Add a sqlite data storage implementation

Panic on bad piece per resource chunk names

This was masking a bug in a coming sqlite storage implementation. Maybe it could be relaxed to checking for no filepath.Dir in the future.

Tweaks to storage error and completion handling

Tidy up some storage close handling

Use testing.T.Name instead of missinggo.GetTestName

This handles subtests correctly, and removes the need to specify when to export due to collisions with the old function.

Tidy up some logging

Fix webseed requests for non-trivial path components

Fix PeerConn conn status string

Fix unused import

Set tracker announce timeout back to default

Add lots of comments about how this works and why.

Expose Client.ConnStats

Include ip param in http announces

Pass key param in http announces

Rework HTTP announce timeouts

Use Request.Context to implement timeouts, set the default to 3s for announces from the Client.

Limit simultaneous announces to the same URL

Limit half-open connections at the Client level

Rename struct size test

Optimize padding on Piece