responsemanager

Documentation

Index

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

Types

type BlockHooks

type BlockHooks interface {
	ProcessBlockHooks(p peer.ID, request graphsync.RequestData, blockData graphsync.BlockData) hooks.BlockResult
}

BlockHooks is an interface for processing block hooks

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 Manager

type Manager interface {
	StartTask(task *peertask.Task, responseTaskDataChan chan<- ResponseTaskData)
	GetUpdates(p peer.ID, requestID graphsync.RequestID, updatesChan chan<- []gsmsg.GraphSyncRequest)
	FinishTask(task *peertask.Task, err error)
}

Manager providers an interface to the response manager

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 QueryQueue

type QueryQueue interface {
	PushTasks(to peer.ID, tasks ...peertask.Task)
	PopTasks(targetMinWork int) (peer.ID, []*peertask.Task, int)
	Remove(topic peertask.Topic, p peer.ID)
	TasksDone(to peer.ID, tasks ...*peertask.Task)
	ThawRound()
}

QueryQueue is an interface that can receive new selector query tasks and prioritize them as needed, and pop them off later

type RequestCloser

type RequestCloser interface {
	CloseWithNetworkError(p peer.ID, requestID graphsync.RequestID)
}

RequestCloser can cancel request on a network error

type RequestHooks

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

RequestHooks is an interface for processing request hooks

type RequestQueuedHooks

type RequestQueuedHooks interface {
	ProcessRequestQueuedHooks(p peer.ID, request graphsync.RequestData)
}

RequestQueuedHooks is an interface for processing request queued hooks

type ResponseAssembler

type ResponseAssembler interface {
	DedupKey(p peer.ID, requestID graphsync.RequestID, key string)
	IgnoreBlocks(p peer.ID, requestID graphsync.RequestID, links []ipld.Link)
	SkipFirstBlocks(p peer.ID, requestID graphsync.RequestID, skipCount int64)
	Transaction(p peer.ID, requestID graphsync.RequestID, transaction responseassembler.Transaction) error
}

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,
	queryQueue QueryQueue,
	requestQueuedHooks RequestQueuedHooks,
	requestHooks RequestHooks,
	blockHooks BlockHooks,
	updateHooks UpdateHooks,
	completedListeners CompletedListeners,
	cancelledListeners CancelledListeners,
	blockSentListeners BlockSentListeners,
	networkErrorListeners NetworkErrorListeners,
	maxInProcessRequests uint64,
	connManager network.ConnManager,
	maxLinksPerRequest uint64,
) *ResponseManager

New creates a new response manager for responding to requests

func (*ResponseManager) CancelResponse

func (rm *ResponseManager) CancelResponse(p peer.ID, requestID graphsync.RequestID) error

CancelResponse cancels an in progress response

func (*ResponseManager) CloseWithNetworkError

func (rm *ResponseManager) CloseWithNetworkError(p peer.ID, requestID graphsync.RequestID)

CloseWithNetworkError closes a request due to a network error

func (*ResponseManager) FinishTask

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

FinishTask marks a task from the task queue as done

func (*ResponseManager) GetUpdates

func (rm *ResponseManager) GetUpdates(p peer.ID, 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(p peer.ID, requestID graphsync.RequestID) error

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

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, responseTaskDataChan chan<- ResponseTaskData)

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) UnpauseResponse

func (rm *ResponseManager) UnpauseResponse(p peer.ID, requestID graphsync.RequestID, extensions ...graphsync.ExtensionData) error

UnpauseResponse unpauses a response that was previously paused

type ResponseSignals

type ResponseSignals struct {
	PauseSignal  chan struct{}
	UpdateSignal chan struct{}
	ErrSignal    chan error
}

ResponseSignals are message channels to communicate between the manager and the query

type ResponseTaskData

type ResponseTaskData struct {
	Empty      bool
	Subscriber *notifications.TopicDataSubscriber
	Ctx        context.Context
	Request    gsmsg.GraphSyncRequest
	Loader     ipld.BlockReadOpener
	Traverser  ipldutil.Traverser
	Signals    ResponseSignals
}

ResponseTaskData returns all information needed to execute a given 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