responsemanager

Documentation

Index

• type BlockSentListeners
• type CancelledListeners
• type CompletedListeners
• type NetworkErrorListeners
• type RequestCloser
• type RequestHooks
• type RequestProcessingListeners
• type ResponseAssembler
• type ResponseManager
  • func New(ctx context.Context, linkSystem ipld.LinkSystem, ...) *ResponseManager
  • func (rm *ResponseManager) CancelResponse(ctx context.Context, requestID graphsync.RequestID) error
  • func (rm *ResponseManager) CloseWithNetworkError(requestID graphsync.RequestID)
  • func (rm *ResponseManager) FinishTask(task *peertask.Task, p peer.ID, err error)
  • func (rm *ResponseManager) GetUpdates(requestID graphsync.RequestID, updatesChan chan<- []gsmsg.GraphSyncRequest)
  • func (rm *ResponseManager) PauseResponse(ctx context.Context, requestID graphsync.RequestID) error
  • func (rm *ResponseManager) PeerState(p peer.ID) peerstate.PeerState
  • func (rm *ResponseManager) ProcessRequests(ctx context.Context, p peer.ID, requests []gsmsg.GraphSyncRequest)
  • func (rm *ResponseManager) Shutdown()
  • func (rm *ResponseManager) StartTask(task *peertask.Task, p peer.ID, ...)
  • func (rm *ResponseManager) Startup()
  • func (rm *ResponseManager) TerminateRequest(requestID graphsync.RequestID)
  • func (rm *ResponseManager) UnpauseResponse(ctx context.Context, requestID graphsync.RequestID, ...) error
  • func (rm *ResponseManager) UpdateResponse(ctx context.Context, requestID graphsync.RequestID, ...) error
• type UpdateHooks

Types

type BlockSentListeners

type BlockSentListeners interface {
	NotifyBlockSentListeners(p peer.ID, request graphsync.RequestData, block graphsync.BlockData)
}

BlockSentListeners is an interface for notifying listeners that of a block send occuring over the wire

type CancelledListeners

type CancelledListeners interface {
	NotifyCancelledListeners(p peer.ID, request graphsync.RequestData)
}

CancelledListeners is an interface for notifying listeners that requestor cancelled

type CompletedListeners

type CompletedListeners interface {
	NotifyCompletedListeners(p peer.ID, request graphsync.RequestData, status graphsync.ResponseStatusCode)
}

CompletedListeners is an interface for notifying listeners that responses are complete

type NetworkErrorListeners

type NetworkErrorListeners interface {
	NotifyNetworkErrorListeners(p peer.ID, request graphsync.RequestData, err error)
}

NetworkErrorListeners is an interface for notifying listeners that an error occurred sending a data on the wire

type RequestCloser

type RequestCloser interface {
	TerminateRequest(requestID graphsync.RequestID)
	CloseWithNetworkError(requestID graphsync.RequestID)
}

RequestCloser can cancel request on a network error

type RequestHooks

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

RequestHooks is an interface for processing request hooks

type RequestProcessingListeners

type RequestProcessingListeners interface {
	NotifyRequestProcessingListeners(p peer.ID, request graphsync.RequestData, inProgressRequestCount int)
}

RequestProcessingListeners is an interface for notifying listeners a request has begun processing

type ResponseAssembler

type ResponseAssembler interface {
	NewStream(ctx context.Context, p peer.ID, requestID graphsync.RequestID, subscriber notifications.Subscriber) responseassembler.ResponseStream
}

ResponseAssembler is an interface that returns sender interfaces for peer responses.

type ResponseManager

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

ResponseManager handles incoming requests from the network, initiates selector traversals, and transmits responses

func New

func New(ctx context.Context,
	linkSystem ipld.LinkSystem,
	responseAssembler ResponseAssembler,
	requestProcessingListeners RequestProcessingListeners,
	requestHooks RequestHooks,
	updateHooks UpdateHooks,
	completedListeners CompletedListeners,
	cancelledListeners CancelledListeners,
	blockSentListeners BlockSentListeners,
	networkErrorListeners NetworkErrorListeners,
	connManager network.ConnManager,
	maxLinksPerRequest uint64,
	panicCallback panics.CallBackFn,
	responseQueue taskqueue.TaskQueue,
) *ResponseManager

New creates a new response manager for responding to requests

func (*ResponseManager) CancelResponse

func (rm *ResponseManager) CancelResponse(ctx context.Context, requestID graphsync.RequestID) error

CancelResponse cancels an in progress response

func (*ResponseManager) CloseWithNetworkError

func (rm *ResponseManager) CloseWithNetworkError(requestID graphsync.RequestID)

CloseWithNetworkError closes a request due to a network error

func (*ResponseManager) FinishTask

func (rm *ResponseManager) FinishTask(task *peertask.Task, p peer.ID, err error)

FinishTask marks a task from the task queue as done

func (*ResponseManager) GetUpdates

func (rm *ResponseManager) GetUpdates(requestID graphsync.RequestID, updatesChan chan<- []gsmsg.GraphSyncRequest)

GetUpdates is called to read pending updates for a task and clear them

func (*ResponseManager) PauseResponse

func (rm *ResponseManager) PauseResponse(ctx context.Context, requestID graphsync.RequestID) error

PauseResponse pauses an in progress response (may take 1 or more blocks to process)

func (*ResponseManager) PeerState

func (rm *ResponseManager) PeerState(p peer.ID) peerstate.PeerState

PeerState gets current state of the outgoing responses for a given peer

func (*ResponseManager) ProcessRequests

func (rm *ResponseManager) ProcessRequests(ctx context.Context, p peer.ID, requests []gsmsg.GraphSyncRequest)

ProcessRequests processes incoming requests for the given peer

func (*ResponseManager) Shutdown

func (rm *ResponseManager) Shutdown()

Shutdown ends processing for the want manager.

func (*ResponseManager) StartTask

func (rm *ResponseManager) StartTask(task *peertask.Task, p peer.ID, responseTaskChan chan<- queryexecutor.ResponseTask)

StartTask starts the given task from the peer task queue

func (*ResponseManager) Startup

func (rm *ResponseManager) Startup()

Startup starts processing for the WantManager.

func (*ResponseManager) TerminateRequest

func (rm *ResponseManager) TerminateRequest(requestID graphsync.RequestID)

TerminateRequest indicates a request has finished sending data and should no longer be tracked

func (*ResponseManager) UnpauseResponse

func (rm *ResponseManager) UnpauseResponse(ctx context.Context, requestID graphsync.RequestID, extensions ...graphsync.ExtensionData) error

UnpauseResponse unpauses a response that was previously paused

func (*ResponseManager) UpdateResponse

func (rm *ResponseManager) UpdateResponse(ctx context.Context, requestID graphsync.RequestID, extensions ...graphsync.ExtensionData) error

UpdateRequest updates an in progress response

type UpdateHooks

type UpdateHooks interface {
	ProcessUpdateHooks(p peer.ID, request graphsync.RequestData, update graphsync.RequestData) hooks.UpdateResult
}

UpdateHooks is an interface for processing update hooks