requestmanager

Documentation

Index

• type AsyncLoader
• type PeerHandler
• type RequestHooks
• type RequestManager
  • func New(ctx context.Context, asyncLoader AsyncLoader, linkSystem ipld.LinkSystem, ...) *RequestManager
  • func (rm *RequestManager) CancelRequest(ctx context.Context, requestID graphsync.RequestID) error
  • func (rm *RequestManager) Disconnected(p peer.ID)
  • func (rm *RequestManager) GetRequestTask(p peer.ID, task *peertask.Task, requestExecutionChan chan executor.RequestTask)
  • func (rm *RequestManager) NewRequest(ctx context.Context, p peer.ID, root ipld.Link, selectorNode ipld.Node, ...) (<-chan graphsync.ResponseProgress, <-chan error)
  • func (rm *RequestManager) PauseRequest(requestID graphsync.RequestID) error
  • func (rm *RequestManager) ProcessResponses(p peer.ID, responses []gsmsg.GraphSyncResponse, blks []blocks.Block)
  • func (rm *RequestManager) ReleaseRequestTask(p peer.ID, task *peertask.Task, err error)
  • func (rm *RequestManager) SendRequest(p peer.ID, request gsmsg.GraphSyncRequest)
  • func (rm *RequestManager) SetDelegate(peerHandler PeerHandler)
  • func (rm *RequestManager) Shutdown()
  • func (rm *RequestManager) Startup()
  • func (rm *RequestManager) UnpauseRequest(requestID graphsync.RequestID, extensions ...graphsync.ExtensionData) error
• type ResponseHooks

Types

type AsyncLoader

type AsyncLoader interface {
	StartRequest(graphsync.RequestID, string) error
	ProcessResponse(responses map[graphsync.RequestID]metadata.Metadata,
		blks []blocks.Block)
	AsyncLoad(p peer.ID, requestID graphsync.RequestID, link ipld.Link, linkContext ipld.LinkContext) <-chan types.AsyncLoadResult
	CompleteResponsesFor(requestID graphsync.RequestID)
	CleanupRequest(p peer.ID, requestID graphsync.RequestID)
}

AsyncLoader is an interface for loading links asynchronously, returning results as new responses are processed

type PeerHandler

type PeerHandler interface {
	AllocateAndBuildMessage(p peer.ID, blkSize uint64, buildMessageFn func(*gsmsg.Builder), notifees []notifications.Notifee)
}

PeerHandler is an interface that can send requests to peers

type RequestHooks

type RequestHooks interface {
	ProcessRequestHooks(p peer.ID, request graphsync.RequestData) hooks.RequestResult
}

RequestHooks run for new requests

type RequestManager

type RequestManager struct {
	// contains filtered or unexported fields
}

RequestManager tracks outgoing requests and processes incoming reponses to them.

func New

func New(ctx context.Context,
	asyncLoader AsyncLoader,
	linkSystem ipld.LinkSystem,
	requestHooks RequestHooks,
	responseHooks ResponseHooks,
	networkErrorListeners *listeners.NetworkErrorListeners,
	requestQueue taskqueue.TaskQueue,
	connManager network.ConnManager,
	maxLinksPerRequest uint64,
) *RequestManager

New generates a new request manager from a context, network, and selectorQuerier

func (*RequestManager) CancelRequest

func (rm *RequestManager) CancelRequest(ctx context.Context, requestID graphsync.RequestID) error

CancelRequest cancels the given request ID and waits for the request to terminate

func (*RequestManager) Disconnected

func (rm *RequestManager) Disconnected(p peer.ID)

Disconnected is called when a peer disconnects

func (*RequestManager) GetRequestTask

func (rm *RequestManager) GetRequestTask(p peer.ID, task *peertask.Task, requestExecutionChan chan executor.RequestTask)

GetRequestTask gets data for the given task in the request queue

func (*RequestManager) NewRequest

func (rm *RequestManager) NewRequest(ctx context.Context,
	p peer.ID,
	root ipld.Link,
	selectorNode ipld.Node,
	extensions ...graphsync.ExtensionData) (<-chan graphsync.ResponseProgress, <-chan error)

NewRequest initiates a new GraphSync request to the given peer.

func (*RequestManager) PauseRequest

func (rm *RequestManager) PauseRequest(requestID graphsync.RequestID) error

PauseRequest pauses an in progress request (may take 1 or more blocks to process)

func (*RequestManager) ProcessResponses

func (rm *RequestManager) ProcessResponses(p peer.ID, responses []gsmsg.GraphSyncResponse,
	blks []blocks.Block)

ProcessResponses ingests the given responses from the network and and updates the in progress requests based on those responses.

func (*RequestManager) ReleaseRequestTask

func (rm *RequestManager) ReleaseRequestTask(p peer.ID, task *peertask.Task, err error)

ReleaseRequestTask releases a task request the requestQueue

func (*RequestManager) SendRequest

func (rm *RequestManager) SendRequest(p peer.ID, request gsmsg.GraphSyncRequest)

SendRequest sends a request to the message queue

func (*RequestManager) SetDelegate

func (rm *RequestManager) SetDelegate(peerHandler PeerHandler)

SetDelegate specifies who will send messages out to the internet.

func (*RequestManager) Shutdown

func (rm *RequestManager) Shutdown()

Shutdown ends processing for the want manager.

func (*RequestManager) Startup

func (rm *RequestManager) Startup()

Startup starts processing for the WantManager.

func (*RequestManager) UnpauseRequest

func (rm *RequestManager) UnpauseRequest(requestID graphsync.RequestID, extensions ...graphsync.ExtensionData) error

UnpauseRequest unpauses a request that was paused in a block hook based request ID Can also send extensions with unpause

type ResponseHooks

type ResponseHooks interface {
	ProcessResponseHooks(p peer.ID, response graphsync.ResponseData) hooks.UpdateResult
}

ResponseHooks run for new responses