Avoid rebuffering in peer_protocol.Decode

Some minor fiddling to announcing in the client

The fuse library allocates a response data slice for us, so use it

ResponsiveDownloadStrategy will readahead blocks

Test peers don't play well with short "up request" buffers, so we need to fill
these with the most likely blocks to achieve maximum download speeds.

client.go: Shorten module peer_protocol to pp

Shorten variable names in connectionLoop

Be more selective about when to replenish connection requests

Implement connection.{Cancel,Choke}

Allocate peer_protocol.Message on the stack in connectionLoop

Support individual peer max requests

Misc minor improvements

Add Client.DownloadStrategy; fix priority of incomplete pieces

cmd/torrent: Add flags -disableTrackers and -seed

Ininitialize the torrent.Priorities up front and do initial piece checks with a single goroutine

Add some String methods and contextual information in log messages

Make Request private

Implement receiving cancel messages

TestUnmountWedged, fs.Destroy

Big visibility/doc clean-up, and extract mmap_span package

Check for asynchronous mount error after serving

Break up torrentfs main(), it's too large

Handle repeat SIGINT/SIGTERMs

Need to determine if there's a way to better interrupt the FS or if we have no control over that.

Add error handling to PrioritizeDataRegion as it's public facing API

Mask EHOSTUNREACH on connect()

goimports decided to reorganise imports

Fix calculation of request for torrent data offset

Break up client.go into several files and a few fixes

Suppress expected errors when initiating connections.
Add an explicit timeout to initiate connections.
Put a lock on closing a connection to prevent data race warnings.

Fix short read and report unexpected EOFs decoding peer protocol

TODO

Lots of logging improvements

Add -listenAddr and actually listen in ./cmd/torrent

Send port on announces when possible

Fix requests to other leechers

Tidy up

Fix races stopping clients and closing connections

Test created torrent structure in current directory

Improvements to pending chunks; extract testutil

Add a scrape command so I can work out if trackers are seeing my test clients

I don't even know if scrape is the right word.

Various progress, particularly around the way data readiness is handled

Hunting for goroutine leaks

Start implementing Client.Stop().

Add a end-to-end test for torrentfs

Basic unchoking and uploading.
Accept incoming connections.
Break out torrentfs lib.
Fix and implement some protocol stuff.

Add tracker_test

Make use of trackers

Simplify the tracker.New interface, just take a string

Tracker doc

Fixes and tests for UDP tracker protocol

Fix parsing of UDP announce response peers

Implementing UDP tracker in its own module

Unit test for connection address comparison to avoid adding bootstrap peers when already present

Bring the 'torrent' command up to speed with the client API, including profiling flags

Set the event condition locker in client

Needed for WaitAll, albeit not actually triggered anywhere yet.

Stop connection writer timer on exit from function

Remove obsolete private type 'pieceState'

Begin on UDP trackers

More explicit implementation for wantPiece method

If no requests can be found for a connection, set it to uninterested

Set pieceByBytesPendingSlice capacity in advance to reduce memory pressure

Reconnect to the torrentfs -testPeer at regular intervals if it's missing for any loaded torrents

Fix keep-alive timer use in connection writer, and make connection a public type

I'm not sure if making this public is the right approach yet, but for now it's a good way to conditionally invoke methods on Client from external packages.

Significant progress and improvements

Piece state is broken up into several dimensions.
Implement keep-alive in connection writer.
Lazily hash pieces, only as requested.
Replace client actor mechanism with a mutex.
Fix runConnection/connectionLoop/handshake misnomers.
Fix broken reading from partially complete pieces.

Always finish off partially downloaded pieces

Implement prioritizing of torrent data regions based on FS activity

Torrent client publishes data ready information; torrentfs supports file reads

Fix bugs in the new WriteSectionTo hashing implementation

Create more efficient writer method for MMapSpan for use with hashing

Support browsing torrents in the filesystem

Need executable permissions on torrent data directories

Start implementing torrentfs binary

Fix TestHaveEncode now that message length prefixes are actually included in Marshal output

BEP20

Implement writing of chunks as they arrive

Failing WriteAt should return ErrShortWrite

See the implementation of io.Copy.

Mostly handle Piece messages, and kick off a piece check when all the chunks are done

Decoding of Piece messages, and checking entire message is consumed

Fix request/chunk confusion, missing outgoing message prefix, protocol tests; improve request triggering

Implementing bitfields and connection message handling

Implement peer connection writer, optimizer and handshake

Fix race conditions

BytesInfoHash wasn't actually initializing the info hash

Don't rely on *os.File finalizer for close

Prevent false-positive race conditions

Begin implementing the adding of peers, and initiating of connections

Handle actorTask messages

Can't send to torrentFinished while handling an event

Fix crash due to torrent.MetaInfo being unset

Create torrent data files with at least the required size

Truncate is required or use of mmap'd region beyond file length raises SIGBUS.

Start implementing a basic client

Add some basic protocol definitions, this will be improved in the future

Add torrent-verify, simple exe that logs matching pieces from a torrent file and torrent path

Add torrent.Mmap and MmapSpan, types that abstract memory-mapped torrent data

Add cmds 'torrent-create' and 'torrent-metainfo-pprint' using nsf's libtorgo