@streamr/dht 100.0.0-testnet-three.6 → 100.1.0

package/src/dht/PeerManager.ts

@@ -8,9 +8,12 @@ import {
 import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import { RandomContactList } from './contact/RandomContactList'
 import { SortedContactList } from './contact/SortedContactList'
-import { ConnectionManager } from '../connection/ConnectionManager'
+import { ConnectionLocker } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
 import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
+import { RingContactList, RingContacts } from './contact/RingContactList'
+import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
+import { LockID } from '../connection/ConnectionLockStates'
 
 const logger = new Logger(module)
 
@@ -19,8 +22,10 @@ interface PeerManagerConfig {
     maxContactListSize: number
     peerDiscoveryQueryBatchSize: number
     localNodeId: DhtAddress
-    connectionManager: ConnectionManager
+    localPeerDescriptor: PeerDescriptor
+    connectionLocker?: ConnectionLocker
     isLayer0: boolean
+    lockId: LockID
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
@@ -29,6 +34,8 @@ export interface PeerManagerEvents {
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
     kBucketEmpty: () => void
 }
 
@@ -51,6 +58,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // All nodes that we know about
     private contacts: SortedContactList<DhtNodeRpcRemote>
     private randomPeers: RandomContactList<DhtNodeRpcRemote>
+    private ringContacts: RingContactList<DhtNodeRpcRemote>
     private stopped: boolean = false
     private readonly config: PeerManagerConfig
 
@@ -62,6 +70,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
+        this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), true)
+        this.ringContacts.on('ringContactAdded', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
+            this.emit('ringContactAdded', peerDescriptor, closestPeers)
+        })
+        this.ringContacts.on('ringContactRemoved', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
+            this.emit('ringContactRemoved', peerDescriptor, closestPeers)
+        })
         this.bucket.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
         this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         this.bucket.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
@@ -69,7 +84,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             // TODO: Update contact info to the connection manager and reconnect
         })
         this.contacts = new SortedContactList({
-            referenceId: this.config.localNodeId, 
+            referenceId: this.config.localNodeId,
             maxSize: this.config.maxContactListSize,
             allowToContainReferenceId: false,
             emitEvents: true
@@ -98,7 +113,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
-            referenceId: this.config.localNodeId, 
+            referenceId: this.config.localNodeId,
             maxSize: 100,  // TODO use config option or named constant?
             allowToContainReferenceId: false,
             emitEvents: false
@@ -106,7 +121,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         const removableNodeId = sortedContacts[sortedContacts.length - 1].getNodeId()
-        this.config.connectionManager?.weakUnlockConnection(removableNodeId)
+        this.config.connectionLocker?.weakUnlockConnection(removableNodeId, this.config.lockId)
         this.bucket.remove(getRawFromDhtAddress(removableNodeId))
         this.bucket.add(newContact)
     }
@@ -115,7 +130,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        this.config.connectionManager?.weakUnlockConnection(nodeId)
+        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
         logger.trace(`Removed contact ${nodeId}`)
         if (this.bucket.count() === 0) {
             this.emit('kBucketEmpty')
@@ -130,7 +145,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             const peerDescriptor = contact.getPeerDescriptor()
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
-            this.config.connectionManager?.weakLockConnection(nodeId)
+            this.config.connectionLocker?.weakLockConnection(nodeId, this.config.lockId)
             if (this.connections.has(contact.getNodeId())) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
@@ -140,13 +155,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                         logger.trace(`Added new contact ${nodeId}`)
                     } else {
                         logger.trace('ping failed ' + nodeId)
-                        this.config.connectionManager?.weakUnlockConnection(nodeId)
+                        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                         this.removeContact(nodeId)
                         this.addClosestContactToBucket()
                     }
                     return
                 }).catch((_e) => {
-                    this.config.connectionManager?.weakUnlockConnection(nodeId)
+                    this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                     this.removeContact(nodeId)
                     this.addClosestContactToBucket()
                 })
@@ -160,7 +175,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         const closest = this.getClosestActiveContactNotInBucket()
         if (closest) {
-            this.addContact([closest.getPeerDescriptor()])
+            this.addContact(closest.getPeerDescriptor())
         }
     }
 
@@ -207,6 +222,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         logger.trace(`Removing contact ${nodeId}`)
+        this.ringContacts.removeContact(this.contacts.getContact(nodeId)?.contact)
         this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
         this.randomPeers.removeContact(nodeId)
@@ -219,6 +235,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             this.bucket.remove(rpcRemote.id)
         })
         this.bucket.removeAllListeners()
+        this.ringContacts.getAllContacts().forEach((rpcRemote) => {
+            rpcRemote.leaveNotice()
+            this.ringContacts.removeContact(rpcRemote)
+        })
         this.contacts.stop()
         this.randomPeers.stop()
         this.connections.clear()
@@ -229,10 +249,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             referenceId,
             allowToContainReferenceId: true,
             emitEvents: false,
-            excludedNodeIds
-        }) 
+            excludedNodeIds,
+            maxSize: limit
+        })
         this.bucket.toArray().forEach((contact) => closest.addContact(contact))
-        return closest.getClosestContacts(limit)
+        return closest.getAllContacts()
     }
 
     // TODO reduce copy-paste?
@@ -241,21 +262,26 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             referenceId,
             allowToContainReferenceId: true,
             emitEvents: false,
-            excludedNodeIds
+            excludedNodeIds,
+            maxSize: limit
         })
         this.contacts.getAllContacts().map((contact) => closest.addContact(contact))
-        // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
-        return closest.getClosestContacts(limit)
+        return closest.getAllContacts()
+    }
+
+    getClosestRingContactsTo(
+        ringIdRaw: RingIdRaw,
+        limit?: number,
+        excludedIds?: Set<DhtAddress>
+    ): { left: DhtNodeRpcRemote[], right: DhtNodeRpcRemote[] } {
+        const closest = new RingContactList<DhtNodeRpcRemote>(ringIdRaw, false, excludedIds)
+        this.contacts.getAllContacts().map((contact) => closest.addContact(contact))
+        this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
+        return closest.getClosestContacts(limit ?? 8)
     }
 
     getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
-        return this.contacts.getAllContacts().filter((contact) => {
-            if (!excludedNodeIds) {
-                return true
-            } else {
-                return !excludedNodeIds.has(contact.getNodeId())
-            } 
-        }).length
+        return this.contacts.getSize(excludedNodeIds)
     }
 
     getConnectionCount(): number {
@@ -274,30 +300,30 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.contacts.setActive(nodeId)
     }
 
-    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
+    addContact(peerDescriptor: PeerDescriptor): void {
         if (this.stopped) {
             return
         }
-        peerDescriptors.forEach((contact) => {
-            const nodeId = getNodeIdFromPeerDescriptor(contact)
-            if (nodeId !== this.config.localNodeId) {
-                logger.trace(`Adding new contact ${nodeId}`)
-                const remote = this.config.createDhtNodeRpcRemote(contact)
-                const isInBucket = (this.bucket.get(contact.nodeId) !== null)
-                const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
-                if (isInBucket || isInContacts) {
-                    this.randomPeers.addContact(remote)
-                }
-                if (!isInBucket) {
-                    this.bucket.add(remote)
-                } 
-                if (!isInContacts) {
-                    this.contacts.addContact(remote)
-                } 
-                if (setActive) {
-                    this.contacts.setActive(nodeId)
-                }
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        if (nodeId !== this.config.localNodeId) {
+            logger.trace(`Adding new contact ${nodeId}`)
+            const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+            const isInBucket = (this.bucket.get(peerDescriptor.nodeId) !== null)
+            const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
+            const isInRingContacts = this.ringContacts.getContact(peerDescriptor) !== undefined
+
+            if (isInBucket || isInContacts) {
+                this.randomPeers.addContact(remote)
             }
-        })
+            if (!isInBucket) {
+                this.bucket.add(remote)
+            }
+            if (!isInContacts) {
+                this.contacts.addContact(remote)
+            }
+            if (!isInRingContacts) {
+                this.ringContacts.addContact(remote)
+            }
+        }
     }
 }

package/src/dht/contact/RingContactList.ts

@@ -0,0 +1,151 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { OrderedMap } from '@js-sdsl/ordered-map'
+import { RingDistance, RingId, RingIdRaw, getLeftDistance, getRightDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from './ringIdentifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import EventEmitter from 'eventemitter3'
+
+export interface RingContacts { 
+    left: PeerDescriptor[]
+    right: PeerDescriptor[]
+}
+export interface RingContactListEvents {  
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+}
+export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<RingContactListEvents> {
+
+    private readonly numNeighborsPerSide = 5
+    private readonly referenceId: RingId
+    private readonly excludedIds: Set<DhtAddress>
+    private readonly leftNeighbors: OrderedMap<RingDistance, C>
+    private readonly rightNeighbors: OrderedMap<RingDistance, C>
+    private readonly emitEvents: boolean
+
+    constructor(rawReferenceId: RingIdRaw, emitEvents: boolean, excludedIds?: Set<DhtAddress>) {
+        super()
+        this.referenceId = getRingIdFromRaw(rawReferenceId)
+        this.emitEvents = emitEvents
+        this.excludedIds = excludedIds ?? new Set()
+        this.leftNeighbors = new OrderedMap<RingDistance, C>()
+        this.rightNeighbors = new OrderedMap<RingDistance, C>()
+    }
+
+    addContact(contact: C): void {
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        if (id === this.referenceId || this.excludedIds.has(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))) {
+            return
+        }
+        let elementAdded = false
+        let elementRemoved = false
+
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const lastLeftNeighbor = this.leftNeighbors.back()
+        if (lastLeftNeighbor === undefined || leftDistance < lastLeftNeighbor[0]) {
+            this.leftNeighbors.setElement(leftDistance, contact)
+            elementAdded = true
+            if (this.leftNeighbors.size() > this.numNeighborsPerSide) {
+                this.leftNeighbors.eraseElementByIterator(this.leftNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        const rightDistance = getRightDistance(this.referenceId, id)
+        const lastRightNeighbor = this.rightNeighbors.back()
+        if (lastRightNeighbor === undefined || rightDistance < lastRightNeighbor[0]) {
+            this.rightNeighbors.setElement(rightDistance, contact)
+            elementAdded = true
+            if (this.rightNeighbors.size() > this.numNeighborsPerSide) {
+                this.rightNeighbors.eraseElementByIterator(this.rightNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        if (this.emitEvents && (elementAdded || elementRemoved)) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { 
+                left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor())
+            }
+            if (elementAdded) {
+                this.emit('ringContactAdded', contact.getPeerDescriptor(), closestDescriptors)
+            }
+            if (elementRemoved) {
+                this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+            }
+        }
+    }
+
+    removeContact(contact?: C): void {
+        if (contact === undefined) {
+            return
+        }
+
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+
+        let elementRemoved = false
+        if (this.leftNeighbors.eraseElementByKey(leftDistance)) {
+            elementRemoved = true
+        }
+        if (this.rightNeighbors.eraseElementByKey(rightDistance)) {
+            elementRemoved = true
+        }
+
+        if (this.emitEvents && elementRemoved) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor()) }
+            this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+        }
+    }
+
+    getContact(peerDescriptor: PeerDescriptor): C | undefined {
+        const id = getRingIdFromPeerDescriptor(peerDescriptor)
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+        if (this.leftNeighbors.getElementByKey(leftDistance)) {
+            return this.leftNeighbors.getElementByKey(leftDistance)
+        }
+        if (this.rightNeighbors.getElementByKey(rightDistance)) {
+            return this.rightNeighbors.getElementByKey(rightDistance)
+        }
+        return undefined
+    }
+
+    getClosestContacts(limitPerSide?: number): { left: C[], right: C[] } {
+        const leftContacts: C[] = []
+        const rightContacts: C[] = []
+
+        let leftCount = 0
+        for (const item of this.leftNeighbors) {
+            if (limitPerSide != undefined && leftCount >= limitPerSide) {
+                break
+            }
+            leftContacts.push(item[1])
+            leftCount++
+        } 
+
+        let rightCount = 0
+        for (const item of this.rightNeighbors) {
+            if (limitPerSide != undefined && rightCount >= limitPerSide) {
+                break
+            }
+            rightContacts.push(item[1])
+            rightCount++
+        }
+
+        return { left: leftContacts, right: rightContacts }
+    }
+
+    getAllContacts(): C[] {
+        const ret: C[] = []
+        for (const item of this.leftNeighbors) {
+            ret.push(item[1])
+        }
+        for (const item of this.rightNeighbors) {
+            ret.push(item[1])
+        }
+        return ret
+    }
+}

package/src/dht/contact/SortedContactList.ts

@@ -92,6 +92,10 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return this.contactsById.get(id)
     }
 
+    has(id: DhtAddress): boolean {
+        return this.contactsById.has(id)
+    }
+
     public setContacted(contactId: DhtAddress): void {
         if (this.contactsById.has(contactId)) {
             this.contactsById.get(contactId)!.contacted = true
@@ -105,25 +109,17 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     }
 
     public getClosestContacts(limit?: number): C[] {
-        const ret: C[] = []
-        this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId)
-            if (contact) {
-                ret.push(contact.contact)
-            }
-        })
-        if (limit === undefined) {
-            return ret
-        } else {
-            return ret.slice(0, limit)
-        }
+        const ret = this.getAllContacts()
+        return (limit === undefined) 
+            ? ret 
+            : ret.slice(0, limit)
     }
 
     public getUncontactedContacts(num: number): C[] {
         const ret: C[] = []
         for (const contactId of this.contactIds) {
-            const contact = this.contactsById.get(contactId)
-            if (contact && !contact.contacted) {
+            const contact = this.contactsById.get(contactId)!
+            if (!contact.contacted) {
                 ret.push(contact.contact)
                 if (ret.length >= num) {
                     return ret
@@ -136,8 +132,8 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     public getActiveContacts(limit?: number): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId)
-            if (contact && contact.active) {
+            const contact = this.contactsById.get(contactId)!
+            if (contact.active) {
                 ret.push(contact.contact)
             }
         })
@@ -187,8 +183,16 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return this.contactIds.map((nodeId) => this.contactsById.get(nodeId)!.contact)
     }
 
-    public getSize(): number {
-        return this.contactIds.length
+    public getSize(excludedNodeIds?: Set<DhtAddress>): number {
+        let excludedCount = 0
+        if (excludedNodeIds !== undefined) {
+            for (const nodeId of excludedNodeIds) {
+                if (this.has(nodeId)) {
+                    excludedCount++
+                }
+            }
+        }
+        return this.contactIds.length - excludedCount
     }
 
     public clear(): void {

package/src/dht/contact/ringIdentifiers.ts

@@ -0,0 +1,62 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+
+// Notice: you cannot convert RingId to RingIdRaw, because 
+// RingId is only an approximation of the actual value.
+// That is why RingIdRaw is widely used in the codebase.
+
+export type RingIdRaw = Uint8Array & { __ringIdRaw: never }
+export type RingId = number & { __ringId: never }
+export type RingDistance = number & { __ringDistance: never }
+
+export const RING_SIZE = 2 ** 120 - 1   // 2^120 - 1
+
+const binaryToBigInt = (binary: Uint8Array): bigint => {
+    return binary.reduce((acc, val) => (acc << BigInt(8)) | BigInt(val), BigInt(0))
+}
+
+export const getRingIdFromRaw = (raw: RingIdRaw): RingId => Number(binaryToBigInt(raw)) as RingId
+
+export const getRingIdRawFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingIdRaw => {
+    const regionAsBuffer = Buffer.alloc(4)
+    regionAsBuffer.writeUInt32BE(peerDescriptor.region ?? 0, 0)
+    const ipAsbuffer = Buffer.alloc(4)
+    ipAsbuffer.writeUInt32BE(peerDescriptor.ipAddress ?? 0, 0)
+    
+    const uniquePartAsBuffer = Buffer.from(peerDescriptor.nodeId.subarray(peerDescriptor.nodeId.length - 7, peerDescriptor.nodeId.length))
+
+    const arr = [
+        regionAsBuffer,
+        ipAsbuffer,
+        uniquePartAsBuffer
+    ]
+
+    const buffer = Buffer.concat(arr)
+    return new Uint8Array(buffer) as RingIdRaw
+}
+
+export const getRingIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingId => {
+    const raw = getRingIdRawFromPeerDescriptor(peerDescriptor)
+    return Number(binaryToBigInt(raw)) as RingId    
+}
+
+export const getLeftDistance = (referenceId: RingId, id: RingId): RingDistance =>{
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the difference
+        return diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    }
+}
+
+export const getRightDistance = (referenceId: RingId, id: RingId): RingDistance => {
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the difference
+        return diff as RingDistance
+    }
+}

package/src/dht/discovery/DiscoverySession.ts

@@ -38,7 +38,9 @@ export class DiscoverySession {
         if (this.stopped) {
             return
         }
-        this.config.peerManager.addContact(contacts)
+        for (const contact of contacts) {
+            this.config.peerManager.addContact(contact)
+        }
     }
 
     private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {

package/src/dht/discovery/PeerDiscovery.ts

@@ -2,10 +2,12 @@ import { DiscoverySession } from './DiscoverySession'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
-import { ConnectionManager } from '../../connection/ConnectionManager'
+import { ConnectionLocker } from '../../connection/ConnectionManager'
 import { PeerManager } from '../PeerManager'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { ServiceID } from '../../types/ServiceID'
+import { RingDiscoverySession } from './RingDiscoverySession'
+import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdentifiers'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -14,7 +16,7 @@ interface PeerDiscoveryConfig {
     serviceId: ServiceID
     parallelism: number
     joinTimeout: number
-    connectionManager?: ConnectionManager
+    connectionLocker?: ConnectionLocker
     peerManager: PeerManager
 }
 
@@ -29,6 +31,8 @@ const logger = new Logger(module)
 export class PeerDiscovery {
 
     private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
+    private ongoingRingDiscoverySessions: Map<string, RingDiscoverySession> = new Map()
+    
     private rejoinOngoing = false
     private joinCalled = false
     private readonly abortController: AbortController
@@ -74,18 +78,24 @@ export class PeerDiscovery {
         if (areEqualPeerDescriptors(entryPointDescriptor, this.config.localPeerDescriptor)) {
             return
         }
-        this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
-        this.config.peerManager.addContact([entryPointDescriptor])
+        this.config.connectionLocker?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+        this.config.peerManager.addContact(entryPointDescriptor)
         const targetId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const sessions = [this.createSession(targetId, contactedPeers)]
         if (additionalDistantJoin.enabled) {
             sessions.push(this.createSession(createDistantDhtAddress(targetId), additionalDistantJoin.contactedPeers))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
-        this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+        this.config.connectionLocker?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
 
     }
 
+    async joinRing(): Promise<void> {
+        const contactedPeers = new Set<DhtAddress>()
+        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), contactedPeers)]
+        await this.runRingSessions(sessions)
+    }
+
     private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
         const sessionOptions = {
             targetId,
@@ -97,6 +107,17 @@ export class PeerDiscovery {
         return new DiscoverySession(sessionOptions)
     }
 
+    private createRingSession(targetId: RingIdRaw, contactedPeers: Set<DhtAddress>): RingDiscoverySession {
+        const sessionOptions = {
+            targetId,
+            parallelism: this.config.parallelism,
+            noProgressLimit: this.config.joinNoProgressLimit,
+            peerManager: this.config.peerManager,
+            contactedPeers
+        }
+        return new RingDiscoverySession(sessionOptions)
+    }
+
     private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
         try {
             for (const session of sessions) {
@@ -121,6 +142,19 @@ export class PeerDiscovery {
         }
     }
 
+    private async runRingSessions(sessions: RingDiscoverySession[]): Promise<void> {
+        try {
+            for (const session of sessions) {
+                this.ongoingRingDiscoverySessions.set(session.id, session)
+                await session.findClosestNodes(this.config.joinTimeout)
+            }
+        } catch (_e) {
+            logger.debug(`Ring join on ${this.config.serviceId} timed out`)
+        } finally {
+            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
+        }
+    }
+
     public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
         if (this.isStopped() || this.rejoinOngoing) {
             return
@@ -162,7 +196,9 @@ export class PeerDiscovery {
         await Promise.allSettled(
             nodes.map(async (peer: DhtNodeRpcRemote) => {
                 const contacts = await peer.getClosestPeers(localNodeId)
-                this.config.peerManager.addContact(contacts)
+                for (const contact of contacts) {
+                    this.config.peerManager.addContact(contact)
+                }
             })
         )
     }
@@ -184,5 +220,8 @@ export class PeerDiscovery {
         this.ongoingDiscoverySessions.forEach((session) => {
             session.stop()
         })
+        this.ongoingRingDiscoverySessions.forEach((session) => {
+            session.stop()
+        })
     }
 }