@streamr/trackerless-network 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/logic/StreamrNode.ts

@@ -2,7 +2,8 @@ import {
     ConnectionLocker,
     DhtNode,
     ITransport,
-    PeerDescriptor
+    PeerDescriptor,
+    EXISTING_CONNECTION_TIMEOUT
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
 import {
@@ -26,7 +27,7 @@ import { ProxyClient } from './proxy/ProxyClient'
 
 export type StreamPartDelivery = {
     broadcast: (msg: StreamMessage) => void
-    stop: () => void
+    stop: () => Promise<void>
 } & ({ 
     proxied: false
     layer1Node: Layer1Node
@@ -55,6 +56,7 @@ export interface StreamrNodeConfig {
     streamPartitionNumOfNeighbors?: number
     streamPartitionMinPropagationTargets?: number
     acceptProxyConnections?: boolean
+    rpcRequestTimeout?: number
 }
 
 // TODO rename class?
@@ -86,7 +88,7 @@ export class StreamrNode extends EventEmitter<Events> {
         if (this.started || this.destroyed) {
             return
         }
-        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0Node.getPeerDescriptor())}`)
+        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0Node.getLocalPeerDescriptor())}`)
         this.started = true
         this.layer0Node = startedAndJoinedLayer0Node
         this.transport = transport
@@ -100,12 +102,9 @@ export class StreamrNode extends EventEmitter<Events> {
         }
         logger.trace('Destroying StreamrNode...')
         this.destroyed = true
-        this.streamParts.forEach((streamPart) => streamPart.stop())
+        await Promise.all(Array.from(this.streamParts.values()).map((streamPart) => streamPart.stop()))
         this.streamParts.clear()
         this.removeAllListeners()
-        // TODO stopping should be in NetworkStack#stop?
-        await this.layer0Node!.stop()
-        await this.transport!.stop()
         this.layer0Node = undefined
         this.transport = undefined
         this.connectionLocker = undefined
@@ -119,10 +118,10 @@ export class StreamrNode extends EventEmitter<Events> {
         this.metrics.broadcastBytesPerSecond.record(msg.content.length)
     }
 
-    leaveStreamPart(streamPartId: StreamPartID): void {
+    async leaveStreamPart(streamPartId: StreamPartID): Promise<void> {
         const streamPart = this.streamParts.get(streamPartId)
         if (streamPart) {
-            streamPart.stop()
+            await streamPart.stop()
             this.streamParts.delete(streamPartId)
         }
     }
@@ -137,7 +136,7 @@ export class StreamrNode extends EventEmitter<Events> {
         const node = this.createRandomGraphNode(streamPartId, layer1Node)
         const entryPointDiscovery = new EntryPointDiscovery({
             streamPartId,
-            ownPeerDescriptor: this.getPeerDescriptor(),
+            localPeerDescriptor: this.getPeerDescriptor(),
             layer1Node,
             getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
@@ -154,10 +153,10 @@ export class StreamrNode extends EventEmitter<Events> {
             node,
             entryPointDiscovery,
             broadcast: (msg: StreamMessage) => node.broadcast(msg),
-            stop: () => {
-                entryPointDiscovery.destroy()
+            stop: async () => {
+                await entryPointDiscovery.destroy()
                 node.stop()
-                layer1Node.stop()
+                await layer1Node.stop()
             }
         }
         this.streamParts.set(streamPartId, streamPart)
@@ -193,28 +192,29 @@ export class StreamrNode extends EventEmitter<Events> {
         }
     }
 
-    private createLayer1Node = (streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): Layer1Node => {
+    private createLayer1Node(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): Layer1Node {
         return new DhtNode({
             transport: this.layer0Node!,
             serviceId: 'layer1::' + streamPartId,
-            peerDescriptor: this.layer0Node!.getPeerDescriptor(),
+            peerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             entryPoints,
             numberOfNodesPerKBucket: 4,
-            rpcRequestTimeout: 5000,
+            rpcRequestTimeout: EXISTING_CONNECTION_TIMEOUT,
             dhtJoinTimeout: 20000
         })
     }
 
-    private createRandomGraphNode = (streamPartId: StreamPartID, layer1Node: Layer1Node) => {
+    private createRandomGraphNode(streamPartId: StreamPartID, layer1Node: Layer1Node) {
         return createRandomGraphNode({
             streamPartId,
             transport: this.transport!,
             layer1Node,
             connectionLocker: this.connectionLocker!,
-            ownPeerDescriptor: this.layer0Node!.getPeerDescriptor(),
+            localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
             numOfTargetNeighbors: this.config.streamPartitionNumOfNeighbors,
-            acceptProxyConnections: this.config.acceptProxyConnections
+            acceptProxyConnections: this.config.acceptProxyConnections,
+            rpcRequestTimeout: this.config.rpcRequestTimeout
         })
     }
 
@@ -240,7 +240,7 @@ export class StreamrNode extends EventEmitter<Events> {
                     proxied: true,
                     client,
                     broadcast: (msg: StreamMessage) => client.broadcast(msg),
-                    stop: () => client.stop()
+                    stop: async () => client.stop()
                 })
                 client.on('message', (message: StreamMessage) => {
                     this.emit('newMessage', message)
@@ -249,7 +249,7 @@ export class StreamrNode extends EventEmitter<Events> {
             }
             await client.setProxies(nodes, direction, userId, connectionCount)
         } else {
-            this.streamParts.get(streamPartId)?.stop()
+            await this.streamParts.get(streamPartId)?.stop()
             this.streamParts.delete(streamPartId)
         }
     }
@@ -257,7 +257,7 @@ export class StreamrNode extends EventEmitter<Events> {
     private createProxyClient(streamPartId: StreamPartID): ProxyClient {
         return new ProxyClient({
             transport: this.transport!,
-            ownPeerDescriptor: this.layer0Node!.getPeerDescriptor(),
+            localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             streamPartId,
             connectionLocker: this.connectionLocker!,
             minPropagationTargets: this.config.streamPartitionMinPropagationTargets
@@ -292,11 +292,11 @@ export class StreamrNode extends EventEmitter<Events> {
     }
 
     getPeerDescriptor(): PeerDescriptor {
-        return this.layer0Node!.getPeerDescriptor()
+        return this.layer0Node!.getLocalPeerDescriptor()
     }
 
     getNodeId(): NodeID {
-        return getNodeIdFromPeerDescriptor(this.layer0Node!.getPeerDescriptor())
+        return getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())
     }
 
     getNeighbors(streamPartId: StreamPartID): NodeID[] {
@@ -317,3 +317,10 @@ export class StreamrNode extends EventEmitter<Events> {
         process.exit()
     })
 })
+
+declare let window: any
+if (typeof window === 'object') {
+    window.addEventListener('unload', async () => {
+        await cleanUp()
+    })
+}

package/src/logic/createRandomGraphNode.ts

@@ -25,7 +25,7 @@ type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
     }
 
 const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
-    const ownNodeId = getNodeIdFromPeerDescriptor(config.ownPeerDescriptor)
+    const ownNodeId = getNodeIdFromPeerDescriptor(config.localPeerDescriptor)
     const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
         formStreamPartDeliveryServiceId(config.streamPartId),
         config.transport
@@ -42,10 +42,10 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
         streamPartId: config.streamPartId,
         rpcCommunicator,
-        ownPeerDescriptor: config.ownPeerDescriptor
+        localPeerDescriptor: config.localPeerDescriptor
     })
     const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
-        ownPeerDescriptor: config.ownPeerDescriptor,
+        localPeerDescriptor: config.localPeerDescriptor,
         streamPartId: config.streamPartId,
         rpcCommunicator
     }) : undefined
@@ -64,14 +64,15 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         }
     })
     const handshaker = config.handshaker ?? new Handshaker({
-        ownPeerDescriptor: config.ownPeerDescriptor,
+        localPeerDescriptor: config.localPeerDescriptor,
         streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker,
         rpcCommunicator,
         nearbyNodeView,
         randomNodeView,
         targetNeighbors,
-        maxNeighborCount: numOfTargetNeighbors
+        maxNeighborCount: numOfTargetNeighbors,
+        rpcRequestTimeout: config.rpcRequestTimeout
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
         targetNeighbors,
@@ -82,14 +83,14 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
         targetNeighbors,
         nearbyNodeView,
-        ownPeerDescriptor: config.ownPeerDescriptor,
+        localPeerDescriptor: config.localPeerDescriptor,
         neighborFinder,
         streamPartId: config.streamPartId,
         rpcCommunicator,
         neighborUpdateInterval
     })
     const inspector = config.inspector ?? new Inspector({
-        ownPeerDescriptor: config.ownPeerDescriptor,
+        localPeerDescriptor: config.localPeerDescriptor,
         rpcCommunicator,
         streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker

package/src/logic/inspect/Inspector.ts

@@ -9,7 +9,7 @@ import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface InspectorConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: RpcCommunicator
     connectionLocker: ConnectionLocker
@@ -32,14 +32,14 @@ export class Inspector implements IInspector {
     private readonly sessions: Map<NodeID, InspectSession> = new Map()
     private readonly streamPartId: StreamPartID
     private readonly client: ProtoRpcClient<TemporaryConnectionRpcClient>
-    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly localPeerDescriptor: PeerDescriptor
     private readonly connectionLocker: ConnectionLocker
     private readonly inspectionTimeout: number
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
 
     constructor(config: InspectorConfig) {
         this.streamPartId = config.streamPartId
-        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.localPeerDescriptor = config.localPeerDescriptor
         this.client = toProtoRpcClient(new TemporaryConnectionRpcClient(config.rpcCommunicator.getRpcClientTransport()))
         this.connectionLocker = config.connectionLocker
         this.inspectionTimeout = config.inspectionTimeout ?? DEFAULT_TIMEOUT
@@ -47,7 +47,7 @@ export class Inspector implements IInspector {
     }
 
     async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: string): Promise<void> {
-        const rpcRemote = new TemporaryConnectionRpcRemote(this.ownPeerDescriptor, peerDescriptor, this.streamPartId, this.client)
+        const rpcRemote = new TemporaryConnectionRpcRemote(this.localPeerDescriptor, peerDescriptor, this.streamPartId, this.client)
         await rpcRemote.openConnection()
         this.connectionLocker.lockConnection(peerDescriptor, lockId)
     }

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -19,7 +19,7 @@ import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakerConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
     targetNeighbors: NodeList
@@ -27,6 +27,7 @@ interface HandshakerConfig {
     randomNodeView: NodeList
     rpcCommunicator: RpcCommunicator
     maxNeighborCount: number
+    rpcRequestTimeout?: number
 }
 
 const logger = new Logger(module)
@@ -141,10 +142,11 @@ export class Handshaker implements IHandshaker {
 
     private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: NodeID): Promise<boolean> {
         const targetNeighbor = new HandshakeRpcRemote(
-            this.config.ownPeerDescriptor,
+            this.config.localPeerDescriptor,
             target,
             this.config.streamPartId,
-            this.client
+            this.client,
+            this.config.rpcRequestTimeout
         )
         const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
@@ -162,15 +164,22 @@ export class Handshaker implements IHandshaker {
     }
 
     private createRpcRemote(targetPeerDescriptor: PeerDescriptor): HandshakeRpcRemote {
-        return new HandshakeRpcRemote(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
+        return new HandshakeRpcRemote(
+            this.config.localPeerDescriptor,
+            targetPeerDescriptor,
+            this.config.streamPartId,
+            this.client,
+            this.config.rpcRequestTimeout
+        )
     }
 
     private createDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): DeliveryRpcRemote {
         return new DeliveryRpcRemote(
-            this.config.ownPeerDescriptor,
+            this.config.localPeerDescriptor,
             targetPeerDescriptor,
             this.config.streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport())),
+            this.config.rpcRequestTimeout
         )
     }
 

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -11,7 +11,7 @@ import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: INeighborFinder
@@ -64,6 +64,6 @@ export class NeighborUpdateManager implements INeighborUpdateManager {
     }
 
     private createRemote(targetPeerDescriptor: PeerDescriptor): NeighborUpdateRpcRemote {
-        return new NeighborUpdateRpcRemote(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
+        return new NeighborUpdateRpcRemote(this.config.localPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
     }
 }

package/src/logic/neighbor-discovery/NeighborUpdateRpcLocal.ts

@@ -11,7 +11,7 @@ import { INeighborFinder } from './NeighborFinder'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateRpcLocalConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
@@ -35,12 +35,12 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
             const newPeerDescriptors = message.neighborDescriptors
                 .filter((peerDescriptor) => {
                     const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-                    const ownNodeId = getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor)
+                    const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
                     return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
                 })
             newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
                 new DeliveryRpcRemote(
-                    this.config.ownPeerDescriptor,
+                    this.config.localPeerDescriptor,
                     peerDescriptor,
                     this.config.streamPartId,
                     toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))

package/src/logic/proxy/ProxyClient.ts

@@ -44,7 +44,7 @@ export const retry = async <T>(task: () => Promise<T>, description: string, abor
 
 interface ProxyClientConfig {
     transport: ITransport
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
     minPropagationTargets?: number // TODO could be required option if we apply all defaults somewhere at higher level
@@ -77,9 +77,9 @@ export class ProxyClient extends EventEmitter {
         super()
         this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
-        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor), 1000)
+        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
         this.deliveryRpcLocal = new DeliveryRpcLocal({
-            ownPeerDescriptor: this.config.ownPeerDescriptor,
+            localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
@@ -150,7 +150,7 @@ export class ProxyClient extends EventEmitter {
 
     private getInvalidConnections(): NodeID[] {
         return Array.from(this.connections.keys()).filter((id) => {
-            return !this.definition!.nodes.has(id )
+            return !this.definition!.nodes.has(id)
                 || this.definition!.direction !== this.connections.get(id)
         })
     }
@@ -167,13 +167,13 @@ export class ProxyClient extends EventEmitter {
     private async attemptConnection(nodeId: NodeID, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const client = toProtoRpcClient(new ProxyConnectionRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-        const rpcRemote = new ProxyConnectionRpcRemote(this.config.ownPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
+        const rpcRemote = new ProxyConnectionRpcRemote(this.config.localPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
             this.connections.set(nodeId, direction)
             const remote = new DeliveryRpcRemote(
-                this.config.ownPeerDescriptor,
+                this.config.localPeerDescriptor,
                 peerDescriptor,
                 this.config.streamPartId,
                 toProtoRpcClient(new DeliveryRpcClient(this.rpcCommunicator.getRpcClientTransport()))

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -26,7 +26,7 @@ interface ProxyConnection {
 }
 
 interface ProxyConnectionRpcLocalConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
 }
@@ -95,7 +95,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             direction: request.direction,
             userId: toEthereumAddress(binaryToHex(request.userId, true)),
             remote: new DeliveryRpcRemote(
-                this.config.ownPeerDescriptor,
+                this.config.localPeerDescriptor,
                 senderPeerDescriptor,
                 this.config.streamPartId,
                 toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,4 +1,4 @@
-import { Remote } from '@streamr/dht'
+import { Remote, EXISTING_CONNECTION_TIMEOUT } from '@streamr/dht'
 import { EthereumAddress, Logger, hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -13,7 +13,7 @@ export class ProxyConnectionRpcRemote extends Remote<IProxyConnectionRpcClient>
             userId: hexToBinary(userId)
         }
         const options = this.formDhtRpcOptions({
-            timeout: 5000
+            timeout: EXISTING_CONNECTION_TIMEOUT
         })
         try {
             const res = await this.getClient().requestConnection(request, options)

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -13,7 +13,7 @@ import { StreamPartID } from '@streamr/protocol'
 interface TemporaryConnectionRpcLocalConfig {
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
 } 
 
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
@@ -23,7 +23,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
-        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.ownPeerDescriptor), 10)
+        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
     }
 
     getNodes(): NodeList {
@@ -40,7 +40,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
     ): Promise<TemporaryConnectionResponse> {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
         const remote = new DeliveryRpcRemote(
-            this.config.ownPeerDescriptor,
+            this.config.localPeerDescriptor,
             sender,
             this.config.streamPartId,
             toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))