Class NodeManager

Readonly basePath

Readonly checkSeedConnectionsHandlerId

Readonly connectionConnectTimeoutTime

Readonly gcBucketHandlerId

Readonly pingAndSetNodeHandlerId

Readonly refreshBucketHandlerId

claimNode

• claimNode(targetNodeId, tran?, ctx?): Promise<void>

• Call this function upon receiving a "claim node request" notification from another node.

  Parameters

  • targetNodeId: NodeId

  • Optional tran: DBTransaction

  • Optional ctx: ContextTimed

  Returns Promise<void>

getBucket

• getBucket(bucketIndex, tran?): Promise<undefined | NodeBucket>

• Gets the specified bucket from the NodeGraph

  Parameters

  • bucketIndex: number

  • Optional tran: DBTransaction

  Returns Promise<undefined | NodeBucket>

getNodeAddress

• getNodeAddress(nodeId, tran): Promise<undefined | NodeAddress>

• Retrieves the node Address from the NodeGraph

  Parameters

  • nodeId: NodeId

    node ID of the target node

  • tran: DBTransaction

  Returns Promise<undefined | NodeAddress>

  Node Address of the target node

handleClaimNode

• handleClaimNode(requestingNodeId, input, tran?): AsyncGenerator<AgentRPCResponseResult<AgentClaimMessage>, any, unknown>

• Parameters

  • requestingNodeId: NodeId

  • input: AsyncIterableIterator<AgentRPCRequestParams<AgentClaimMessage>>

  • Optional tran: DBTransaction

  Returns AsyncGenerator<AgentRPCResponseResult<AgentClaimMessage>, any, unknown>

knowsNode

• knowsNode(targetNodeId, tran): Promise<boolean>

• Determines whether a node ID -> node address mapping exists in the NodeGraph

  Parameters

  • targetNodeId: NodeId

    the node ID of the node to find

  • tran: DBTransaction

  Returns Promise<boolean>

  true if the node exists in the table, false otherwise

pingNode

• pingNode(nodeId, address?, ctx?): PromiseCancellable<boolean>

• Determines whether a node in the Polykey network is online.

  Parameters

  • nodeId: NodeId

    NodeId of the node we're pinging

  • Optional address: NodeAddress

    Optional Host and Port we want to ping

  • Optional ctx: Partial<ContextTimedInput>

  Returns PromiseCancellable<boolean>

  true if online, false if offline

refreshBucket

• refreshBucket(bucketIndex, pingTimeoutTime?, ctx?): PromiseCancellable<void>

• Kademlia refresh bucket operation. It picks a random node within a bucket and does a search for that node. Connections during the search will share node information with other nodes.

  Parameters

  • bucketIndex: number

  • Optional pingTimeoutTime: number

  • Optional ctx: Partial<ContextTimed>

  Returns PromiseCancellable<void>

requestChainData

• requestChainData(targetNodeId, claimId?, ctx?): PromiseCancellable<Record<ClaimId, SignedClaim>>

• Connects to the target node, and retrieves its sigchain data. Verifies and returns the decoded chain as ChainData. Note: this will drop any unverifiable claims. For node1 -> node2 claims, the verification process also involves connecting to node2 to verify the claim (to retrieve its signing public key).

  Parameters

  • targetNodeId: NodeId

    Id of the node to connect request the chain data of.

  • Optional claimId: ClaimId

    If set then we get the claims newer that this claim Id.

  • Optional ctx: Partial<ContextTimed>

  Returns PromiseCancellable<Record<ClaimId, SignedClaim>>

resetBuckets

• resetBuckets(): Promise<void>

• To be called on key renewal. Re-orders all nodes in all buckets with respect to the new node ID.

  Returns Promise<void>

setNode

• setNode(nodeId, nodeAddress, block?, force?, pingTimeoutTime?, ctx?, tran?): PromiseCancellable<void>

• Adds a node to the node graph. This assumes that you have already authenticated the node Updates the node if the node already exists This operation is blocking by default - set block 2qto false to make it non-blocking

  Parameters

  • nodeId: NodeId

    Id of the node we wish to add

  • nodeAddress: NodeAddress

    Expected address of the node we want to add

  • Optional block: boolean

    When true it will wait for any garbage collection to finish before returning.

  • Optional force: boolean

    Flag for if we want to add the node without authenticating or if the bucket is full. This will drop the oldest node in favor of the new.

  • Optional pingTimeoutTime: number

    Timeout for each ping operation during garbage collection.

  • Optional ctx: Partial<ContextTimed>

  • Optional tran: DBTransaction

  Returns PromiseCancellable<void>

syncNodeGraph

• syncNodeGraph(block?, pingTimeoutTime?, ctx?): PromiseCancellable<void>

• Perform an initial database synchronisation: get k of the closest nodes from each seed node and add them to this database Establish a connection to each node before adding it By default this operation is blocking, set block to false to make it non-blocking

  Parameters

  • Optional block: boolean

  • Optional pingTimeoutTime: number

  • Optional ctx: Partial<ContextTimedInput>

  Returns PromiseCancellable<void>

unsetNode

• unsetNode(nodeId, tran): Promise<void>

• Removes a node from the NodeGraph

  Parameters

  • nodeId: NodeId

  • tran: DBTransaction

  Returns Promise<void>

updateRefreshBucketDelay

• updateRefreshBucketDelay(bucketIndex, delay?, lazy?, tran?): Promise<Task>

• Parameters

  • bucketIndex: number

  • delay: number = ...

  • lazy: boolean = true

  • Optional tran: DBTransaction

  Returns Promise<Task>