query

type ClosestNodesIter[K kad.Key[K], N kad.NodeID[K]] struct {
	// contains filtered or unexported fields
}

type EventPoolAddFindCloserQuery[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID    coordt.QueryID // the id to use for the new query
	Target     K              // the target key for the query
	Seed       []N            // an initial set of close nodes the query should use
	NumResults int            // the minimum number of nodes to successfully contact before considering iteration complete
}

type EventPoolAddQuery[K kad.Key[K], N kad.NodeID[K], M coordt.Message] struct {
	QueryID    coordt.QueryID // the id to use for the new query
	Target     K              // the target key for the query
	Message    M              // message to be sent to each node
	Seed       []N            // an initial set of close nodes the query should use
	NumResults int            // the minimum number of nodes to successfully contact before considering iteration complete
}

type EventPoolNodeFailure[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID coordt.QueryID // the id of the query that sent the message
	NodeID  N              // the node the message was sent to
	Error   error          // the error that caused the failure, if any
}

type EventPoolNodeResponse[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID     coordt.QueryID // the id of the query that sent the message
	NodeID      N              // the node the message was sent to
	CloserNodes []N            // the closer nodes sent by the node
}

type EventPoolPoll struct{}

type EventPoolStopQuery struct {
	QueryID coordt.QueryID // the id of the query that should be stopped
}

type EventQueryCancel struct{}

type EventQueryNodeFailure[K kad.Key[K], N kad.NodeID[K]] struct {
	NodeID N     // the node the message was sent to
	Error  error // the error that caused the failure, if any
}

type EventQueryNodeResponse[K kad.Key[K], N kad.NodeID[K]] struct {
	NodeID      N   // the node the message was sent to
	CloserNodes []N // the closer nodes sent by the node
}

type EventQueryPoll struct{}

type NodeIter[K kad.Key[K], N kad.NodeID[K]] interface {
	// Add adds node information to the iterator
	Add(*NodeStatus[K, N])

	// Find returns the node information corresponding to the given Kademlia key
	Find(K) (*NodeStatus[K, N], bool)

	// Each applies fn to each entry in the iterator in order. Each stops and returns true if fn returns true.
	// Otherwise, Each returns false when there are no further entries.
	Each(ctx context.Context, fn func(context.Context, *NodeStatus[K, N]) bool) bool
}

type NodeState interface {
	// contains filtered or unexported methods
}

type NodeStatus[K kad.Key[K], N kad.NodeID[K]] struct {
	NodeID N
	State  NodeState
}

type Pool[K kad.Key[K], N kad.NodeID[K], M coordt.Message] struct {
	// contains filtered or unexported fields
}

type PoolConfig struct {
	Concurrency      int           // the maximum number of queries that may be waiting for message responses at any one time
	Timeout          time.Duration // the time to wait before terminating a query that is not making progress
	Replication      int           // the 'k' parameter defined by Kademlia
	QueryConcurrency int           // the maximum number of concurrent requests that each query may have in flight
	RequestTimeout   time.Duration // the timeout queries should use for contacting a single node
	Clock            clock.Clock   // a clock that may replaced by a mock when testing
}

type PoolEvent interface {
	// contains filtered or unexported methods
}

type PoolState interface {
	// contains filtered or unexported methods
}

type Query[K kad.Key[K], N kad.NodeID[K], M coordt.Message] struct {
	// contains filtered or unexported fields
}

type QueryConfig struct {
	Concurrency    int           // the maximum number of concurrent requests that may be in flight
	NumResults     int           // the minimum number of nodes to successfully contact before considering iteration complete
	RequestTimeout time.Duration // the timeout for contacting a single node
	Clock          clock.Clock   // a clock that may replaced by a mock when testing
}

type QueryEvent interface {
	// contains filtered or unexported methods
}

type QueryState interface {
	// contains filtered or unexported methods
}

type QueryStats struct {
	Start    time.Time
	End      time.Time
	Requests int
	Success  int
	Failure  int
}

type SequentialIter[K kad.Key[K], N kad.NodeID[K]] struct {
	// contains filtered or unexported fields
}

type StateNodeFailed struct{}

type StateNodeNotContacted struct{}

type StateNodeSucceeded struct{}

type StateNodeUnresponsive struct{}

type StateNodeWaiting struct {
	Deadline time.Time
}

type StatePoolFindCloser[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID coordt.QueryID
	Target  K // the key that the query wants to find closer nodes for
	NodeID  N // the node to send the message to
	Stats   QueryStats
}

type StatePoolIdle struct{}

type StatePoolQueryFinished[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID      coordt.QueryID
	Stats        QueryStats
	ClosestNodes []N
}

type StatePoolQueryTimeout struct {
	QueryID coordt.QueryID
	Stats   QueryStats
}

type StatePoolSendMessage[K kad.Key[K], N kad.NodeID[K], M coordt.Message] struct {
	QueryID coordt.QueryID
	NodeID  N // the node to send the message to
	Message M
	Stats   QueryStats
}

type StatePoolWaitingAtCapacity struct{}

type StatePoolWaitingWithCapacity struct{}

type StateQueryFindCloser[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID coordt.QueryID
	Target  K // the key that the query wants to find closer nodes for
	NodeID  N // the node to send the message to
	Stats   QueryStats
}

type StateQueryFinished[K kad.Key[K], N kad.NodeID[K]] struct {
	QueryID      coordt.QueryID
	Stats        QueryStats
	ClosestNodes []N // contains the closest nodes to the target key that were found
}

type StateQuerySendMessage[K kad.Key[K], N kad.NodeID[K], M coordt.Message] struct {
	QueryID coordt.QueryID
	NodeID  N // the node to send the message to
	Message M
	Stats   QueryStats
}

type StateQueryWaitingAtCapacity struct {
	QueryID coordt.QueryID
	Stats   QueryStats
}

type StateQueryWaitingWithCapacity struct {
	QueryID coordt.QueryID
	Stats   QueryStats
}