GitLab

remove potential send on close channel -- only happens when context closes anyway

* style(imports): fix import formatting

Fix import formatting via script. Also add script for import fixes and release log

* docs(CHANGELOG): add changelog, contributing

Add the changelog and a contributing guidelines doc

* feat(persistenceoptions): add unregister ability

add unregister ability to persistence options so we can create short lived options for single
requests

* fix(lint): fix lint issues

All changes to date including pause requests & start paused, along with new adds for cleanups and checking of execution (#75)

* WIP

* feat(graphsync): pause/unpause requests

Allow graphsync requests to be paused and unpaused via request cancelling and DoNotSendCIDs
extension

* fix(requestmanager): refactor executor

remove extraneous allocation of closure functions

* feat(graphsync): support external request pauses

allow pausing requests imperatively via PauseRequest function

* fix(lint): fix lint errors

* feat(responsemanager): start requests paused

add the ability for a hook to pause a response right when it's first received

* feat(responsemanager): improve cancellation UX

provide a mechanism for responders to learn a requestor cancelled a request and for requestors to
learn a request was cancelled

* feat(requestmanager): process request cancelled status

process the responder returning a request cancelled error code and also support sentinel errors

* feat(executor): refactor to remove loader

remove loader, also only fire restart request as needed

* fix(asyncloader): load requests synchronously when possible

* fix(responsemanager): fix external pause

Fix external pauses missing a block

* fix(responsemanager): do not delay complete listener

Run complete listener in same thread as response processing, making it less susceptable to
interruption via cancel

* fix(responsemanager): fix context check

fix checking for context cancellation errors based off of the way ipld-prime does not wrap errors

* fix(responsemanager): more precise cancel

make cancels only get recorded if actual blocks are not sent -- otherwise the request is considered
complete -- and the complete hook always runs

* fix(requestmanager): handle non processed pauses

Handler the case where a pause is requested but never actually takes place

* refactor(responsemanager): handle cancels, correctly this time

Properly handle cancels for both paused and unpaused states

* fix(errors): remove regex cause it appears to be very slow

* fix(traverser): fix race condition for shutdown

make sure that the traverser is finished in the request executor

* fix(deps): mod tidy

* fix(executor): add back network error

* 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): define hook interfaces, test infrastructure

rename hooks, add outgoing request hook, define chain types for node builder chooser tests

* feat(graphsync): define persistence option

add persistence options to asyncloader & responsemanager + handling

* feat(graphsync): complete persistence / node builder chooser roundtrip

* fix(lint): fix lint errors

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.

extracts parts of old asyncloader to load attempt queue
expands functionality of asyncloader to handle response cache
moves response cache and unverified block store under async laoder

Continue to load links synchronously after network request completes

Async loader returns a single channel result type

Create async loader to handle multiple load attempts as responses come in from network