@streamr/trackerless-network 100.0.0-testnet-three.6 → 100.1.0

package/src/logic/{StreamrNode.ts → ContentDeliveryManager.ts}

@@ -1,10 +1,10 @@
 import {
     ConnectionLocker,
+    DhtAddress,
     DhtNode,
+    EXISTING_CONNECTION_TIMEOUT,
     ITransport,
     PeerDescriptor,
-    EXISTING_CONNECTION_TIMEOUT,
-    DhtAddress,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
@@ -18,11 +18,11 @@ import {
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { ProxyDirection, StreamPartitionInfo, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection, StreamMessage, StreamPartitionInfo } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { EntryPointDiscovery, NETWORK_SPLIT_AVOIDANCE_LIMIT } from './EntryPointDiscovery'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
 import { RandomGraphNode } from './RandomGraphNode'
-import { NETWORK_SPLIT_AVOIDANCE_LIMIT, EntryPointDiscovery } from './EntryPointDiscovery'
 import { createRandomGraphNode } from './createRandomGraphNode'
 import { ProxyClient } from './proxy/ProxyClient'
 
@@ -50,7 +50,7 @@ interface Metrics extends MetricsDefinition {
     broadcastBytesPerSecond: Metric
 }
 
-export interface StreamrNodeConfig {
+export interface ContentDeliveryManagerConfig {
     metricsContext?: MetricsContext
     streamPartitionNeighborTargetCount?: number
     streamPartitionMinPropagationTargets?: number
@@ -58,20 +58,20 @@ export interface StreamrNodeConfig {
     rpcRequestTimeout?: number
 }
 
-// TODO rename class?
-export class StreamrNode extends EventEmitter<Events> {
+export class ContentDeliveryManager extends EventEmitter<Events> {
+
     private transport?: ITransport
     private connectionLocker?: ConnectionLocker
     private layer0Node?: Layer0Node
     private readonly metricsContext: MetricsContext
     private readonly metrics: Metrics
-    private readonly config: StreamrNodeConfig
+    private readonly config: ContentDeliveryManagerConfig
     private readonly streamParts: Map<StreamPartID, StreamPartDelivery>
     private readonly knownStreamPartEntryPoints: Map<StreamPartID, PeerDescriptor[]> = new Map()
     private started = false
     private destroyed = false
 
-    constructor(config: StreamrNodeConfig) {
+    constructor(config: ContentDeliveryManagerConfig) {
         super()
         this.config = config
         this.streamParts = new Map()
@@ -87,7 +87,6 @@ export class StreamrNode extends EventEmitter<Events> {
         if (this.started || this.destroyed) {
             return
         }
-        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0Node.getLocalPeerDescriptor())}`)
         this.started = true
         this.layer0Node = startedAndJoinedLayer0Node
         this.transport = transport
@@ -98,7 +97,7 @@ export class StreamrNode extends EventEmitter<Events> {
         if (!this.started || this.destroyed) {
             return
         }
-        logger.trace('Destroying StreamrNode...')
+        logger.trace('Destroying ContentDeliveryManager')
         this.destroyed = true
         await Promise.all(Array.from(this.streamParts.values()).map((streamPart) => streamPart.stop()))
         this.streamParts.clear()
@@ -113,8 +112,10 @@ export class StreamrNode extends EventEmitter<Events> {
         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> {
@@ -136,7 +137,7 @@ export class StreamrNode extends EventEmitter<Events> {
             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) => this.layer0Node!.deleteDataFromDht(key, false)
         })
@@ -173,7 +174,7 @@ export class StreamrNode extends EventEmitter<Events> {
             try {
                 await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
             } catch (err) {
-                logger.warn(`Failed to join to stream part ${streamPartId} with error: ${err}`)
+                logger.warn(`Failed to join to stream part ${streamPartId}`, { err })
             }
         })
     }
@@ -192,7 +193,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)
         }
@@ -292,7 +296,7 @@ export class StreamrNode extends EventEmitter<Events> {
             return {
                 id: streamPartId,
                 controlLayerNeighbors: stream.layer1Node.getNeighbors(),
-                deliveryLayerNeighbors: stream.node.getNeighbors()
+                contentDeliveryLayerNeighbors: stream.node.getNeighbors()
             }
         })
 

package/src/logic/{DeliveryRpcLocal.ts → ContentDeliveryRpcLocal.ts}

@@ -6,11 +6,11 @@ import {
     MessageRef,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { IContentDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { StreamPartID } from '@streamr/protocol'
 
-export interface DeliveryRpcLocalConfig {
+export interface ContentDeliveryRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
@@ -20,11 +20,11 @@ export interface DeliveryRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
 }
 
-export class DeliveryRpcLocal implements IDeliveryRpc {
+export class ContentDeliveryRpcLocal implements IContentDeliveryRpc {
     
-    private readonly config: DeliveryRpcLocalConfig
+    private readonly config: ContentDeliveryRpcLocalConfig
 
-    constructor(config: DeliveryRpcLocalConfig) {
+    constructor(config: ContentDeliveryRpcLocalConfig) {
         this.config = config
     }
 

package/src/logic/{DeliveryRpcRemote.ts → ContentDeliveryRpcRemote.ts}

@@ -4,12 +4,12 @@ import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
-export class DeliveryRpcRemote extends RpcRemote<DeliveryRpcClient> {
+export class ContentDeliveryRpcRemote extends RpcRemote<ContentDeliveryRpcClient> {
 
     async sendStreamMessage(msg: StreamMessage): Promise<void> {
         const options = this.formDhtRpcOptions({

package/src/logic/EntryPointDiscovery.ts

@@ -13,7 +13,7 @@ import { Any } from '../proto/google/protobuf/any'
 import { Layer1Node } from './Layer1Node'
 
 export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
-    return getDhtAddressFromRaw(new Uint8Array(createHash('md5').update(streamPartId).digest()))
+    return getDhtAddressFromRaw(new Uint8Array((createHash('sha1').update(streamPartId).digest())))
 }
 
 const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
@@ -46,7 +46,7 @@ const exponentialRunOff = async (
         try { // Abort controller throws unexpected errors in destroy?
             await wait(delay, abortSignal)
         } catch (err) {
-            logger.trace(`${err}`)
+            logger.trace(`${err}`)  // TODO Do we need logging?
         }
     }
 }
@@ -60,7 +60,7 @@ interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     localPeerDescriptor: PeerDescriptor
     layer1Node: Layer1Node
-    getEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
+    fetchEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
     storeEntryPointData: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
     deleteEntryPointData: (key: DhtAddress) => Promise<void>
     storeInterval?: number
@@ -111,7 +111,7 @@ export class EntryPointDiscovery {
     private async queryEntrypoints(key: DhtAddress): Promise<PeerDescriptor[]> {
         logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)}`)
         try {
-            const result = await this.config.getEntryPointData(key)
+            const result = await this.config.fetchEntryPointData(key)
             return parseEntryPointData(result)
         } catch (err) {
             return []

package/src/logic/Layer0Node.ts

@@ -5,7 +5,7 @@ export interface Layer0Node extends ITransport {
     joinDht(entryPointDescriptors: PeerDescriptor[]): Promise<void>
     hasJoined(): boolean
     getLocalPeerDescriptor(): PeerDescriptor
-    getDataFromDht(key: DhtAddress): Promise<DataEntry[]>
+    fetchDataFromDht(key: DhtAddress): Promise<DataEntry[]>
     storeDataToDht(key: DhtAddress, data: Any): Promise<PeerDescriptor[]>
     deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>
     waitForNetworkConnectivity(): Promise<void>

package/src/logic/Layer1Node.ts

@@ -1,21 +1,36 @@
-import { DhtAddress, PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, RingContacts } from '@streamr/dht'
 
 export interface Layer1NodeEvents {
     contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
 }
 
 export interface Layer1Node {
     on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
+    on<T extends keyof Layer1NodeEvents>(
+        eventName: T,
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts) => void
+    ): void
+    once<T extends keyof Layer1NodeEvents>(
+        eventName: T, 
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts) => void
+    ): void
+    off<T extends keyof Layer1NodeEvents>(
+        eventName: T,
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts
+    ) => void): void
     removeContact: (nodeId: DhtAddress) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
     getNeighbors: () => PeerDescriptor[]
     getNeighborCount(): number
     joinDht: (entryPoints: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean) => Promise<void>
+    joinRing: () => Promise<void>
     start: () => Promise<void>
     stop: () => Promise<void>
 }

package/src/logic/NodeList.ts

@@ -1,13 +1,14 @@
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { sample } from 'lodash'
-import { DeliveryRpcRemote } from './DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
 
 export interface Events {
-    nodeAdded: (id: DhtAddress, remote: DeliveryRpcRemote) => any
+    nodeAdded: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
+    nodeRemoved: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
 }
 
-const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, exclude: DhtAddress[]): DeliveryRpcRemote[] => {
+const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, ContentDeliveryRpcRemote>, exclude: DhtAddress[]): ContentDeliveryRpcRemote[] => {
     return Array.from(nodes.entries())
         .filter(([id, _node]) => !exclude.includes(id))
         .map(([_id, node]) => node)
@@ -16,7 +17,7 @@ const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, excl
 // The items in the list are in the insertion order
 
 export class NodeList extends EventEmitter<Events> {
-    private readonly nodes: Map<DhtAddress, DeliveryRpcRemote>
+    private readonly nodes: Map<DhtAddress, ContentDeliveryRpcRemote>
     private readonly limit: number
     private ownId: DhtAddress
 
@@ -27,7 +28,7 @@ export class NodeList extends EventEmitter<Events> {
         this.ownId = ownId
     }
 
-    add(remote: DeliveryRpcRemote): void {
+    add(remote: ContentDeliveryRpcRemote): void {
         const nodeId = getNodeIdFromPeerDescriptor(remote.getPeerDescriptor())
         if ((this.ownId !== nodeId) && (this.nodes.size < this.limit)) {
             const isExistingNode = this.nodes.has(nodeId)
@@ -40,14 +41,19 @@ export class NodeList extends EventEmitter<Events> {
     }
 
     remove(nodeId: DhtAddress): void {
-        this.nodes.delete(nodeId)
+        if (this.nodes.has(nodeId)) {
+            const remote = this.nodes.get(nodeId)!
+            this.nodes.delete(nodeId)
+            this.emit('nodeRemoved', nodeId, remote)
+        }   
     }
 
     has(nodeId: DhtAddress): boolean {
         return this.nodes.has(nodeId)
     }
 
-    replaceAll(neighbors: DeliveryRpcRemote[]): void {
+    // Replace nodes does not emit nodeRemoved events, use with caution
+    replaceAll(neighbors: ContentDeliveryRpcRemote[]): void {
         this.nodes.clear()
         const limited = neighbors.splice(0, this.limit)
         limited.forEach((remote) => {
@@ -59,7 +65,7 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys())
     }
 
-    get(id: DhtAddress): DeliveryRpcRemote | undefined {
+    get(id: DhtAddress): ContentDeliveryRpcRemote | undefined {
         return this.nodes.get(id)
     }
 
@@ -67,16 +73,16 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length
     }
 
-    getRandom(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getRandom(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         return sample(getValuesOfIncludedKeys(this.nodes, exclude))
     }
 
-    getFirst(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getFirst(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[0]
     }
 
-    getFirstAndLast(exclude: DhtAddress[]): DeliveryRpcRemote[] {
+    getFirstAndLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote[] {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         if (included.length === 0) {
             return []
@@ -84,17 +90,17 @@ export class NodeList extends EventEmitter<Events> {
         return included.length > 1 ? [this.getFirst(exclude)!, this.getLast(exclude)!] : [this.getFirst(exclude)!]
     }
 
-    getLast(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[included.length - 1]
     }
 
-    getAll(): DeliveryRpcRemote[] {
+    getAll(): ContentDeliveryRpcRemote[] {
         return Array.from(this.nodes.values())
     }
 
     stop(): void {
-        this.nodes.clear()
+        this.nodes.forEach((node) => this.remove(getNodeIdFromPeerDescriptor(node.getPeerDescriptor())))
         this.removeAllListeners()
     }
 }

package/src/logic/RandomGraphNode.ts

@@ -5,7 +5,8 @@ import {
     ITransport,
     ConnectionLocker,
     DhtAddress,
-    getNodeIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor,
+    RingContacts
 } from '@streamr/dht'
 import {
     StreamMessage,
@@ -17,16 +18,15 @@ import {
     CloseTemporaryConnection,
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NodeList } from './NodeList'
-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 { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
 import { DuplicateMessageDetector } from './DuplicateMessageDetector'
 import { Logger, addManagedEventListener } from '@streamr/utils'
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { Propagation } from './propagation/Propagation'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { DeliveryRpcLocal } from './DeliveryRpcLocal'
+import { ContentDeliveryRpcLocal } from './ContentDeliveryRpcLocal'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
@@ -50,6 +50,8 @@ export interface StrictRandomGraphNodeConfig {
     nodeViewSize: number
     nearbyNodeView: NodeList
     randomNodeView: NodeList
+    leftNodeView: NodeList
+    rightNodeView: NodeList
     neighbors: NodeList
     handshaker: Handshaker
     neighborFinder: NeighborFinder
@@ -72,14 +74,14 @@ export class RandomGraphNode extends EventEmitter<Events> {
     private started = false
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector>
     private config: StrictRandomGraphNodeConfig
-    private readonly deliveryRpcLocal: IDeliveryRpc
+    private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
     private abortController: AbortController = new AbortController()
 
     constructor(config: StrictRandomGraphNodeConfig) {
         super()
         this.config = config
         this.duplicateDetectors = new Map()
-        this.deliveryRpcLocal = new DeliveryRpcLocal({
+        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             rpcCommunicator: this.config.rpcCommunicator,
@@ -92,13 +94,15 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 const contact = this.config.nearbyNodeView.get(sourceId)
                 || this.config.randomNodeView.get(sourceId)
                 || this.config.neighbors.get(sourceId)
-                || this.config.proxyConnectionRpcLocal?.getConnection(sourceId )?.remote
+                || this.config.proxyConnectionRpcLocal?.getConnection(sourceId)?.remote
                 // TODO: check integrity of notifier?
                 if (contact) {
                     this.config.layer1Node.removeContact(sourceId)
                     this.config.neighbors.remove(sourceId)
                     this.config.nearbyNodeView.remove(sourceId)
-                    this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.streamPartId)
+                    this.config.randomNodeView.remove(sourceId)
+                    this.config.leftNodeView.remove(sourceId)
+                    this.config.rightNodeView.remove(sourceId)
                     this.config.neighborFinder.start([sourceId])
                     this.config.proxyConnectionRpcLocal?.removeConnection(sourceId)
                 }
@@ -130,13 +134,29 @@ export class RandomGraphNode extends EventEmitter<Events> {
             'randomContactAdded',
             (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.onRandomContactAdded(randomPeers),
             this.abortController.signal
-        )   
+        )
         addManagedEventListener<any, any>(
             this.config.layer1Node as any,
             'randomContactRemoved',
             (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.onRandomContactRemoved(randomPeers),
             this.abortController.signal
-        )   
+        )
+        addManagedEventListener<any, any>(
+            this.config.layer1Node as any,
+            'ringContactAdded',
+            (_: PeerDescriptor, peers: RingContacts) => {
+                this.onRingContactEvent(peers)
+            },
+            this.abortController.signal
+        )
+        addManagedEventListener<any, any>(
+            this.config.layer1Node as any,
+            'ringContactRemoved',
+            (_: PeerDescriptor, peers: RingContacts) => {
+                this.onRingContactEvent(peers)
+            },
+            this.abortController.signal
+        )
         addManagedEventListener<any, any>(
             this.config.transport as any,
             'disconnected',
@@ -146,12 +166,27 @@ export class RandomGraphNode extends EventEmitter<Events> {
         addManagedEventListener(
             this.config.neighbors,
             'nodeAdded',
-            (id, _remote) => {
+            (id, remote) => {
                 this.config.propagation.onNeighborJoined(id)
+                this.config.connectionLocker.weakLockConnection(
+                    getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                    this.config.streamPartId
+                )
                 this.emit('neighborConnected', id)
             },
             this.abortController.signal
         )
+        addManagedEventListener(
+            this.config.neighbors,
+            'nodeRemoved',
+            (_id, remote) => {
+                this.config.connectionLocker.weakUnlockConnection(
+                    getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                    this.config.streamPartId
+                )
+            },
+            this.abortController.signal
+        )
         if (this.config.proxyConnectionRpcLocal !== undefined) {
             addManagedEventListener(
                 this.config.proxyConnectionRpcLocal,
@@ -170,15 +205,40 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private registerDefaultServerMethods(): void {
         this.config.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.deliveryRpcLocal.sendStreamMessage(msg, context))
+            (msg: StreamMessage, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context))
         this.config.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.deliveryRpcLocal.leaveStreamPartNotice(req, context))
+            (req: LeaveStreamPartNotice, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context))
         this.config.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection',
             (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.openConnection(req, context))
         this.config.rpcCommunicator.registerRpcNotification(CloseTemporaryConnection, 'closeConnection',
             (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.closeConnection(req, context))
     }
 
+    private onRingContactEvent(ringPeers: RingContacts): void {
+        logger.trace(`onRingContactAdded`)
+        if (this.isStopped()) {
+            return
+        }
+        this.config.leftNodeView.replaceAll(ringPeers.left.map((peer) => 
+            new ContentDeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peer,
+                this.config.rpcCommunicator,
+                ContentDeliveryRpcClient,
+                this.config.rpcRequestTimeout
+            )
+        ))
+        this.config.rightNodeView.replaceAll(ringPeers.right.map((peer) =>
+            new ContentDeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peer,
+                this.config.rpcCommunicator,
+                ContentDeliveryRpcClient,
+                this.config.rpcRequestTimeout
+            )
+        ))
+    }
+
     private onContactAdded(closestNodes: PeerDescriptor[]): void {
         logger.trace(`New nearby contact found`)
         if (this.isStopped()) {
@@ -200,11 +260,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private updateNearbyNodeView(nodes: PeerDescriptor[]) {
         this.config.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -213,13 +273,12 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 break
             }
             this.config.nearbyNodeView.add(
-                new DeliveryRpcRemote(
+                new ContentDeliveryRpcRemote(
                     this.config.localPeerDescriptor,
                     descriptor,
                     this.config.rpcCommunicator,
-                    DeliveryRpcClient,
+                    ContentDeliveryRpcClient,
                     this.config.rpcRequestTimeout
-
                 )
             )
         }
@@ -230,11 +289,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -249,11 +308,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -263,7 +322,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.config.neighbors.has(nodeId)) {
             this.config.neighbors.remove(nodeId)
-            this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.streamPartId)
             this.config.neighborFinder.start([nodeId])
             this.config.temporaryConnectionRpcLocal.removeNode(nodeId)
         }
@@ -293,9 +351,13 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
         this.abortController.abort()
         this.config.proxyConnectionRpcLocal?.stop()
-        this.config.neighbors.getAll().map(
-            (remote) => remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
-        )
+        this.config.neighbors.getAll().map((remote) => {
+            remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
+            this.config.connectionLocker.weakUnlockConnection(
+                getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                this.config.streamPartId
+            )
+        })
         this.config.rpcCommunicator.destroy()
         this.removeAllListeners()
         this.config.nearbyNodeView.stop()