@streamr/trackerless-network 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/src/logic/StreamrNode.ts

@@ -3,7 +3,9 @@ import {
     DhtNode,
     ITransport,
     PeerDescriptor,
-    EXISTING_CONNECTION_TIMEOUT
+    EXISTING_CONNECTION_TIMEOUT,
+    DhtAddress,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
 import {
@@ -16,8 +18,7 @@ import {
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
-import { ProxyDirection, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection, StreamPartitionInfo, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
 import { RandomGraphNode } from './RandomGraphNode'
@@ -44,8 +45,6 @@ export interface Events {
 
 const logger = new Logger(module)
 
-let cleanUp: () => Promise<void> = async () => { }
-
 interface Metrics extends MetricsDefinition {
     broadcastMessagesPerSecond: Metric
     broadcastBytesPerSecond: Metric
@@ -53,7 +52,7 @@ interface Metrics extends MetricsDefinition {
 
 export interface StreamrNodeConfig {
     metricsContext?: MetricsContext
-    streamPartitionNumOfNeighbors?: number
+    streamPartitionNeighborTargetCount?: number
     streamPartitionMinPropagationTargets?: number
     acceptProxyConnections?: boolean
     rpcRequestTimeout?: number
@@ -93,7 +92,6 @@ export class StreamrNode extends EventEmitter<Events> {
         this.layer0Node = startedAndJoinedLayer0Node
         this.transport = transport
         this.connectionLocker = connectionLocker
-        cleanUp = () => this.destroy()
     }
 
     async destroy(): Promise<void> {
@@ -112,10 +110,13 @@ export class StreamrNode extends EventEmitter<Events> {
 
     broadcast(msg: StreamMessage): void {
         const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
+        logger.debug(`Broadcasting to stream part ${streamPartId}`)
         this.joinStreamPart(streamPartId)
         this.streamParts.get(streamPartId)!.broadcast(msg)
-        this.metrics.broadcastMessagesPerSecond.record(1)
-        this.metrics.broadcastBytesPerSecond.record(msg.content.length)
+        if (msg.body.oneofKind === 'contentMessage') {
+            this.metrics.broadcastMessagesPerSecond.record(1)
+            this.metrics.broadcastBytesPerSecond.record(msg.body.contentMessage.content.length)
+        }
     }
 
     async leaveStreamPart(streamPartId: StreamPartID): Promise<void> {
@@ -127,26 +128,25 @@ export class StreamrNode extends EventEmitter<Events> {
     }
 
     joinStreamPart(streamPartId: StreamPartID): void {
-        logger.debug(`Join stream part ${streamPartId}`)
         let streamPart = this.streamParts.get(streamPartId)
         if (streamPart !== undefined) {
             return
         }
+        logger.debug(`Join stream part ${streamPartId}`)
         const layer1Node = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
-        const node = this.createRandomGraphNode(streamPartId, layer1Node)
         const entryPointDiscovery = new EntryPointDiscovery({
             streamPartId,
             localPeerDescriptor: this.getPeerDescriptor(),
             layer1Node,
-            getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
+            fetchEntryPointData: (key) => this.layer0Node!.fetchDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
-            deleteEntryPointData: async (key) => {
-                if (this.destroyed) {
-                    return 
-                }
-                return this.layer0Node!.deleteDataFromDht(key)
-            }
+            deleteEntryPointData: async (key) => this.layer0Node!.deleteDataFromDht(key, false)
         })
+        const node = this.createRandomGraphNode(
+            streamPartId,
+            layer1Node, 
+            () => entryPointDiscovery.isLocalNodeEntryPoint()
+        )
         streamPart = {
             proxied: false,
             layer1Node,
@@ -163,6 +163,14 @@ export class StreamrNode extends EventEmitter<Events> {
         node.on('message', (message: StreamMessage) => {
             this.emit('newMessage', message)
         })
+        const handleEntryPointLeave = async () => {
+            if (this.destroyed || entryPointDiscovery.isLocalNodeEntryPoint() || this.knownStreamPartEntryPoints.has(streamPartId)) {
+                return
+            }
+            const entryPoints = await entryPointDiscovery.discoverEntryPointsFromDht(0)
+            await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.discoveredEntryPoints.length)
+        }
+        node.on('entryPointLeaveDetected', () => handleEntryPointLeave())
         setImmediate(async () => {
             try {
                 await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
@@ -186,7 +194,10 @@ export class StreamrNode extends EventEmitter<Events> {
             entryPoints.length
         )
         entryPoints = entryPoints.concat(discoveryResult.discoveredEntryPoints)
-        await streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT))
+        await Promise.all([
+            streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT)),
+            streamPart.layer1Node.joinRing()
+        ])
         if (discoveryResult.entryPointsFromDht) {
             await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.length)
         }
@@ -198,13 +209,17 @@ export class StreamrNode extends EventEmitter<Events> {
             serviceId: 'layer1::' + streamPartId,
             peerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             entryPoints,
-            numberOfNodesPerKBucket: 4,
+            numberOfNodesPerKBucket: 4,  // TODO use config option or named constant?
             rpcRequestTimeout: EXISTING_CONNECTION_TIMEOUT,
-            dhtJoinTimeout: 20000
+            dhtJoinTimeout: 20000  // TODO use config option or named constant?
         })
     }
 
-    private createRandomGraphNode(streamPartId: StreamPartID, layer1Node: Layer1Node) {
+    private createRandomGraphNode(
+        streamPartId: StreamPartID,
+        layer1Node: Layer1Node,
+        isLocalNodeEntryPoint: () => boolean
+    ) {
         return createRandomGraphNode({
             streamPartId,
             transport: this.transport!,
@@ -212,9 +227,10 @@ export class StreamrNode extends EventEmitter<Events> {
             connectionLocker: this.connectionLocker!,
             localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
-            numOfTargetNeighbors: this.config.streamPartitionNumOfNeighbors,
+            neighborTargetCount: this.config.streamPartitionNeighborTargetCount,
             acceptProxyConnections: this.config.acceptProxyConnections,
-            rpcRequestTimeout: this.config.rpcRequestTimeout
+            rpcRequestTimeout: this.config.rpcRequestTimeout,
+            isLocalNodeEntryPoint
         })
     }
 
@@ -225,6 +241,7 @@ export class StreamrNode extends EventEmitter<Events> {
         userId: EthereumAddress,
         connectionCount?: number
     ): Promise<void> {
+        // TODO explicit default value for "acceptProxyConnections" or make it required
         if (this.config.acceptProxyConnections) {
             throw new Error('cannot set proxies when acceptProxyConnections=true')
         }
@@ -272,6 +289,20 @@ export class StreamrNode extends EventEmitter<Events> {
         return false
     }
 
+    // TODO inline this method?
+    getNodeInfo(): StreamPartitionInfo[] {
+        const streamParts = Array.from(this.streamParts.entries()).filter(([_, node]) => node.proxied === false)
+        return streamParts.map(([streamPartId]) => {
+            const stream = this.streamParts.get(streamPartId)! as { node: RandomGraphNode, layer1Node: Layer1Node }
+            return {
+                id: streamPartId,
+                controlLayerNeighbors: stream.layer1Node.getNeighbors(),
+                deliveryLayerNeighbors: stream.node.getNeighbors()
+            }
+        })
+
+    }
+
     setStreamPartEntryPoints(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): void {
         this.knownStreamPartEntryPoints.set(streamPartId, entryPoints)
     }
@@ -295,14 +326,14 @@ export class StreamrNode extends EventEmitter<Events> {
         return this.layer0Node!.getLocalPeerDescriptor()
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())
     }
 
-    getNeighbors(streamPartId: StreamPartID): NodeID[] {
+    getNeighbors(streamPartId: StreamPartID): DhtAddress[] {
         const streamPart = this.streamParts.get(streamPartId)
         return (streamPart !== undefined) && (streamPart.proxied === false)
-            ? streamPart.node.getTargetNeighborIds()
+            ? streamPart.node.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
             : []
     }
 
@@ -310,17 +341,3 @@ export class StreamrNode extends EventEmitter<Events> {
         return Array.from(this.streamParts.keys()).map((id) => StreamPartIDUtils.parse(id))
     }
 }
-
-[`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`].forEach((term) => {
-    process.on(term, async () => {
-        await cleanUp()
-        process.exit()
-    })
-})
-
-declare let window: any
-if (typeof window === 'object') {
-    window.addEventListener('unload', async () => {
-        await cleanUp()
-    })
-}

package/src/logic/createRandomGraphNode.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
@@ -10,15 +10,14 @@ import { MarkOptional } from 'ts-essentials'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
-    'nearbyNodeView' | 'randomNodeView' | 'targetNeighbors' | 'propagation'
-    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'numOfTargetNeighbors'
+    'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
+    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborTargetCount'
     | 'rpcCommunicator' | 'nodeViewSize'
     | 'inspector' | 'temporaryConnectionRpcLocal'> & {
-        maxNumberOfContacts?: number
+        maxContactCount?: number
         minPropagationTargets?: number
         acceptProxyConnections?: boolean
         neighborUpdateInterval?: number
@@ -30,19 +29,23 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         formStreamPartDeliveryServiceId(config.streamPartId),
         config.transport
     )
-    const numOfTargetNeighbors = config.numOfTargetNeighbors ?? 4
-    const maxNumberOfContacts = config.maxNumberOfContacts ?? 20
+    const neighborTargetCount = config.neighborTargetCount ?? 4
+    const maxContactCount = config.maxContactCount ?? 20
     const minPropagationTargets = config.minPropagationTargets ?? 2
     const acceptProxyConnections = config.acceptProxyConnections ?? false
     const neighborUpdateInterval = config.neighborUpdateInterval ?? 10000
-    const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, numOfTargetNeighbors + 1)
-    const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxNumberOfContacts)
-    const targetNeighbors = config.targetNeighbors ?? new NodeList(ownNodeId, maxNumberOfContacts)
+    const neighbors = config.neighbors ?? new NodeList(ownNodeId, maxContactCount)
+    const leftNodeView = config.leftNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const rightNodeView = config.rightNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const ongoingHandshakes = new Set<DhtAddress>()
 
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
-        streamPartId: config.streamPartId,
         rpcCommunicator,
-        localPeerDescriptor: config.localPeerDescriptor
+        localPeerDescriptor: config.localPeerDescriptor,
+        streamPartId: config.streamPartId,
+        connectionLocker: config.connectionLocker
     })
     const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
         localPeerDescriptor: config.localPeerDescriptor,
@@ -51,8 +54,8 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     }) : undefined
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
-        sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
+        sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
+            const remote = neighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
             const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
             if (remote) {
                 await remote.sendStreamMessage(msg)
@@ -66,28 +69,35 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const handshaker = config.handshaker ?? new Handshaker({
         localPeerDescriptor: config.localPeerDescriptor,
         streamPartId: config.streamPartId,
-        connectionLocker: config.connectionLocker,
         rpcCommunicator,
+        neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
         randomNodeView,
-        targetNeighbors,
-        maxNeighborCount: numOfTargetNeighbors,
-        rpcRequestTimeout: config.rpcRequestTimeout
+        maxNeighborCount: neighborTargetCount,
+        rpcRequestTimeout: config.rpcRequestTimeout,
+        ongoingHandshakes
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
-        targetNeighbors,
+        neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
+        randomNodeView,
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
-        minCount: numOfTargetNeighbors
+        minCount: neighborTargetCount
     })
     const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
-        targetNeighbors,
+        neighbors,
         nearbyNodeView,
         localPeerDescriptor: config.localPeerDescriptor,
         neighborFinder,
         streamPartId: config.streamPartId,
         rpcCommunicator,
-        neighborUpdateInterval
+        neighborUpdateInterval,
+        neighborTargetCount,
+        ongoingHandshakes
     })
     const inspector = config.inspector ?? new Inspector({
         localPeerDescriptor: config.localPeerDescriptor,
@@ -97,16 +107,18 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     })
     return {
         ...config,
+        neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
         randomNodeView,
-        targetNeighbors,
         rpcCommunicator,
         handshaker,
         neighborFinder,
         neighborUpdateManager,
         propagation,
-        numOfTargetNeighbors,
-        nodeViewSize: maxNumberOfContacts,
+        neighborTargetCount,
+        nodeViewSize: maxContactCount,
         proxyConnectionRpcLocal,
         inspector,
         temporaryConnectionRpcLocal

package/src/logic/formStreamPartDeliveryServiceId.ts

@@ -1,5 +1,6 @@
+import { ServiceID } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
 
-export const formStreamPartDeliveryServiceId = (streamPartId: StreamPartID): string => {
+export const formStreamPartDeliveryServiceId = (streamPartId: StreamPartID): ServiceID => {
     return `stream-part-delivery-${streamPartId}`
 }

package/src/logic/inspect/InspectSession.ts

@@ -1,14 +1,14 @@
 import { EventEmitter } from 'eventemitter3'
-import { NodeID } from '../../identifiers'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { binaryToHex } from '@streamr/utils'
+import { DhtAddress } from '@streamr/dht'
 
 export interface Events {
     done: () => void
 }
 
 interface InspectSessionConfig {
-    inspectedNode: NodeID
+    inspectedNode: DhtAddress
 }
 
 const createMessageKey = (messageId: MessageID): string => {
@@ -18,14 +18,14 @@ export class InspectSession extends EventEmitter<Events> {
     
     // Boolean indicates if the message has been received by the inspected node
     private readonly inspectionMessages: Map<string, boolean> = new Map()
-    private readonly inspectedNode: NodeID
+    private readonly inspectedNode: DhtAddress
 
     constructor(config: InspectSessionConfig) {
         super()
         this.inspectedNode = config.inspectedNode
     }
 
-    markMessage(senderId: NodeID, messageId: MessageID): void {
+    markMessage(senderId: DhtAddress, messageId: MessageID): void {
         const messageKey = createMessageKey(messageId)
         if (!this.inspectionMessages.has(messageKey)) {
             this.inspectionMessages.set(messageKey, senderId === this.inspectedNode)
@@ -44,6 +44,10 @@ export class InspectSession extends EventEmitter<Events> {
         return this.inspectionMessages.size
     }
 
+    onlyMarkedByInspectedNode(): boolean {
+        return Array.from(this.inspectionMessages.values()).every((value) => value === true)
+    }
+
     stop(): void {
         this.emit('done')
     }

package/src/logic/inspect/Inspector.ts

@@ -1,55 +1,65 @@
-import { PeerDescriptor, ConnectionLocker } from '@streamr/dht'
+import { PeerDescriptor, ConnectionLocker, LockID, DhtAddress, getNodeIdFromPeerDescriptor, ListeningRpcCommunicator } from '@streamr/dht'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { Logger, waitForEvent3 } from '@streamr/utils'
 import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface InspectorConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    rpcCommunicator: RpcCommunicator
+    rpcCommunicator: ListeningRpcCommunicator
     connectionLocker: ConnectionLocker
     inspectionTimeout?: number
-    openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
-}
-
-export interface IInspector {
-    inspect(peerDescriptor: PeerDescriptor): Promise<boolean>
-    markMessage(sender: NodeID, messageId: MessageID): void
-    isInspected(nodeId: NodeID): boolean
-    stop(): void
+    openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
+    closeInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
 }
 
 const logger = new Logger(module)
 const DEFAULT_TIMEOUT = 60 * 1000
 
-export class Inspector implements IInspector {
+export class Inspector {
 
-    private readonly sessions: Map<NodeID, InspectSession> = new Map()
+    private readonly sessions: Map<DhtAddress, InspectSession> = new Map()
     private readonly streamPartId: StreamPartID
-    private readonly client: ProtoRpcClient<TemporaryConnectionRpcClient>
     private readonly localPeerDescriptor: PeerDescriptor
+    private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly connectionLocker: ConnectionLocker
     private readonly inspectionTimeout: number
-    private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
+    private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
+    private readonly closeInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
 
     constructor(config: InspectorConfig) {
         this.streamPartId = config.streamPartId
         this.localPeerDescriptor = config.localPeerDescriptor
-        this.client = toProtoRpcClient(new TemporaryConnectionRpcClient(config.rpcCommunicator.getRpcClientTransport()))
+        this.rpcCommunicator = config.rpcCommunicator
         this.connectionLocker = config.connectionLocker
         this.inspectionTimeout = config.inspectionTimeout ?? DEFAULT_TIMEOUT
         this.openInspectConnection = config.openInspectConnection ?? this.defaultOpenInspectConnection
+        this.closeInspectConnection = config.closeInspectConnection ?? this.defaultCloseInspectConnection
     }
 
-    async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: string): Promise<void> {
-        const rpcRemote = new TemporaryConnectionRpcRemote(this.localPeerDescriptor, peerDescriptor, this.streamPartId, this.client)
+    async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
+        const rpcRemote = new TemporaryConnectionRpcRemote(
+            this.localPeerDescriptor,
+            peerDescriptor,
+            this.rpcCommunicator,
+            TemporaryConnectionRpcClient
+        )
         await rpcRemote.openConnection()
-        this.connectionLocker.lockConnection(peerDescriptor, lockId)
+        this.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(peerDescriptor), lockId)
+    }
+
+    async defaultCloseInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
+        const rpcRemote = new TemporaryConnectionRpcRemote(
+            this.localPeerDescriptor,
+            peerDescriptor,
+            this.rpcCommunicator,
+            TemporaryConnectionRpcClient
+        )
+        await rpcRemote.closeConnection()
+        this.connectionLocker.weakUnlockConnection(getNodeIdFromPeerDescriptor(peerDescriptor), lockId)
     }
 
     async inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
@@ -67,17 +77,17 @@ export class Inspector implements IInspector {
         } catch (err) {
             logger.trace('Inspect session timed out, removing')
         } finally {
+            await this.closeInspectConnection(peerDescriptor, lockId)
             this.sessions.delete(nodeId)
-            this.connectionLocker.unlockConnection(peerDescriptor, lockId)
         }
-        return success || session.getInspectedMessageCount() < 1
+        return success || session.getInspectedMessageCount() < 1 || session.onlyMarkedByInspectedNode()
     }
 
-    markMessage(sender: NodeID, messageId: MessageID): void {
+    markMessage(sender: DhtAddress, messageId: MessageID): void {
         this.sessions.forEach((session) => session.markMessage(sender, messageId))
     }
 
-    isInspected(nodeId: NodeID): boolean {
+    isInspected(nodeId: DhtAddress): boolean {
         return this.sessions.has(nodeId)
     }