Add some tests verifying request map ordering

Update anacrolix/args for bool Flag fix

requesting: Remove some obsoleted condition checks

These shouldn't be necessary since peers were pruned for the ability to allocate chunks to the current piece.

request_strategy.Peer.canRequestPiece performance: Reorder conditions

bencode: get type of `big.Int` without creating instance (#651)

Nope, it doesn't really matter. But anyway, see https://github.com/golang/crypto/blob/c084706c2272f3d44b722e988e70d4a58e60e7f4/cryptobyte/asn1.go#L267

bencode: simplify getting `marshalerType` and `unmarshalerType` (#652)

bencode: Simplify `(*Decoder).parseListInterface()` (#656)

Preserve as much type as possible (it'll be converted to an `interface{}` anyway, but we can return `[]interface{}` instead of `{}interface` here).

Prevent allocation when checking interface (#649)

metainfo: Remove reflection dependency for `Piece.Hash()` (#661)

`copy`  will copy exactly `HashSize` bytes here.

lockWithDeferreds: inlineable Unlock() (#603)

requesting: Filter peers that can't be allocated chunks

Rejig waits between doRequests

Performance improvements in piece requesting

Change torrent capacity to not return a pointer

It's an unnecessary complication for a storage implementer.

Simplify PIece.iterUndirtiedChunks

Pre-allocate request strategy pieces

cmd/torrent: Use anacrolix/args and merge several other cmds in as subcommands

Inlineable `(*Torrent).Seeding()` (#626)

Inlineable `(*Torrent).SetDisplayName()` (#625)

Inlineable `(*Torrent).PieceState()` (#621)

Inlineable `(*Torrent).AddPeers()` (#622)

Inlineable `DownloadPieces()` and `CancelPieces()` (#623)

Create default constructor for Client (#567)

Allow for certain values to always be properly initialized on construction -- namely the maps for now. I'm currently working on a change that requires a baseline constructor; this change would make the use of `chansync.BroadcastCond` and `chansync.SetOnce` obsolete -- i.e. one can have channel members without worrying about proper initialization/destruction of a `chan struct{}`.

As for why `makeClient` returns a value instead of a pointer: returning a value gives us more options -- you can always take a pointer from a value later on cheaply, and have things moved to the heap if they weren't already. The same can't be said about getting a value back from a pointer. GC also could potentially have less work to do. Plus I personally find ownership to be an important concept (semi-borrowed from rust) -- use of values make ownership clear.

Clarify maximum value of "metadata_size" (#609)

Inlineable `(*File).BytesCompleted()` (#612)

Optimize `LoopbackListenHost()` (#615)

Inlineable (*reader).SetReadAhead and (*reader).Close (#594)

Small fixes that prevent inlining of public functions

Drop bradfitz/iter dependency (#605)

* Drop bradfitz/iter dependency

`range iter.N` looks nice and doesn't allocate, but unfortunately using a `range` expression blocks a function from being inlined wherever it's used (for now). It's not that we need inlining in all cases, but I do think a C-style for loop looks just as nice and is probably clearer to the majority. There also aren't any clear disadvantages to changing (unless you just happen to dislike the look of C)

* Update misc_test.go

* Update rlreader_test.go

* Update torrent_test.go

* Update bench_test.go

* Update client_test.go

* Update iplist_test.go

* Update mse_test.go

* Update peerconn_test.go

* Update peerconn.go

* Update order_test.go

* Update decoder_test.go

* Update main.go

* Update bench-piece-mark-complete.go

* Update main.go

* Update torrent.go

* Update iplist_test.go

* Update main.go

Cheaper byte to string conversion (#602)

Revamped https://github.com/anacrolix/torrent/pull/587

Inlineable reader.Seek and no-lock return for bad whence (#577)

* Inlineable reader.Seek and no-lock return for bad whence

Couldn't find an elegant way to early exit on bad whence. Using a closure could reduce code duplication slightly, but it's overkill for only 3 cases.

Note that returning 0 on an invalid whence is the behavior of `strings.Reader` and `bytes.Reader`.

* Update reader.go

Fix usages of eachListener() and make inlineable (#599)

Inlineable methods to access File piecePriority (#601)

Simplify (*Torrent).gotMetainfo (#581)

Remove xerrors dependency (#600)

* Remove xerrors dependency

* Update main.go

Reorder fields to reduce padding in reader (#597)

Reorder some of the fields to reduce the size of `reader`. Not much of a change -- original size was 104 bytes, with changes (moving bool's to the end) the size is 96 bytes. There's also the whole cache-friendly bit -- I tried reordering fields to help here, but I doubt it makes much of a difference.

Some other notes: `sync.Locker` is a 16 byte field. I suggest changing this to something like `*sync.RWMutex` or `*lockWithDeferreds`. This would not only reduce size but would allow access to `RLock`/`RUnlock`.
`pieceRange` could also be shrunk to 8 bytes, but I feel like I'm probably asking for too much lol.

Update ReadCloser interface check to ReadSeekCloser (#595)

Fix http announce of infohash containing ' ' bytes (#591)

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

Don't call Client onClose handlers until torrent storages are closed

Fix Torrent.Drop to wait for storage close without client lock

Avoid allocating memory when checking interface (#588)

Not a big deal, but there isn't a need to allocate an object to check that `*Node` satisfies `bencode.Unmarshaler`.

Optimize peersForPieces allocations for make and sorting

Optimize requesting peerId Uintptr allocation

Disable ensureValidSortedPeersForPieceRequests

Should approximately half the contribution of the parent function to overhead.

Optimize sortPeersForPiece in allocatePendingChunks

Optimize Torrent.worstBadConn

Remove reader.opMu

https://github.com/anacrolix/torrent/issues/553

go fmt ./...

Fix possible misuse of reflect.StringHeader

useTorrentSources: fix http request resource leak (#562)

Clarify ownership of (*Torrent).chunkPool (#583)

Basically bind the lifetime of chunkPool to the torrent by using `sync.Pool` in lieu of `*sync.Pool`. Gives the GC ever so slightly less work to do.

Don't readahead until a read occurs

Make readahead algorithm linear

Add default sqrt readahead algorithm

Extract common Torrent.newReader

Add Webtor to downstream projects

Fix unit tests littering working directory

Update README.md

Update README.md

Drop xerrors and missinggo/slices dependency for Client (#572)

* Drop xerrors and missinggo/slices dependency for Client

Made `BadPeerIPs` inlineable since I changed `badPeerIPsLocked` anyway. Also eliminated an extra torrentsAsSlice copy since Go wasn't smart enough to figure it out.

Improve Closing (#559)

- Prevent double-closing in cmd/torrent
- Move async closing from storage to torrents, and wait on them to finish tidying up before returning/exiting.

Update chansync

Return error on sqlite PieceCompletion.Set when closed

Rework Reader waiting

Simplify dhtPort()

A similar case of `haveDhtServer`

Drop xerrors and reflection dependency

Nothing wrong with missinggo.CopyExact -- but fewer dependencies is better IMO.  Also changed String() to use a consistent receiver name -- not a big deal.

[gomod] Update anacrolix/dht and run 'go mod tidy'

Simplify haveDhtServers()

A bit too much functional programming, lol.

Merge branch 'master' into squirrel

go get -u ./...

Add generics TODO

Add "no name" handling and storage.NewFileOpts

This came out of testing against Transmission in https://github.com/anacrolix/torrent/discussions/556#discussioncomment-1263670.

./cmd/torrent-create: Update the builtin announce list

Fix info name when building from . and ..

cmd/torrent download: Don't seed if no torrents are specified

Fix panic on double Close of sqlite piece completion DB

PieceStateRuns: reduce copying and make inlineable

Just a heads up: using `range` and/or `defer` prevents function inlining. This is fine for infrequently called functions and/or large functions, but for simple public methods like these, I'd assume it's better for them to be inlined.

Fix some DeepSource lints

Set Go CI workflow to use Go 1.17

go mod tidy

Add function to wrap squirrel.Cache as storage.ClientImpl

Update squirrel

Use separate squirrel module

Removed unused sqlite "provider" storage

Embed SQL

Implement {Set,Get}Tag on SquirrelBlob

Begin extracting 'squirrel' from storage/sqlite

Avoid reallocating keep alive timer on each pass

Don't run linter on master branch

Super unimpressed with this pedantic rubbish. PRs to adjust the settings welcome.

Update install command

Change linter workflow branches and name

Remove unused code

Update staticcheck go target to 1.16

Disable excessively pedantic linters

Fix data race closing incoming PeerConn

Set direct sqlite storage conn to nil on close

This might help catch the reason for SQLITE_MISUSE in getCapacity.

Rewrite peerConnMsgWriter.run

Set testing keep alive timeout to 1 millisecond

If it's too fast, we get stuck trying to send keep alives rather than actually communicating with the peer.

Fix deadlock when checking whether to send keep alive

Limit keep alives for rate limited download test

Fix race in assigning keep alive timer