@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/src/dht/PeerManager.ts

@@ -0,0 +1,339 @@
+import {
+    Logger
+} from '@streamr/utils'
+import KBucket from 'k-bucket'
+import {
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
+import { RandomContactList } from './contact/RandomContactList'
+import { SortedContactList } from './contact/SortedContactList'
+import { ConnectionManager } 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/ConnectionLockHandler'
+
+const logger = new Logger(module)
+
+interface PeerManagerConfig {
+    numberOfNodesPerKBucket: number
+    maxContactListSize: number
+    peerDiscoveryQueryBatchSize: number
+    localNodeId: DhtAddress
+    localPeerDescriptor: PeerDescriptor
+    connectionManager: ConnectionManager
+    isLayer0: boolean
+    lockId: LockID
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
+}
+
+export interface PeerManagerEvents {
+    contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    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
+}
+
+export const getDistance = (nodeIdOrDataKeyRaw1: DhtAddressRaw, nodeIdOrDataKeyRaw2: DhtAddressRaw): number => {
+    return KBucket.distance(nodeIdOrDataKeyRaw1, nodeIdOrDataKeyRaw2)
+}
+
+export class PeerManager extends EventEmitter<PeerManagerEvents> {
+
+    // Glossary: 
+    // * 'neighbors' are the nodes that are our neighbors according to 
+    //   the protocol of the layer we are in
+    // * 'connections' are the nodes that are connected to this node on Layer0
+    // * 'contacts' are all non-unresponsive nodes that we know about
+
+    // The kademlia k-bucket
+    private bucket: KBucket<DhtNodeRpcRemote>
+    // Nodes that are connected to this node on Layer0
+    public readonly connections: Map<DhtAddress, DhtNodeRpcRemote> = new Map()
+    // 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
+
+    constructor(config: PeerManagerConfig) {
+        super()
+        this.config = config
+        this.bucket = new KBucket<DhtNodeRpcRemote>({
+            localNodeId: getRawFromDhtAddress(this.config.localNodeId),
+            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))
+        this.bucket.on('updated', () => {
+            // TODO: Update contact info to the connection manager and reconnect
+        })
+        this.contacts = new SortedContactList({
+            referenceId: this.config.localNodeId,
+            maxSize: this.config.maxContactListSize,
+            allowToContainReferenceId: false,
+            emitEvents: true
+        })
+        this.contacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
+            if (this.stopped) {
+                return
+            }
+            this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+            this.randomPeers.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
+        })
+        this.contacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('contactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+        this.randomPeers = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
+        this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+        this.randomPeers.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('randomContactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+    }
+
+    private onKBucketPing(oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
+            referenceId: this.config.localNodeId,
+            maxSize: 100,  // TODO use config option or named constant?
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
+        sortingList.addContacts(oldContacts)
+        const sortedContacts = sortingList.getAllContacts()
+        const removableNodeId = sortedContacts[sortedContacts.length - 1].getNodeId()
+        this.config.connectionManager?.weakUnlockConnection(removableNodeId, this.config.lockId)
+        this.bucket.remove(getRawFromDhtAddress(removableNodeId))
+        this.bucket.add(newContact)
+    }
+
+    private onKBucketRemoved(nodeId: DhtAddress): void {
+        if (this.stopped) {
+            return
+        }
+        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+        logger.trace(`Removed contact ${nodeId}`)
+        if (this.bucket.count() === 0) {
+            this.emit('kBucketEmpty')
+        }
+    }
+
+    private onKBucketAdded(contact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        if (contact.getNodeId() !== this.config.localNodeId) {
+            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.lockId)
+            if (this.connections.has(contact.getNodeId())) {
+                logger.trace(`Added new contact ${nodeId}`)
+            } else {    // open connection by pinging
+                logger.trace('starting ping ' + nodeId)
+                contact.ping().then((result) => {
+                    if (result) {
+                        logger.trace(`Added new contact ${nodeId}`)
+                    } else {
+                        logger.trace('ping failed ' + nodeId)
+                        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+                        this.removeContact(nodeId)
+                        this.addClosestContactToBucket()
+                    }
+                    return
+                }).catch((_e) => {
+                    this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+                    this.removeContact(nodeId)
+                    this.addClosestContactToBucket()
+                })
+            }
+        }
+    }
+
+    private addClosestContactToBucket(): void {
+        if (this.stopped) {
+            return
+        }
+        const closest = this.getClosestActiveContactNotInBucket()
+        if (closest) {
+            this.addContact([closest.getPeerDescriptor()])
+        }
+    }
+
+    private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
+        for (const contactId of this.contacts.getContactIds()) {
+            if (!this.bucket.get(getRawFromDhtAddress(contactId)) && this.contacts.isActive(contactId)) {
+                return this.contacts.getContact(contactId)!.contact
+            }
+        }
+        return undefined
+    }
+
+    onContactConnected(peerDescriptor: PeerDescriptor): void {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        if (nodeId === this.config.localNodeId) {
+            logger.error('handleConnected() to self')
+        }
+        const rpcRemote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+        if (!this.connections.has(nodeId)) {
+            this.connections.set(nodeId, rpcRemote)
+            logger.trace('connectionschange add ' + this.connections.size)
+        } else {
+            logger.trace('new connection not set to connections, there is already a connection with the peer ID')
+        }
+        logger.trace('connected: ' + nodeId + ' ' + this.connections.size)
+    }
+
+    onContactDisconnected(nodeId: DhtAddress, gracefulLeave: boolean): void {
+        logger.trace('disconnected: ' + nodeId)
+        this.connections.delete(nodeId)
+        if (this.config.isLayer0) {
+            this.bucket.remove(getRawFromDhtAddress(nodeId))
+            if (gracefulLeave === true) {
+                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                this.removeContact(nodeId)
+            } else {
+                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+            }
+        }
+    }
+
+    removeContact(nodeId: DhtAddress): void {
+        if (this.stopped) {
+            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)
+    }
+
+    stop(): void {
+        this.stopped = true
+        this.bucket.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
+            rpcRemote.leaveNotice()
+            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()
+    }
+
+    getClosestNeighborsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId,
+            allowToContainReferenceId: true,
+            emitEvents: false,
+            excludedNodeIds
+        })
+        this.bucket.toArray().forEach((contact) => closest.addContact(contact))
+        return closest.getClosestContacts(limit)
+    }
+
+    // TODO reduce copy-paste?
+    getClosestContactsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId,
+            allowToContainReferenceId: true,
+            emitEvents: false,
+            excludedNodeIds
+        })
+        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)
+    }
+
+    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
+    }
+
+    getConnectionCount(): number {
+        return this.connections.size
+    }
+
+    getNeighborCount(): number {
+        return this.bucket.count()
+    }
+
+    getNeighbors(): PeerDescriptor[] {
+        return this.bucket.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    }
+
+    setContactActive(nodeId: DhtAddress): void {
+        this.contacts.setActive(nodeId)
+    }
+
+    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): 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)
+                const isInRingContacts = this.ringContacts.getContact(contact) !== 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)
+                }
+                if (!isInRingContacts) {
+                    this.ringContacts.addContact(remote)
+                }
+            }
+        })
+    }
+}

package/src/dht/contact/Contact.ts

@@ -1,8 +1,8 @@
-import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 export class Contact {
+
     private peerDescriptor: PeerDescriptor
 
     constructor(peerDescriptor: PeerDescriptor) {
@@ -13,7 +13,7 @@ export class Contact {
         return this.peerDescriptor
     }
 
-    public getPeerId(): PeerID {
-        return peerIdFromPeerDescriptor(this.peerDescriptor)
+    public getNodeId(): DhtAddress {
+        return getNodeIdFromPeerDescriptor(this.peerDescriptor)
     }
 }

package/src/dht/contact/ContactList.ts

@@ -1,5 +1,5 @@
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import EventEmitter from 'eventemitter3'
+import { DhtAddress } from '../../identifiers'
 
 export class ContactState<C> {
     public contacted = false
@@ -13,30 +13,31 @@ export class ContactState<C> {
 
 export interface Events<C> {
     contactRemoved: (removedContact: C, closestContacts: C[]) => void
-    newContact: (newContact: C, closestContacts: C[]) => void
+    contactAdded: (contactAdded: C, closestContacts: C[]) => void
 }
 
-export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
+export class ContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
-    protected contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
-    protected contactIds: PeerID[] = []
-    protected ownId: PeerID
+    protected contactsById: Map<DhtAddress, ContactState<C>> = new Map()
+    // TODO move this to SortedContactList
+    protected contactIds: DhtAddress[] = []
+    protected localNodeId: DhtAddress
     protected maxSize: number
     protected defaultContactQueryLimit
 
     constructor(
-        ownId: PeerID,
+        localNodeId: DhtAddress,
         maxSize: number,
         defaultContactQueryLimit = 20
     ) {
         super()
-        this.ownId = ownId
+        this.localNodeId = localNodeId
         this.maxSize = maxSize
         this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
-    public getContact(id: PeerID): ContactState<C> {
-        return this.contactsById.get(id.toKey())!
+    public getContact(id: DhtAddress): ContactState<C> | undefined {
+        return this.contactsById.get(id)
     }
 
     public getSize(): number {

package/src/dht/contact/RandomContactList.ts

@@ -1,35 +1,35 @@
-import { PeerID } from '../../helpers/PeerID'
+import { DhtAddress } from '../../identifiers'
 import { ContactList, ContactState } from './ContactList'
 
-export class RandomContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
+export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extends ContactList<C> {
 
     private randomness: number
 
     constructor(
-        ownId: PeerID,
+        localNodeId: DhtAddress,
         maxSize: number,
         randomness = 0.20,
         defaultContactQueryLimit?: number
     ) {
-        super(ownId, maxSize, defaultContactQueryLimit)
+        super(localNodeId, maxSize, defaultContactQueryLimit)
         this.randomness = randomness
     }
 
     addContact(contact: C): void {
-        if (this.ownId.equals(contact.getPeerId())) {
+        if (this.localNodeId === contact.getNodeId()) {
             return
         }
-        if (!this.contactsById.has(contact.getPeerId().toKey())) {
+        if (!this.contactsById.has(contact.getNodeId())) {
             const roll = Math.random()
             if (roll < this.randomness) {
                 if (this.getSize() === this.maxSize && this.getSize() > 0) {
                     const toRemove = this.contactIds[0]
                     this.removeContact(toRemove)
                 }
-                this.contactIds.push(contact.getPeerId())
-                this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
+                this.contactIds.push(contact.getNodeId())
+                this.contactsById.set(contact.getNodeId(), new ContactState(contact))
                 this.emit(
-                    'newContact',
+                    'contactAdded',
                     contact,
                     this.getContacts()
                 )
@@ -37,12 +37,12 @@ export class RandomContactList<C extends { getPeerId: () => PeerID }> extends Co
         }
     }
 
-    removeContact(id: PeerID): boolean {
-        if (this.contactsById.has(id.toKey())) {
-            const removed = this.contactsById.get(id.toKey())!.contact
-            const index = this.contactIds.findIndex((element) => element.equals(id))
+    removeContact(id: DhtAddress): boolean {
+        if (this.contactsById.has(id)) {
+            const removed = this.contactsById.get(id)!.contact
+            const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
             this.contactIds.splice(index, 1)
-            this.contactsById.delete(id.toKey())
+            this.contactsById.delete(id)
             this.emit('contactRemoved', removed, this.getContacts())
             return true
         }
@@ -52,7 +52,7 @@ export class RandomContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getContacts(limit = this.defaultContactQueryLimit): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId.toKey())
+            const contact = this.contactsById.get(contactId)
             if (contact) {
                 ret.push(contact.contact)
             }

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
+    }
+}