@streamr/trackerless-network 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/logic/StreamrNode.ts

@@ -17,24 +17,24 @@ import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { ProxyDirection, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ILayer0 } from './ILayer0'
-import { ILayer1 } from './ILayer1'
+import { Layer0Node } from './Layer0Node'
+import { Layer1Node } from './Layer1Node'
 import { RandomGraphNode } from './RandomGraphNode'
-import { NETWORK_SPLIT_AVOIDANCE_LIMIT, StreamPartEntryPointDiscovery } from './StreamPartEntryPointDiscovery'
+import { NETWORK_SPLIT_AVOIDANCE_LIMIT, EntryPointDiscovery } from './EntryPointDiscovery'
 import { createRandomGraphNode } from './createRandomGraphNode'
-import { ProxyStreamConnectionClient } from './proxy/ProxyStreamConnectionClient'
+import { ProxyClient } from './proxy/ProxyClient'
 
 export type StreamPartDelivery = {
     broadcast: (msg: StreamMessage) => void
     stop: () => void
 } & ({ 
     proxied: false
-    layer1: ILayer1
+    layer1Node: Layer1Node
     node: RandomGraphNode
-    entryPointDiscovery: StreamPartEntryPointDiscovery
+    entryPointDiscovery: EntryPointDiscovery
 } | {
     proxied: true
-    client: ProxyStreamConnectionClient
+    client: ProxyClient
 })
 
 export interface Events {
@@ -54,21 +54,19 @@ export interface StreamrNodeConfig {
     metricsContext?: MetricsContext
     streamPartitionNumOfNeighbors?: number
     streamPartitionMinPropagationTargets?: number
-    nodeName?: string
-    firstConnectionTimeout?: number
     acceptProxyConnections?: boolean
 }
 
 // TODO rename class?
 export class StreamrNode extends EventEmitter<Events> {
-    private P2PTransport?: ITransport
+    private transport?: ITransport
     private connectionLocker?: ConnectionLocker
-    private layer0?: ILayer0
+    private layer0Node?: Layer0Node
     private readonly metricsContext: MetricsContext
     private readonly metrics: Metrics
-    public config: StreamrNodeConfig
-    private readonly streamParts: Map<string, StreamPartDelivery>
-    private readonly knownStreamPartEntryPoints: Map<string, PeerDescriptor[]> = new Map()
+    private readonly config: StreamrNodeConfig
+    private readonly streamParts: Map<StreamPartID, StreamPartDelivery>
+    private readonly knownStreamPartEntryPoints: Map<StreamPartID, PeerDescriptor[]> = new Map()
     private started = false
     private destroyed = false
 
@@ -84,14 +82,14 @@ export class StreamrNode extends EventEmitter<Events> {
         this.metricsContext.addMetrics('node', this.metrics)
     }
 
-    async start(startedAndJoinedLayer0: ILayer0, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void> {
+    async start(startedAndJoinedLayer0Node: Layer0Node, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void> {
         if (this.started || this.destroyed) {
             return
         }
-        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0.getPeerDescriptor())}`)
+        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0Node.getPeerDescriptor())}`)
         this.started = true
-        this.layer0 = startedAndJoinedLayer0
-        this.P2PTransport = transport
+        this.layer0Node = startedAndJoinedLayer0Node
+        this.transport = transport
         this.connectionLocker = connectionLocker
         cleanUp = () => this.destroy()
     }
@@ -102,13 +100,14 @@ export class StreamrNode extends EventEmitter<Events> {
         }
         logger.trace('Destroying StreamrNode...')
         this.destroyed = true
-        this.streamParts.forEach((stream) => stream.stop())
+        this.streamParts.forEach((streamPart) => streamPart.stop())
         this.streamParts.clear()
         this.removeAllListeners()
-        await this.layer0!.stop()
-        await this.P2PTransport!.stop()
-        this.layer0 = undefined
-        this.P2PTransport = undefined
+        // TODO stopping should be in NetworkStack#stop?
+        await this.layer0Node!.stop()
+        await this.transport!.stop()
+        this.layer0Node = undefined
+        this.transport = undefined
         this.connectionLocker = undefined
     }
 
@@ -121,48 +120,47 @@ export class StreamrNode extends EventEmitter<Events> {
     }
 
     leaveStreamPart(streamPartId: StreamPartID): void {
-        const stream = this.streamParts.get(streamPartId)
-        if (stream) {
-            stream.stop()
+        const streamPart = this.streamParts.get(streamPartId)
+        if (streamPart) {
+            streamPart.stop()
             this.streamParts.delete(streamPartId)
         }
     }
 
     joinStreamPart(streamPartId: StreamPartID): void {
         logger.debug(`Join stream part ${streamPartId}`)
-        let stream = this.streamParts.get(streamPartId)
-        if (stream !== undefined) {
+        let streamPart = this.streamParts.get(streamPartId)
+        if (streamPart !== undefined) {
             return
         }
-        const layer1 = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
-        const node = this.createRandomGraphNode(streamPartId, layer1)
-        const entryPointDiscovery = new StreamPartEntryPointDiscovery({
+        const layer1Node = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
+        const node = this.createRandomGraphNode(streamPartId, layer1Node)
+        const entryPointDiscovery = new EntryPointDiscovery({
             streamPartId,
             ownPeerDescriptor: this.getPeerDescriptor(),
-            layer1,
-            getEntryPointData: (key) => this.layer0!.getDataFromDht(key),
-            getEntryPointDataViaNode: (key, node) => this.layer0!.findDataViaPeer(key, node),
-            storeEntryPointData: (key, data) => this.layer0!.storeDataToDht(key, data),
+            layer1Node,
+            getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
+            storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
             deleteEntryPointData: async (key) => {
                 if (this.destroyed) {
                     return 
                 }
-                return this.layer0!.deleteDataFromDht(key)
+                return this.layer0Node!.deleteDataFromDht(key)
             }
         })
-        stream = {
+        streamPart = {
             proxied: false,
-            layer1,
+            layer1Node,
             node,
             entryPointDiscovery,
             broadcast: (msg: StreamMessage) => node.broadcast(msg),
             stop: () => {
                 entryPointDiscovery.destroy()
                 node.stop()
-                layer1.stop()
+                layer1Node.stop()
             }
         }
-        this.streamParts.set(streamPartId, stream)
+        this.streamParts.set(streamPartId, streamPart)
         node.on('message', (message: StreamMessage) => {
             this.emit('newMessage', message)
         })
@@ -170,56 +168,52 @@ export class StreamrNode extends EventEmitter<Events> {
             try {
                 await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
             } catch (err) {
-                logger.warn(`Failed to join to stream ${streamPartId} with error: ${err}`)
+                logger.warn(`Failed to join to stream part ${streamPartId} with error: ${err}`)
             }
         })
     }
 
-    private async startLayersAndJoinDht(streamPartId: StreamPartID, entryPointDiscovery: StreamPartEntryPointDiscovery): Promise<void> {
+    private async startLayersAndJoinDht(streamPartId: StreamPartID, entryPointDiscovery: EntryPointDiscovery): Promise<void> {
         logger.debug(`Start layers and join DHT for stream part ${streamPartId}`)
-        const stream = this.streamParts.get(streamPartId)
-        if ((stream === undefined) || stream.proxied) {
-            // leaveStream has been called (or leaveStream called, and then setProxies called)
+        const streamPart = this.streamParts.get(streamPartId)
+        if ((streamPart === undefined) || streamPart.proxied) {
+            // leaveStreamPart has been called (or leaveStreamPart called, and then setProxies called)
             return
         }
-        await stream.layer1.start()
-        await stream.node.start()
+        await streamPart.layer1Node.start()
+        await streamPart.node.start()
         let entryPoints = this.knownStreamPartEntryPoints.get(streamPartId) ?? []
-        const forwardingNode = this.layer0!.isJoinOngoing() ? this.layer0!.getKnownEntryPoints()[0] : undefined
         const discoveryResult = await entryPointDiscovery.discoverEntryPointsFromDht(
-            entryPoints.length,
-            forwardingNode
+            entryPoints.length
         )
         entryPoints = entryPoints.concat(discoveryResult.discoveredEntryPoints)
-        await stream.layer1.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT))
+        await streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT))
         if (discoveryResult.entryPointsFromDht) {
             await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.length)
         }
     }
 
-    private createLayer1Node = (streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): ILayer1 => {
+    private createLayer1Node = (streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): Layer1Node => {
         return new DhtNode({
-            transportLayer: this.layer0!,
+            transport: this.layer0Node!,
             serviceId: 'layer1::' + streamPartId,
-            peerDescriptor: this.layer0!.getPeerDescriptor(),
+            peerDescriptor: this.layer0Node!.getPeerDescriptor(),
             entryPoints,
             numberOfNodesPerKBucket: 4,
             rpcRequestTimeout: 5000,
-            dhtJoinTimeout: 20000,
-            nodeName: this.config.nodeName + ':layer1'
+            dhtJoinTimeout: 20000
         })
     }
 
-    private createRandomGraphNode = (streamPartId: StreamPartID, layer1: ILayer1) => {
+    private createRandomGraphNode = (streamPartId: StreamPartID, layer1Node: Layer1Node) => {
         return createRandomGraphNode({
-            randomGraphId: streamPartId,
-            P2PTransport: this.P2PTransport!,
-            layer1,
+            streamPartId,
+            transport: this.transport!,
+            layer1Node,
             connectionLocker: this.connectionLocker!,
-            ownPeerDescriptor: this.layer0!.getPeerDescriptor(),
+            ownPeerDescriptor: this.layer0Node!.getPeerDescriptor(),
             minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
             numOfTargetNeighbors: this.config.streamPartitionNumOfNeighbors,
-            name: this.config.nodeName,
             acceptProxyConnections: this.config.acceptProxyConnections
         })
     }
@@ -236,51 +230,44 @@ export class StreamrNode extends EventEmitter<Events> {
         }
         const enable = (nodes.length > 0) && ((connectionCount === undefined) || (connectionCount > 0))
         if (enable) {
-            let proxyClient: ProxyStreamConnectionClient
+            let client: ProxyClient
             const alreadyProxied = this.isProxiedStreamPart(streamPartId)
             if (alreadyProxied) {
-                proxyClient = (this.streamParts.get(streamPartId)! as { client: ProxyStreamConnectionClient }).client 
+                client = (this.streamParts.get(streamPartId)! as { client: ProxyClient }).client 
             } else {
-                proxyClient = this.createProxyStream(streamPartId, userId)
-                await proxyClient.start()
+                client = this.createProxyClient(streamPartId)
+                this.streamParts.set(streamPartId, {
+                    proxied: true,
+                    client,
+                    broadcast: (msg: StreamMessage) => client.broadcast(msg),
+                    stop: () => client.stop()
+                })
+                client.on('message', (message: StreamMessage) => {
+                    this.emit('newMessage', message)
+                })
+                await client.start()
             }
-            await proxyClient.setProxies(streamPartId, nodes, direction, userId, connectionCount)
+            await client.setProxies(nodes, direction, userId, connectionCount)
         } else {
             this.streamParts.get(streamPartId)?.stop()
             this.streamParts.delete(streamPartId)
         }
     }
 
-    private createProxyStream(streamPartId: StreamPartID, userId: EthereumAddress): ProxyStreamConnectionClient {
-        const client = this.createProxyStreamConnectionClient(streamPartId, userId)
-        this.streamParts.set(streamPartId, {
-            proxied: true,
-            client,
-            broadcast: (msg: StreamMessage) => client.broadcast(msg),
-            stop: () => client.stop()
-        })
-        client.on('message', (message: StreamMessage) => {
-            this.emit('newMessage', message)
-        })
-        return client
-    }
-
-    private createProxyStreamConnectionClient(streamPartId: StreamPartID, userId: EthereumAddress): ProxyStreamConnectionClient {
-        return new ProxyStreamConnectionClient({
-            P2PTransport: this.P2PTransport!,
-            ownPeerDescriptor: this.layer0!.getPeerDescriptor(),
+    private createProxyClient(streamPartId: StreamPartID): ProxyClient {
+        return new ProxyClient({
+            transport: this.transport!,
+            ownPeerDescriptor: this.layer0Node!.getPeerDescriptor(),
             streamPartId,
             connectionLocker: this.connectionLocker!,
-            minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
-            nodeName: this.config.nodeName,
-            userId
+            minPropagationTargets: this.config.streamPartitionMinPropagationTargets
         })
     }
 
     async inspect(peerDescriptor: PeerDescriptor, streamPartId: StreamPartID): Promise<boolean> {
-        const stream = this.streamParts.get(streamPartId)
-        if ((stream !== undefined) && !stream.proxied) {
-            return stream.node.inspect(peerDescriptor)
+        const streamPart = this.streamParts.get(streamPartId)
+        if ((streamPart !== undefined) && !streamPart.proxied) {
+            return streamPart.node.inspect(peerDescriptor)
         }
         return false
     }
@@ -289,33 +276,33 @@ export class StreamrNode extends EventEmitter<Events> {
         this.knownStreamPartEntryPoints.set(streamPartId, entryPoints)
     }
 
-    isProxiedStreamPart(streamId: string, direction?: ProxyDirection): boolean {
-        const stream = this.streamParts.get(streamId)
-        return (stream !== undefined)
-            && stream.proxied
-            && ((direction === undefined) || (stream.client.getDirection() === direction))
+    isProxiedStreamPart(streamPartId: StreamPartID, direction?: ProxyDirection): boolean {
+        const streamPart = this.streamParts.get(streamPartId)
+        return (streamPart !== undefined)
+            && streamPart.proxied
+            && ((direction === undefined) || (streamPart.client.getDirection() === direction))
     }
 
-    getStream(streamPartId: StreamPartID): StreamPartDelivery | undefined {
+    getStreamPartDelivery(streamPartId: StreamPartID): StreamPartDelivery | undefined {
         return this.streamParts.get(streamPartId)
     }
 
-    hasStream(streamPartId: StreamPartID): boolean {
+    hasStreamPart(streamPartId: StreamPartID): boolean {
         return this.streamParts.has(streamPartId)
     }
 
     getPeerDescriptor(): PeerDescriptor {
-        return this.layer0!.getPeerDescriptor()
+        return this.layer0Node!.getPeerDescriptor()
     }
 
     getNodeId(): NodeID {
-        return this.layer0!.getNodeId().toKey() as unknown as NodeID
+        return getNodeIdFromPeerDescriptor(this.layer0Node!.getPeerDescriptor())
     }
 
     getNeighbors(streamPartId: StreamPartID): NodeID[] {
-        const stream = this.streamParts.get(streamPartId)
-        return (stream !== undefined) && (stream.proxied === false)
-            ? stream.node.getTargetNeighborIds()
+        const streamPart = this.streamParts.get(streamPartId)
+        return (streamPart !== undefined) && (streamPart.proxied === false)
+            ? streamPart.node.getTargetNeighborIds()
             : []
     }
 

package/src/logic/createRandomGraphNode.ts

@@ -7,22 +7,29 @@ import { NodeList } from './NodeList'
 import { Propagation } from './propagation/Propagation'
 import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { MarkOptional } from 'ts-essentials'
-import { ProxyStreamConnectionServer } from './proxy/ProxyStreamConnectionServer'
+import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
-import { TemporaryConnectionRpcServer } from './temporary-connection/TemporaryConnectionRpcServer'
-import { StreamPartIDUtils } from '@streamr/protocol'
+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' | 'name' | 'numOfTargetNeighbors'
-    | 'maxNumberOfContacts' | 'minPropagationTargets' | 'rpcCommunicator' | 'nodeViewSize' | 'acceptProxyConnections'
-    | 'neighborUpdateInterval' | 'inspector' | 'temporaryConnectionServer'>
+    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'numOfTargetNeighbors'
+    | 'rpcCommunicator' | 'nodeViewSize'
+    | 'inspector' | 'temporaryConnectionRpcLocal'> & {
+        maxNumberOfContacts?: number
+        minPropagationTargets?: number
+        acceptProxyConnections?: boolean
+        neighborUpdateInterval?: number
+    }
 
 const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
     const ownNodeId = getNodeIdFromPeerDescriptor(config.ownPeerDescriptor)
-    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(`layer2-${config.randomGraphId}`, config.P2PTransport)
-    const name = config.name ?? ownNodeId
+    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
+        formStreamPartDeliveryServiceId(config.streamPartId),
+        config.transport
+    )
     const numOfTargetNeighbors = config.numOfTargetNeighbors ?? 4
     const maxNumberOfContacts = config.maxNumberOfContacts ?? 20
     const minPropagationTargets = config.minPropagationTargets ?? 2
@@ -32,21 +39,21 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxNumberOfContacts)
     const targetNeighbors = config.targetNeighbors ?? new NodeList(ownNodeId, maxNumberOfContacts)
 
-    const temporaryConnectionServer = new TemporaryConnectionRpcServer({
-        randomGraphId: config.randomGraphId,
+    const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
+        streamPartId: config.streamPartId,
         rpcCommunicator,
         ownPeerDescriptor: config.ownPeerDescriptor
     })
-    const proxyConnectionServer = acceptProxyConnections ? new ProxyStreamConnectionServer({
+    const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
         ownPeerDescriptor: config.ownPeerDescriptor,
-        streamPartId: StreamPartIDUtils.parse(config.randomGraphId),
+        streamPartId: config.streamPartId,
         rpcCommunicator
     }) : undefined
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
         sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionServer.getNodes().get(neighborId)
-            const proxyConnection = proxyConnectionServer?.getConnection(neighborId)
+            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
+            const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
             if (remote) {
                 await remote.sendStreamMessage(msg)
             } else if (proxyConnection) {
@@ -58,33 +65,33 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     })
     const handshaker = config.handshaker ?? new Handshaker({
         ownPeerDescriptor: config.ownPeerDescriptor,
-        randomGraphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker,
         rpcCommunicator,
         nearbyNodeView,
         randomNodeView,
         targetNeighbors,
-        N: numOfTargetNeighbors
+        maxNeighborCount: numOfTargetNeighbors
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
         targetNeighbors,
         nearbyNodeView,
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
-        N: numOfTargetNeighbors
+        minCount: numOfTargetNeighbors
     })
     const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
         targetNeighbors,
         nearbyNodeView,
         ownPeerDescriptor: config.ownPeerDescriptor,
         neighborFinder,
-        randomGraphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         rpcCommunicator,
         neighborUpdateInterval
     })
     const inspector = config.inspector ?? new Inspector({
         ownPeerDescriptor: config.ownPeerDescriptor,
         rpcCommunicator,
-        graphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker
     })
     return {
@@ -98,15 +105,10 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         neighborUpdateManager,
         propagation,
         numOfTargetNeighbors,
-        minPropagationTargets,
-        maxNumberOfContacts,
-        name,
         nodeViewSize: maxNumberOfContacts,
-        acceptProxyConnections,
-        proxyConnectionServer,
-        neighborUpdateInterval,
+        proxyConnectionRpcLocal,
         inspector,
-        temporaryConnectionServer
+        temporaryConnectionRpcLocal
     }
 }
 

package/src/logic/formStreamPartDeliveryServiceId.ts

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

package/src/logic/inspect/Inspector.ts

@@ -4,12 +4,13 @@ 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 { RemoteTemporaryConnectionRpcServer } from '../temporary-connection/RemoteTemporaryConnectionRpcServer'
+import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
 interface InspectorConfig {
     ownPeerDescriptor: PeerDescriptor
-    graphId: string
+    streamPartId: StreamPartID
     rpcCommunicator: RpcCommunicator
     connectionLocker: ConnectionLocker
     inspectionTimeout?: number
@@ -29,7 +30,7 @@ const DEFAULT_TIMEOUT = 60 * 1000
 export class Inspector implements IInspector {
 
     private readonly sessions: Map<NodeID, InspectSession> = new Map()
-    private readonly graphId: string
+    private readonly streamPartId: StreamPartID
     private readonly client: ProtoRpcClient<TemporaryConnectionRpcClient>
     private readonly ownPeerDescriptor: PeerDescriptor
     private readonly connectionLocker: ConnectionLocker
@@ -37,7 +38,7 @@ export class Inspector implements IInspector {
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
 
     constructor(config: InspectorConfig) {
-        this.graphId = config.graphId
+        this.streamPartId = config.streamPartId
         this.ownPeerDescriptor = config.ownPeerDescriptor
         this.client = toProtoRpcClient(new TemporaryConnectionRpcClient(config.rpcCommunicator.getRpcClientTransport()))
         this.connectionLocker = config.connectionLocker
@@ -46,8 +47,8 @@ export class Inspector implements IInspector {
     }
 
     async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: string): Promise<void> {
-        const remoteRandomGraphNode = new RemoteTemporaryConnectionRpcServer(this.ownPeerDescriptor, peerDescriptor, this.graphId, this.client)
-        await remoteRandomGraphNode.openConnection()
+        const rpcRemote = new TemporaryConnectionRpcRemote(this.ownPeerDescriptor, peerDescriptor, this.streamPartId, this.client)
+        await rpcRemote.openConnection()
         this.connectionLocker.lockConnection(peerDescriptor, lockId)
     }
 
@@ -56,7 +57,7 @@ export class Inspector implements IInspector {
         const session = new InspectSession({
             inspectedNode: nodeId
         })
-        const lockId = `inspector-${this.graphId}`
+        const lockId = `inspector-${this.streamPartId}`
         this.sessions.set(nodeId, session)
         await this.openInspectConnection(peerDescriptor, lockId)
         let success = false

package/src/logic/neighbor-discovery/{HandshakerServer.ts → HandshakeRpcLocal.ts}

@@ -4,28 +4,28 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeList } from '../NodeList'
 import { ConnectionLocker, DhtCallContext, PeerDescriptor } from '@streamr/dht'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { RemoteHandshaker } from './RemoteHandshaker'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { HandshakeRpcRemote } from './HandshakeRpcRemote'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { binaryToHex } from '@streamr/utils'
+import { StreamPartID } from '@streamr/protocol'
 
-interface HandshakerServerConfig {
-    randomGraphId: string
-    ownPeerDescriptor: PeerDescriptor
+interface HandshakeRpcLocalConfig {
+    streamPartId: StreamPartID
     targetNeighbors: NodeList
     connectionLocker: ConnectionLocker
     ongoingHandshakes: Set<NodeID>
-    N: number
-    createRemoteHandshaker: (target: PeerDescriptor) => RemoteHandshaker
-    createRemoteNode: (peerDescriptor: PeerDescriptor) => RemoteRandomGraphNode
+    maxNeighborCount: number
+    createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
+    createDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => DeliveryRpcRemote
     handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => Promise<boolean>
 }
 
-export class HandshakerServer implements IHandshakeRpc {
+export class HandshakeRpcLocal implements IHandshakeRpc {
 
-    private readonly config: HandshakerServerConfig
+    private readonly config: HandshakeRpcLocalConfig
 
-    constructor(config: HandshakerServerConfig) {
+    constructor(config: HandshakeRpcLocalConfig) {
         this.config = config
     }
 
@@ -40,7 +40,7 @@ export class HandshakerServer implements IHandshakeRpc {
             || this.config.ongoingHandshakes.has(getNodeIdFromPeerDescriptor(senderDescriptor))
         ) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.N) {
+        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
         } else if (this.config.targetNeighbors.size(getInterleaveSourceIds()) >= 2) {
             return this.acceptHandshakeWithInterleaving(request, senderDescriptor)
@@ -54,8 +54,8 @@ export class HandshakerServer implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.randomGraphId)
+        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return res
     }
 
@@ -77,13 +77,13 @@ export class HandshakerServer implements IHandshakeRpc {
         const furthest = this.config.targetNeighbors.getFurthest(exclude)
         const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined
         if (furthest) {
-            const remote = this.config.createRemoteHandshaker(furthest.getPeerDescriptor())
+            const remote = this.config.createRpcRemote(furthest.getPeerDescriptor())
             remote.interleaveNotice(requester)
             this.config.targetNeighbors.remove(furthest.getPeerDescriptor())
-            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.randomGraphId)
+            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.streamPartId)
         }
-        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.randomGraphId)
+        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return {
             requestId: request.requestId,
             accepted: true,
@@ -92,11 +92,11 @@ export class HandshakerServer implements IHandshakeRpc {
     }
 
     async interleaveNotice(message: InterleaveNotice, context: ServerCallContext): Promise<Empty> {
-        if (message.randomGraphId === this.config.randomGraphId) {
+        if (message.streamPartId === this.config.streamPartId) {
             const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
             const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
             if (this.config.targetNeighbors.hasNodeById(senderId)) {
-                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.randomGraphId)
+                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
                 this.config.targetNeighbors.remove(senderPeerDescriptor)
             }
             this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId).catch((_e) => {})