GitLab

Provides full implementation of do-no-send-cids on responder side

* feat(graphsync): add incoming block hook types

add types (not implemented) for incoming block hook

* feat(asyncloader): identify local loads

add a boolean value to AsyncLoadResult to determine if a request load was local

* fixup! feat(graphsync): add incoming block hook types

* feat(hooks): add block hooks plumbing

* feat(requestmanager): process block hooks

Process block hooks on each block, and connect last response to blocks

* feat(peerresponsemanager): add transactions

add the ability to do multple response operations with a gaurantee they will end up in a single
response

* refactor(lint): fix lint errors

* feat(graphsync): add update to message

add update to message protobuf. also fix deserialization error with cancel requests

* feat(requestmanager): support updates for response hooks

Support sending request updates in incoming response hooks. Also factor hooks out of request manager

* refactor(hooks): make hooks approach consistent

for ease of use and learning in library, make hooks structure consistent across requestor and
responder

* feat(responsemanager): update request processing

Add the ability to processing update requests as needed

* test(responsemanager): add more tests for update behavior

* test(integration):add update integration test

Add test to verify the whole update flow

* fix(lint): fix lint error

* feat(deps): upgrade IPLD prime to last before refactor

* refactor(responsemanager): refactor traversal

switch to iterative traversal that is more amenable to interruption

* feat(peerresponsemanager): add bytes sent to peer response sender

Add a return value to SendResponse in peer response sender to return the number of block bytes
transmitted. Note: does not count unsent blocks. Also convert block size measurements to uint64

* feat(responsemanager): add response pausing

add first implementation of response pausing in response manager

* refactor(responsemanager): extract classes to simplify response manager

extract hooks as independant functionality

* test(responsemanager): add tests for block hooks and request hooks

* test(graphsync): add pause/resume integration test

* fix(responsemanager): fix directory misname

requesthooks.go directory -> requesthooks

* fix(tests): cleanup races & lint

* test(graphsync): fix flaky test

Remove the encode and decode on ipldbridge as part of ramp up to removing entirely
Also move selector encode/decode to within protobuf encoding

When the request manager receives extensions in a request, it processes them and returns their
response

To reduce future import cycles, and expose more types properly, move the root package to an
interface/types file and move the main implementation into /impl. This also exposes an interface
other implementers can replace.

limit the size of blocks sent in a response to 512k a.l.a. bitswap

Adds callbacks to manage connections, also removes network receiver methods from public graphsync
interface, and updates libp2p to handle go-libp2p-core refactor

move link tracker out of response manager so it can be used for requests

Creates the Response Manager that processes incoming requests, initiates selector traversal, and
generates responses

Refactor peer manager to handle abstract processes, then use the base class for the peer message
manager and the peer response manager

Create a response manager for a single peer to handle assembling and managing responses for a given
peer