@streamr/trackerless-network 0.0.1-tatum.5 → 0.0.1-tatum.7

package/src/logic/RandomGraphNode.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from 'eventemitter3'
 import {
     PeerDescriptor,
-    DhtPeer,
     ListeningRpcCommunicator,
     ITransport,
     ConnectionLocker
@@ -15,9 +14,9 @@ import {
     MessageID,
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NodeList } from './NodeList'
-import { NetworkRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { RemoteRandomGraphNode } from './RemoteRandomGraphNode'
-import { INetworkRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from './DeliveryRpcRemote'
+import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DuplicateMessageDetector } from './DuplicateMessageDetector'
 import { Logger, addManagedEventListener } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
@@ -25,13 +24,14 @@ import { IHandshaker } from './neighbor-discovery/Handshaker'
 import { Propagation } from './propagation/Propagation'
 import { INeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { INeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { StreamNodeServer } from './StreamNodeServer'
-import { ProxyStreamConnectionServer } from './proxy/ProxyStreamConnectionServer'
+import { DeliveryRpcLocal } from './DeliveryRpcLocal'
+import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { IInspector } from './inspect/Inspector'
-import { TemporaryConnectionRpcServer } from './temporary-connection/TemporaryConnectionRpcServer'
+import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { markAndCheckDuplicate } from './utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { ILayer1 } from './ILayer1'
+import { StreamPartID } from '@streamr/protocol'
 
 export interface Events {
     message: (message: StreamMessage) => void
@@ -39,7 +39,7 @@ export interface Events {
 }
 
 export interface StrictRandomGraphNodeConfig {
-    randomGraphId: string
+    streamPartId: StreamPartID
     layer1: ILayer1
     P2PTransport: ITransport
     connectionLocker: ConnectionLocker
@@ -54,49 +54,44 @@ export interface StrictRandomGraphNodeConfig {
     propagation: Propagation
     rpcCommunicator: ListeningRpcCommunicator
     numOfTargetNeighbors: number
-    maxNumberOfContacts: number
-    minPropagationTargets: number
-    name: string
-    acceptProxyConnections: boolean
-    neighborUpdateInterval: number
     inspector: IInspector
-    temporaryConnectionServer: TemporaryConnectionRpcServer
-    proxyConnectionServer?: ProxyStreamConnectionServer
+    temporaryConnectionRpcLocal: TemporaryConnectionRpcLocal
+    proxyConnectionRpcLocal?: ProxyConnectionRpcLocal
 }
 
 const logger = new Logger(module)
 
 export class RandomGraphNode extends EventEmitter<Events> {
-    private stopped = false
+
     private started = false
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector>
     private config: StrictRandomGraphNodeConfig
-    private readonly server: INetworkRpc
+    private readonly deliveryRpcLocal: IDeliveryRpc
     private abortController: AbortController = new AbortController()
 
     constructor(config: StrictRandomGraphNodeConfig) {
         super()
         this.config = config
         this.duplicateDetectors = new Map()
-        this.server = new StreamNodeServer({
+        this.deliveryRpcLocal = new DeliveryRpcLocal({
             ownPeerDescriptor: this.config.ownPeerDescriptor,
-            randomGraphId: this.config.randomGraphId,
+            streamPartId: this.config.streamPartId,
             rpcCommunicator: this.config.rpcCommunicator,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
             onLeaveNotice: (senderId: NodeID) => {
-                const contact = this.config.nearbyNodeView.getNeighborById(senderId)
-                || this.config.randomNodeView.getNeighborById(senderId)
-                || this.config.targetNeighbors.getNeighborById(senderId)
-                || this.config.proxyConnectionServer?.getConnection(senderId )?.remote
+                const contact = this.config.nearbyNodeView.get(senderId)
+                || this.config.randomNodeView.get(senderId)
+                || this.config.targetNeighbors.get(senderId)
+                || this.config.proxyConnectionRpcLocal?.getConnection(senderId )?.remote
                 // TODO: check integrity of notifier?
                 if (contact) {
                     this.config.layer1.removeContact(contact.getPeerDescriptor(), true)
                     this.config.targetNeighbors.remove(contact.getPeerDescriptor())
                     this.config.nearbyNodeView.remove(contact.getPeerDescriptor())
-                    this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.randomGraphId)
+                    this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.streamPartId)
                     this.config.neighborFinder.start([senderId])
-                    this.config.proxyConnectionServer?.removeConnection(senderId)
+                    this.config.proxyConnectionRpcLocal?.removeConnection(senderId)
                 }
             },
             markForInspection: (senderId: NodeID, messageId: MessageID) => this.config.inspector.markMessage(senderId, messageId)
@@ -109,25 +104,25 @@ export class RandomGraphNode extends EventEmitter<Events> {
         addManagedEventListener<any, any>(
             this.config.layer1 as any,
             'newContact',
-            (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => this.newContact(peerDescriptor, closestPeers),
+            (_peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => this.newContact(closestPeers),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
             this.config.layer1 as any,
             'contactRemoved',
-            (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => this.removedContact(peerDescriptor, closestPeers),
+            (_peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => this.removedContact(closestPeers),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
             this.config.layer1 as any,
             'newRandomContact',
-            (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.newRandomContact(peerDescriptor, randomPeers),
+            (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.newRandomContact(randomPeers),
             this.abortController.signal
         )   
         addManagedEventListener<any, any>(
             this.config.layer1 as any,
             'randomContactRemoved',
-            (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.removedRandomContact(peerDescriptor, randomPeers),
+            (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.removedRandomContact(randomPeers),
             this.abortController.signal
         )   
         addManagedEventListener<any, any>(
@@ -145,9 +140,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
             },
             this.abortController.signal
         )
-        if (this.config.proxyConnectionServer !== undefined) {
+        if (this.config.proxyConnectionRpcLocal !== undefined) {
             addManagedEventListener(
-                this.config.proxyConnectionServer,
+                this.config.proxyConnectionRpcLocal,
                 'newConnection',
                 (id: NodeID) => this.config.propagation.onNeighborJoined(id),
                 this.abortController.signal
@@ -155,7 +150,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
         const candidates = this.getNeighborCandidatesFromLayer1()
         if (candidates.length > 0) {
-            this.newContact(candidates[0], candidates)
+            this.newContact(candidates)
         }
         this.config.neighborFinder.start()
         await this.config.neighborUpdateManager.start()
@@ -163,16 +158,16 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private registerDefaultServerMethods(): void {
         this.config.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.server.sendStreamMessage(msg, context))
+            (msg: StreamMessage, context) => this.deliveryRpcLocal.sendStreamMessage(msg, context))
         this.config.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.server.leaveStreamPartNotice(req, context))
+            (req: LeaveStreamPartNotice, context) => this.deliveryRpcLocal.leaveStreamPartNotice(req, context))
         this.config.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection',
-            (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionServer.openConnection(req, context))
+            (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.openConnection(req, context))
     }
 
-    private newContact(_newContact: PeerDescriptor, closestNodes: PeerDescriptor[]): void {
+    private newContact(closestNodes: PeerDescriptor[]): void {
         logger.trace(`New nearby contact found`)
-        if (this.stopped) {
+        if (this.isStopped()) {
             return
         }
         this.updateNearbyNodeView(closestNodes)
@@ -181,9 +176,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
     }
 
-    private removedContact(_removedContact: PeerDescriptor, closestNodes: PeerDescriptor[]): void {
+    private removedContact(closestNodes: PeerDescriptor[]): void {
         logger.trace(`Nearby contact removed`)
-        if (this.stopped) {
+        if (this.isStopped()) {
             return
         }
         this.updateNearbyNodeView(closestNodes)
@@ -191,11 +186,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private updateNearbyNodeView(nodes: PeerDescriptor[]) {
         this.config.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) =>
-            new RemoteRandomGraphNode(
+            new DeliveryRpcRemote(
                 this.config.ownPeerDescriptor,
                 descriptor,
-                this.config.randomGraphId,
-                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                this.config.streamPartId,
+                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
             )
         ))
         for (const descriptor of this.config.layer1.getKBucketPeers()) {
@@ -203,26 +198,26 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 break
             }
             this.config.nearbyNodeView.add(
-                new RemoteRandomGraphNode(
+                new DeliveryRpcRemote(
                     this.config.ownPeerDescriptor,
                     descriptor,
-                    this.config.randomGraphId,
-                    toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                    this.config.streamPartId,
+                    toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
                 )
             )
         }
     }
 
-    private newRandomContact(_newDescriptor: PeerDescriptor, randomNodes: PeerDescriptor[]): void {
-        if (this.stopped) {
+    private newRandomContact(randomNodes: PeerDescriptor[]): void {
+        if (this.isStopped()) {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new RemoteRandomGraphNode(
+            new DeliveryRpcRemote(
                 this.config.ownPeerDescriptor,
                 descriptor,
-                this.config.randomGraphId,
-                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                this.config.streamPartId,
+                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
             )
         ))
         if (this.config.targetNeighbors.size() < this.config.numOfTargetNeighbors) {
@@ -230,17 +225,17 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
     }
 
-    private removedRandomContact(_removedDescriptor: PeerDescriptor, randomNodes: PeerDescriptor[]): void {
+    private removedRandomContact(randomNodes: PeerDescriptor[]): void {
         logger.trace(`New nearby contact found`)
-        if (this.stopped) {
+        if (this.isStopped()) {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new RemoteRandomGraphNode(
+            new DeliveryRpcRemote(
                 this.config.ownPeerDescriptor,
                 descriptor,
-                this.config.randomGraphId,
-                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                this.config.streamPartId,
+                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
             )
         ))
     }
@@ -248,16 +243,16 @@ export class RandomGraphNode extends EventEmitter<Events> {
     private onNodeDisconnected(peerDescriptor: PeerDescriptor): void {
         if (this.config.targetNeighbors.hasNode(peerDescriptor)) {
             this.config.targetNeighbors.remove(peerDescriptor)
-            this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.randomGraphId)
+            this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.streamPartId)
             this.config.neighborFinder.start([getNodeIdFromPeerDescriptor(peerDescriptor)])
-            this.config.temporaryConnectionServer.removeNode(peerDescriptor)
+            this.config.temporaryConnectionRpcLocal.removeNode(peerDescriptor)
         }
     }
 
     private getNeighborCandidatesFromLayer1(): PeerDescriptor[] {
         const uniqueNodes = new Set<PeerDescriptor>()
-        this.config.layer1.getNeighborList().getClosestContacts(this.config.nodeViewSize).forEach((contact: DhtPeer) => {
-            uniqueNodes.add(contact.getPeerDescriptor())
+        this.config.layer1.getClosestContacts(this.config.nodeViewSize).forEach((peer: PeerDescriptor) => {
+            uniqueNodes.add(peer)
         })
         this.config.layer1.getKBucketPeers().forEach((peer: PeerDescriptor) => {
             uniqueNodes.add(peer)
@@ -265,9 +260,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return Array.from(uniqueNodes)
     }
 
-    public hasProxyConnection(nodeId: NodeID): boolean {
-        if (this.config.proxyConnectionServer) {
-            return this.config.proxyConnectionServer.hasConnection(nodeId)
+    hasProxyConnection(nodeId: NodeID): boolean {
+        if (this.config.proxyConnectionRpcLocal) {
+            return this.config.proxyConnectionRpcLocal.hasConnection(nodeId)
         }
         return false
     }
@@ -276,10 +271,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
         if (!this.started) {
             return
         }
-        this.stopped = true
         this.abortController.abort()
-        this.config.proxyConnectionServer?.stop()
-        this.config.targetNeighbors.getNodes().map((remote) => remote.leaveStreamPartNotice())
+        this.config.proxyConnectionRpcLocal?.stop()
+        this.config.targetNeighbors.getAll().map((remote) => remote.leaveStreamPartNotice())
         this.config.rpcCommunicator.stop()
         this.removeAllListeners()
         this.config.nearbyNodeView.stop()
@@ -304,11 +298,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private getPropagationTargets(msg: StreamMessage): NodeID[] {
         let propagationTargets = this.config.targetNeighbors.getIds()
-        if (this.config.proxyConnectionServer) {
-            propagationTargets = propagationTargets.concat(this.config.proxyConnectionServer!.getPropagationTargets(msg))
+        if (this.config.proxyConnectionRpcLocal) {
+            propagationTargets = propagationTargets.concat(this.config.proxyConnectionRpcLocal!.getPropagationTargets(msg))
         }
         propagationTargets = propagationTargets.filter((target) => !this.config.inspector.isInspected(target ))
-        propagationTargets = propagationTargets.concat(this.config.temporaryConnectionServer.getNodes().getIds())
+        propagationTargets = propagationTargets.concat(this.config.temporaryConnectionRpcLocal.getNodes().getIds())
         return propagationTargets
     }
 
@@ -321,7 +315,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
     }
 
     getTargetNeighborIds(): NodeID[] {
-        if (!this.started && this.stopped) {
+        if (!this.started && this.isStopped()) {
             return []
         }
         return this.config.targetNeighbors.getIds()
@@ -330,4 +324,8 @@ export class RandomGraphNode extends EventEmitter<Events> {
     getNearbyNodeView(): NodeList {
         return this.config.nearbyNodeView
     }
+
+    private isStopped() {
+        return this.abortController.signal.aborted
+    }
 }