@streamr/dht 100.0.0-pretestnet.0 → 100.0.0-pretestnet.3

package/src/connection/ConnectionLockHandler.ts

@@ -3,12 +3,14 @@
 
 import { PeerIDKey } from '../helpers/PeerID'
 
-type ServiceName = string
+export type LockID = string
 
 export class ConnectionLockHandler {
 
-    private localLocks: Map<PeerIDKey, Set<ServiceName>> = new Map()
-    private remoteLocks: Map<PeerIDKey, Set<ServiceName>> = new Map()
+    private localLocks: Map<PeerIDKey, Set<LockID>> = new Map()
+    private remoteLocks: Map<PeerIDKey, Set<LockID>> = new Map()
+    // TODO: remove weakLocks use localLocks instead. When opening weakLocks from the ConnectioManager,
+    // simply do not send lock requests.
     private weakLocks: Set<PeerIDKey> = new Set()
 
     public getNumberOfLocalLockedConnections(): number {
@@ -23,19 +25,19 @@ export class ConnectionLockHandler {
         return this.weakLocks.size
     }
 
-    public isLocalLocked(id: PeerIDKey, serviceName?: ServiceName): boolean {
-        if (!serviceName) {
+    public isLocalLocked(id: PeerIDKey, lockId?: LockID): boolean {
+        if (!lockId) {
             return this.localLocks.has(id)
         } else {
-            return this.localLocks.has(id) && this.localLocks.get(id)!.has(serviceName)
+            return this.localLocks.has(id) && this.localLocks.get(id)!.has(lockId)
         }
     }
 
-    public isRemoteLocked(id: PeerIDKey, serviceName?: ServiceName): boolean {
-        if (!serviceName) {
+    public isRemoteLocked(id: PeerIDKey, lockId?: LockID): boolean {
+        if (!lockId) {
             return this.remoteLocks.has(id)
         } else {
-            if (this.remoteLocks.has(id) && this.remoteLocks.get(id)!.has(serviceName)) {
+            if (this.remoteLocks.has(id) && this.remoteLocks.get(id)!.has(lockId)) {
                 return true
             } else {
                 return false
@@ -51,36 +53,36 @@ export class ConnectionLockHandler {
         return (this.isLocalLocked(id) || this.isRemoteLocked(id) || this.isWeakLocked(id))
     }
 
-    public addLocalLocked(id: PeerIDKey, serviceName: ServiceName): void {
+    public addLocalLocked(id: PeerIDKey, lockId: LockID): void {
         if (!this.localLocks.has(id)) {
             this.localLocks.set(id, new Set())
         }
-        this.localLocks.get(id)!.add(serviceName)
+        this.localLocks.get(id)!.add(lockId)
     }
 
-    public addRemoteLocked(id: PeerIDKey, serviceName: ServiceName): void {
+    public addRemoteLocked(id: PeerIDKey, lockId: LockID): void {
         if (!this.remoteLocks.has(id)) {
             this.remoteLocks.set(id, new Set())
         }
-        this.remoteLocks.get(id)!.add(serviceName)
+        this.remoteLocks.get(id)!.add(lockId)
     }
 
     public addWeakLocked(id: PeerIDKey): void {
         this.weakLocks.add(id)
     }
 
-    public removeLocalLocked(id: PeerIDKey, serviceName: ServiceName): void {
+    public removeLocalLocked(id: PeerIDKey, lockId: LockID): void {
         if (this.localLocks.has(id)) {
-            this.localLocks.get(id)?.delete(serviceName)
+            this.localLocks.get(id)?.delete(lockId)
             if (this.localLocks.get(id)?.size === 0) {
                 this.localLocks.delete(id)
             }
         }
     }
 
-    public removeRemoteLocked(id: PeerIDKey, serviceName: ServiceName): void {
+    public removeRemoteLocked(id: PeerIDKey, lockId: LockID): void {
         if (this.remoteLocks.has(id)) {
-            this.remoteLocks.get(id)?.delete(serviceName)
+            this.remoteLocks.get(id)?.delete(lockId)
             if (this.remoteLocks.get(id)?.size === 0) {
                 this.remoteLocks.delete(id)
             }

package/src/connection/ConnectionLockRpcLocal.ts

@@ -0,0 +1,74 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { Logger } from '@streamr/utils'
+import {
+    areEqualPeerDescriptors,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../helpers/peerIdFromPeerDescriptor'
+import { Empty } from '../proto/google/protobuf/empty'
+import {
+    DisconnectMode,
+    DisconnectNotice,
+    LockRequest,
+    LockResponse,
+    PeerDescriptor,
+    UnlockRequest
+} from '../proto/packages/dht/protos/DhtRpc'
+import { IConnectionLockRpc } from '../proto/packages/dht/protos/DhtRpc.server'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
+import { PeerIDKey } from '../helpers/PeerID'
+import { keyOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { LockID } from './ConnectionLockHandler'
+
+interface ConnectionLockRpcLocalConfig {
+    addRemoteLocked: (id: PeerIDKey, lockId: LockID) => void
+    removeRemoteLocked: (id: PeerIDKey, lockId: LockID) => void
+    closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => void
+    getLocalPeerDescriptor: () => PeerDescriptor
+}
+
+const logger = new Logger(module)
+
+export class ConnectionLockRpcLocal implements IConnectionLockRpc {
+
+    private readonly config: ConnectionLockRpcLocalConfig
+
+    constructor(config: ConnectionLockRpcLocalConfig) {
+        this.config = config
+    }
+
+    async lockRequest(lockRequest: LockRequest, context: ServerCallContext): Promise<LockResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const remotePeerId = peerIdFromPeerDescriptor(senderPeerDescriptor)
+        if (areEqualPeerDescriptors(senderPeerDescriptor, this.config.getLocalPeerDescriptor())) {
+            const response: LockResponse = {
+                accepted: false
+            }
+            return response
+        }
+        this.config.addRemoteLocked(remotePeerId.toKey(), lockRequest.lockId)
+        const response: LockResponse = {
+            accepted: true
+        }
+        return response
+    }
+
+    async unlockRequest(unlockRequest: UnlockRequest, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const peerIdKey = keyFromPeerDescriptor(senderPeerDescriptor)
+        this.config.removeRemoteLocked(peerIdKey, unlockRequest.lockId)
+        return {}
+    }
+
+    async gracefulDisconnect(disconnectNotice: DisconnectNotice, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        logger.trace(keyOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice')
+
+        if (disconnectNotice.disconnectMode === DisconnectMode.LEAVING) {
+            this.config.closeConnection(senderPeerDescriptor, true, 'graceful leave notified')
+        } else {
+            this.config.closeConnection(senderPeerDescriptor, false, 'graceful disconnect notified')
+        }
+        return {}
+    }
+}

package/src/connection/ConnectionLockRpcRemote.ts

@@ -6,23 +6,24 @@ import { LockRequest, UnlockRequest, PeerDescriptor, DisconnectNotice, Disconnec
 import * as Err from '../helpers/errors'
 import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Remote } from '../dht/contact/Remote'
+import { LockID } from './ConnectionLockHandler'
 
 const logger = new Logger(module)
 
 export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         targetPeerDescriptor: PeerDescriptor,
         client: ProtoRpcClient<IConnectionLockRpcClient>
     ) {
-        super(ownPeerDescriptor, targetPeerDescriptor, 'DUMMY', client)
+        super(localPeerDescriptor, targetPeerDescriptor, 'DUMMY', client)
     }
 
-    public async lockRequest(serviceId: string): Promise<boolean> {
+    public async lockRequest(lockId: LockID): Promise<boolean> {
         logger.trace(`Requesting locked connection to ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: LockRequest = {
-            serviceId
+            lockId
         }
         const options = this.formDhtRpcOptions()
         try {
@@ -34,10 +35,10 @@ export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
         }
     }
 
-    public unlockRequest(serviceId: string): void {
+    public unlockRequest(lockId: LockID): void {
         logger.trace(`Requesting connection to be unlocked from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: UnlockRequest = {
-            serviceId
+            lockId
         }
         const options = this.formDhtRpcOptions({
             notification: true

package/src/connection/ConnectionManager.ts

@@ -12,7 +12,6 @@ import {
     peerIdFromPeerDescriptor
 } from '../helpers/peerIdFromPeerDescriptor'
 import { protoToString } from '../helpers/protoToString'
-import { Empty } from '../proto/google/protobuf/empty'
 import {
     DisconnectMode,
     DisconnectNotice,
@@ -25,15 +24,15 @@ import {
     UnlockRequest
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
+import { ITransport, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
-import { ConnectionLockHandler } from './ConnectionLockHandler'
+import { ConnectionLockHandler, LockID } from './ConnectionLockHandler'
 import { ConnectorFacade } from './ConnectorFacade'
 import { ManagedConnection, Events as ManagedConnectionEvents } from './ManagedConnection'
 import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
-import { WEB_RTC_CLEANUP } from './WebRTC/NodeWebRtcConnection'
+import { WEBRTC_CLEANUP } from './webrtc/NodeWebrtcConnection'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
+import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
 
 export interface ConnectionManagerConfig {
     maxConnections?: number
@@ -96,7 +95,7 @@ const INTERNAL_SERVICE_ID = 'system/connection-manager'
 // should only be used only for log output. TODO remove this method if we no longer use
 // peerDescriptors which can be undefined, e.g.
 // - if we refactor ConnectionManager so that it doesn't process handshake requests too early 
-//   and therefore this.ownPeerDescriptor can't be undefine (NET-1129)
+//   and therefore this.localPeerDescriptor can't be undefine (NET-1129)
 // - if the peerDescriptor of ManagedConnection is always available
 // - if we create stricter types for incoming messages (message.sourceDescriptor or
 //   disconnectNotice.peerDescriptor)
@@ -126,8 +125,9 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         super()
         this.config = config
         this.onData = this.onData.bind(this)
+        this.send = this.send.bind(this)
         this.onIncomingConnection = this.onIncomingConnection.bind(this)
-        this.metricsContext = this.config.metricsContext || new MetricsContext()
+        this.metricsContext = this.config.metricsContext ?? new MetricsContext()
         this.metrics = {
             sendMessagesPerSecond: new RateMetric(),
             sendBytesPerSecond: new RateMetric(),
@@ -142,19 +142,27 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         this.rpcCommunicator = new RoutingRpcCommunicator(INTERNAL_SERVICE_ID, this.send, {
             rpcRequestTimeout: 10000
         })
+        const lockRpcLocal = new ConnectionLockRpcLocal({
+            addRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.addRemoteLocked(id, serviceId),
+            removeRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.removeRemoteLocked(id, serviceId),
+            closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => {
+                this.closeConnection(peerDescriptor, gracefulLeave, reason)
+            },
+            getLocalPeerDescriptor: () => this.getLocalPeerDescriptor()
+        })
         this.rpcCommunicator.registerRpcMethod(LockRequest, LockResponse, 'lockRequest',
-            (req: LockRequest, context: ServerCallContext) => this.lockRequest(req, context))
+            (req: LockRequest, context: ServerCallContext) => lockRpcLocal.lockRequest(req, context))
         this.rpcCommunicator.registerRpcNotification(UnlockRequest, 'unlockRequest',
-            (req: UnlockRequest, context: ServerCallContext) => this.unlockRequest(req, context))
+            (req: UnlockRequest, context: ServerCallContext) => lockRpcLocal.unlockRequest(req, context))
         this.rpcCommunicator.registerRpcMethod(DisconnectNotice, DisconnectNoticeResponse, 'gracefulDisconnect',
-            (req: DisconnectNotice, context: ServerCallContext) => this.gracefulDisconnect(req, context))
+            (req: DisconnectNotice, context: ServerCallContext) => lockRpcLocal.gracefulDisconnect(req, context))
     }
 
     public garbageCollectConnections(maxConnections: number, lastUsedLimit: number): void {
         if (this.connections.size <= maxConnections) {
             return
         }
-        const disconnectionCandidates = new SortedContactList<Contact>(peerIdFromPeerDescriptor(this.getOwnPeerDescriptor()), 100000)
+        const disconnectionCandidates = new SortedContactList<Contact>(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 100000)
         this.connections.forEach((connection) => {
             if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
                 logger.trace('disconnecting in timeout interval: ' + keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
@@ -178,7 +186,8 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         logger.trace(`Starting ConnectionManager...`)
         await this.connectorFacade.start(
             (connection: ManagedConnection) => this.onIncomingConnection(connection),
-            (peerDescriptor: PeerDescriptor) => this.canConnect(peerDescriptor)
+            (peerDescriptor: PeerDescriptor) => this.canConnect(peerDescriptor),
+            this
         )
         // Garbage collection of connections
         this.disconnectorIntervalRef = setInterval(() => {
@@ -209,7 +218,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             } else {
                 logger.trace('handshake of connection not completed, force-closing')
                 const eventReceived = waitForEvent3<ManagedConnectionEvents>(peer, 'disconnected', 2000)
-                peer.close('OTHER')
+                peer.close(true)
                 try {
                     await eventReceived
                     logger.trace('resolving after receiving disconnected event from non-handshaked connection')
@@ -224,10 +233,10 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         this.duplicateMessageDetector.clear()
         this.locks.clear()
         this.removeAllListeners()
-        // TODO would it make sense to move this call to WebRtcConnector#stop()?
+        // TODO would it make sense to move this call to WebrtcConnector#stop()?
         // - but note that we should call this only after connections have been closed
         //   (i.e the this.gracefullyDisconnectAsync() calls above)
-        WEB_RTC_CLEANUP.cleanUp()
+        WEBRTC_CLEANUP.cleanUp()
     }
 
     public getNumberOfLocalLockedConnections(): number {
@@ -246,7 +255,6 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         if (this.state === ConnectionManagerState.STOPPED && !doNotMindStopped) {
             return
         }
-
         const peerDescriptor = message.targetDescriptor!
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self')
@@ -254,8 +262,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         logger.trace(`Sending message to: ${keyFromPeerDescriptor(peerDescriptor)}`)
         message = {
             ...message,
-            targetDescriptor: message.targetDescriptor || peerDescriptor,
-            sourceDescriptor: message.sourceDescriptor || this.getOwnPeerDescriptor(),
+            sourceDescriptor: this.getLocalPeerDescriptor()
         }
         const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
         let connection = this.connections.get(peerIdKey)
@@ -272,14 +279,14 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
     }
 
     private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean { 
-        return areEqualPeerDescriptors(peerDescriptor, this.getOwnPeerDescriptor()) || this.isOwnWebSocketServer(peerDescriptor)
+        return areEqualPeerDescriptors(peerDescriptor, this.getLocalPeerDescriptor()) || this.isOwnWebsocketServer(peerDescriptor)
     }
 
-    private isOwnWebSocketServer(peerDescriptor: PeerDescriptor): boolean {
-        const ownPeerDescriptor = this.getOwnPeerDescriptor()
-        if ((peerDescriptor.websocket !== undefined) && (ownPeerDescriptor.websocket !== undefined)) {
-            return ((peerDescriptor.websocket.port === ownPeerDescriptor.websocket.port) 
-                && (peerDescriptor.websocket.host === ownPeerDescriptor.websocket.host))
+    private isOwnWebsocketServer(peerDescriptor: PeerDescriptor): boolean {
+        const localPeerDescriptor = this.getLocalPeerDescriptor()
+        if ((peerDescriptor.websocket !== undefined) && (localPeerDescriptor.websocket !== undefined)) {
+            return ((peerDescriptor.websocket.port === localPeerDescriptor.websocket.port) 
+                && (peerDescriptor.websocket.host === localPeerDescriptor.websocket.host))
         } else {
             return false
         }
@@ -290,13 +297,8 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         return this.connections.get(peerIdKey)
     }
 
-    // TODO remove this method or getOwnPeerDescriptor
-    public getPeerDescriptor(): PeerDescriptor {
-        return this.getOwnPeerDescriptor()
-    }
-
-    private getOwnPeerDescriptor(): PeerDescriptor {
-        return this.connectorFacade.getOwnPeerDescriptor()!
+    public getLocalPeerDescriptor(): PeerDescriptor {
+        return this.connectorFacade.getLocalPeerDescriptor()!
     }
 
     public hasConnection(peerDescriptor: PeerDescriptor): boolean {
@@ -361,15 +363,15 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         }
     }
 
-    private onConnected = (connection: ManagedConnection) => {
+    private onConnected(connection: ManagedConnection) {
         const peerDescriptor = connection.getPeerDescriptor()!
         this.emit('connected', peerDescriptor)
         logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' onConnected() ' + connection.connectionType)
         this.onConnectionCountChange()
     }
 
-    private onDisconnected = (connection: ManagedConnection, disconnectionType: DisconnectionType) => {
-        logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) + ' onDisconnected() ' + disconnectionType)
+    private onDisconnected(connection: ManagedConnection, gracefulLeave: boolean) {
+        logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
 
         const peerIdKey = keyFromPeerDescriptor(connection.getPeerDescriptor()!)
         const storedConnection = this.connections.get(peerIdKey)
@@ -377,8 +379,8 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             this.locks.clearAllLocks(peerIdKey)
             this.connections.delete(peerIdKey)
             logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
-                + ' deleted connection in onDisconnected() ' + disconnectionType)
-            this.emit('disconnected', connection.getPeerDescriptor()!, disconnectionType)
+                + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
+            this.emit('disconnected', connection.getPeerDescriptor()!, gracefulLeave)
             this.onConnectionCountChange()
         } else {
             logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
@@ -401,14 +403,14 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             return false
         }
         connection.on('managedData', this.onData)
-        connection.on('disconnected', (disconnectionType: DisconnectionType) => {
-            this.onDisconnected(connection, disconnectionType)
+        connection.on('disconnected', (gracefulLeave: boolean) => {
+            this.onDisconnected(connection, gracefulLeave)
         })
         this.emit('newConnection', connection)
         if (connection.isHandshakeCompleted()) {
             this.onConnected(connection)
         } else {
-            connection.once('handshakeCompleted', ()=> {
+            connection.once('handshakeCompleted', () => {
                 this.onConnected(connection)
             })
         }
@@ -420,7 +422,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         const newPeerID = peerIdFromPeerDescriptor(newConnection.getPeerDescriptor()!)
         const peerIdKey = keyFromPeerDescriptor(newConnection.getPeerDescriptor()!)
         if (this.connections.has(peerIdKey)) {
-            if (newPeerID.hasSmallerHashThan(peerIdFromPeerDescriptor(this.getOwnPeerDescriptor()))) {
+            if (newPeerID.hasSmallerHashThan(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
                 logger.trace(keyOrUnknownFromPeerDescriptor(newConnection.getPeerDescriptor())
                     + ' acceptIncomingConnection() replace current connection')
                 // replace the current connection
@@ -446,54 +448,54 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         return true
     }
 
-    private async closeConnection(peerDescriptor: PeerDescriptor, disconnectionType: DisconnectionType, reason?: string): Promise<void> {
+    private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
         logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() ' + reason)
         const id = keyFromPeerDescriptor(peerDescriptor)
         this.locks.clearAllLocks(id)
         if (this.connections.has(id)) {
             const connectionToClose = this.connections.get(id)!
-            await connectionToClose.close(disconnectionType)
+            await connectionToClose.close(gracefulLeave)
 
         } else {
             logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() this.connections did not have the id')
-            this.emit('disconnected', peerDescriptor, 'OTHER')
+            this.emit('disconnected', peerDescriptor, false)
         }
     }
 
-    public lockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getOwnPeerDescriptor())) {
+    public lockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void {
+        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
         const rpcRemote = new ConnectionLockRpcRemote(
-            this.getOwnPeerDescriptor(),
+            this.getLocalPeerDescriptor(),
             targetDescriptor,
             toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        this.locks.addLocalLocked(peerIdKey, serviceId)
-        rpcRemote.lockRequest(serviceId)
+        this.locks.addLocalLocked(peerIdKey, lockId)
+        rpcRemote.lockRequest(lockId)
             .then((_accepted) => logger.trace('LockRequest successful'))
             .catch((err) => { logger.debug(err) })
     }
 
-    public unlockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getOwnPeerDescriptor())) {
+    public unlockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void {
+        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.removeLocalLocked(peerIdKey, serviceId)
+        this.locks.removeLocalLocked(peerIdKey, lockId)
         const rpcRemote = new ConnectionLockRpcRemote(
-            this.getOwnPeerDescriptor(),
+            this.getLocalPeerDescriptor(),
             targetDescriptor,
             toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
         if (this.connections.has(peerIdKey)) {
-            rpcRemote.unlockRequest(serviceId)
+            rpcRemote.unlockRequest(lockId)
         }
     }
 
     public weakLockConnection(targetDescriptor: PeerDescriptor): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getOwnPeerDescriptor())) {
+        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
@@ -501,7 +503,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
     }
 
     public weakUnlockConnection(targetDescriptor: PeerDescriptor): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getOwnPeerDescriptor())) {
+        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
@@ -526,7 +528,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             })
                 .catch((e) => {
                     logger.trace('force-closing connection after timeout ' + e)
-                    connection.close('OTHER')
+                    connection.close(true)
                 })
                 .finally(() => {
                     logger.trace('resolving after receiving disconnected event')
@@ -546,7 +548,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
         logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' gracefullyDisconnectAsync()')
         const rpcRemote = new ConnectionLockRpcRemote(
-            this.getOwnPeerDescriptor(),
+            this.getLocalPeerDescriptor(),
             targetDescriptor,
             toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
@@ -563,44 +565,6 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             .map((managedConnection: ManagedConnection) => managedConnection.getPeerDescriptor()!)
     }
 
-    // ConnectionLockRpc local RPC method
-    private async lockRequest(lockRequest: LockRequest, context: ServerCallContext): Promise<LockResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remotePeerId = peerIdFromPeerDescriptor(senderPeerDescriptor)
-        if (areEqualPeerDescriptors(senderPeerDescriptor, this.getOwnPeerDescriptor())) {
-            const response: LockResponse = {
-                accepted: false
-            }
-            return response
-        }
-        this.locks.addRemoteLocked(remotePeerId.toKey(), lockRequest.serviceId)
-        const response: LockResponse = {
-            accepted: true
-        }
-        return response
-    }
-
-    // ConnectionLockRpc local RPC method
-    private async unlockRequest(unlockRequest: UnlockRequest, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerIdKey = keyFromPeerDescriptor(senderPeerDescriptor)
-        this.locks.removeRemoteLocked(peerIdKey, unlockRequest.serviceId)
-        return {}
-    }
-
-    // ConnectionLockRpc local RPC method
-    private async gracefulDisconnect(disconnectNotice: DisconnectNotice, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        logger.trace(keyOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice')
-
-        if (disconnectNotice.disconnectMode === DisconnectMode.LEAVING) {
-            this.closeConnection(senderPeerDescriptor, 'INCOMING_GRACEFUL_LEAVE', 'graceful leave notified')
-        } else {
-            this.closeConnection(senderPeerDescriptor, 'INCOMING_GRACEFUL_DISCONNECT', 'graceful disconnect notified')
-        }
-        return {}
-    }
-
     private onConnectionCountChange() {
         this.metrics.connectionAverageCount.record(this.connections.size)
     }