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

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

package/src/connection/ConnectivityChecker.ts

@@ -6,16 +6,16 @@ import {
 import { ConnectionEvents, IConnection } from './IConnection'
 import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
 import * as Err from '../helpers/errors'
-import { ClientWebSocket } from './WebSocket/ClientWebSocket'
+import { ClientWebsocket } from './websocket/ClientWebsocket'
 import { v4 } from 'uuid'
 import { NatType } from './ConnectionManager'
-import { ServerWebSocket } from './WebSocket/ServerWebSocket'
-import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnectorRpcLocal'
+import { ServerWebsocket } from './websocket/ServerWebsocket'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
 
 const logger = new Logger(module)
 
 // Class for handling both client and server side of the connectivity
-// checks. This is attached to all ServerWebSockets to listen to
+// checks. This is attached to all ServerWebsockets to listen to
 // ConnectivityRequest messages. 
 
 export enum ConnectionMode { REQUEST = 'connectivityRequest', PROBE = 'connectivityProbe' }
@@ -24,17 +24,17 @@ export class ConnectivityChecker {
     private static readonly CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
     private static readonly CONNECTIVITY_CHECKER_TIMEOUT = 5000
     private destroyed = false
-    private readonly webSocketPort: number
+    private readonly websocketPort: number
     private readonly tls: boolean 
-    private readonly host?: string
+    private host?: string
 
-    constructor(webSocketPort: number, tls: boolean, host?: string) {
-        this.webSocketPort = webSocketPort
+    constructor(websocketPort: number, tls: boolean, host?: string) {
+        this.websocketPort = websocketPort
         this.tls = tls
         this.host = host
     }
 
-    public async sendConnectivityRequest(entryPoint: PeerDescriptor): Promise<ConnectivityResponse> {
+    public async sendConnectivityRequest(entryPoint: PeerDescriptor, selfSigned: boolean): Promise<ConnectivityResponse> {
         if (this.destroyed) {
             throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
         }
@@ -46,13 +46,14 @@ export class ConnectivityChecker {
                     port: entryPoint.websocket!.port,
                     tls: entryPoint.websocket!.tls,
                 },
-                mode: ConnectionMode.REQUEST
+                mode: ConnectionMode.REQUEST,
+                selfSigned
             })
         } catch (e) {
-            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`, e)
+            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`, e)
         }
         // send connectivity request
-        const connectivityRequestMessage: ConnectivityRequest = { port: this.webSocketPort, host: this.host, tls: this.tls }
+        const connectivityRequestMessage: ConnectivityRequest = { port: this.websocketPort, host: this.host, tls: this.tls, selfSigned }
         const msg: Message = {
             serviceId: ConnectivityChecker.CONNECTIVITY_CHECKER_SERVICE_ID,
             messageType: MessageType.CONNECTIVITY_REQUEST, messageId: v4(),
@@ -64,11 +65,11 @@ export class ConnectivityChecker {
         const responseAwaiter = () => {
             return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
                 const timeoutId = setTimeout(() => {
-                    outgoingConnection.close('OTHER')
+                    outgoingConnection.close(false)
                     reject(new Err.ConnectivityResponseTimeout('timeout'))
                 }, ConnectivityChecker.CONNECTIVITY_CHECKER_TIMEOUT)
                 const listener = (bytes: Uint8Array) => {
-                    outgoingConnection.close('OTHER')
+                    outgoingConnection.close(false)
                     try {
                         const message: Message = Message.fromBinary(bytes)
                         if (message.body.oneofKind === 'connectivityResponse') {
@@ -98,7 +99,11 @@ export class ConnectivityChecker {
         }
     }
 
-    public listenToIncomingConnectivityRequests(connectionToListenTo: ServerWebSocket): void {
+    public setHost(hostName: string): void {
+        this.host = hostName
+    }
+
+    public listenToIncomingConnectivityRequests(connectionToListenTo: ServerWebsocket): void {
         connectionToListenTo.on('data', (data: Uint8Array) => {
             logger.trace('server received data')
             try {
@@ -120,7 +125,7 @@ export class ConnectivityChecker {
     }
 
     private async handleIncomingConnectivityRequest(
-        connection: ServerWebSocket,
+        connection: ServerWebsocket,
         connectivityRequest: ConnectivityRequest
     ): Promise<void> {
         if (this.destroyed) {
@@ -135,24 +140,23 @@ export class ConnectivityChecker {
                 port: connectivityRequest.port,
                 tls: connectivityRequest.tls
             }
-            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebSocketUrl(wsServerInfo)}`)
+            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebsocketUrl(wsServerInfo)}`)
             outgoingConnection = await this.connectAsync({
                 wsServerInfo,
-                mode: ConnectionMode.PROBE
+                mode: ConnectionMode.PROBE,
+                selfSigned: connectivityRequest.selfSigned
             })
         } catch (err) {
             logger.debug('error', { err })
             connectivityResponseMessage = {
-                openInternet: false,
                 host,
                 natType: NatType.UNKNOWN
             }
         }
         if (outgoingConnection) {
-            outgoingConnection.close('OTHER')
+            outgoingConnection.close(false)
             logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
             connectivityResponseMessage = {
-                openInternet: true,
                 host,
                 natType: NatType.OPEN_INTERNET,
                 websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls }
@@ -171,15 +175,15 @@ export class ConnectivityChecker {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    private async connectAsync({ wsServerInfo, mode, timeoutMs = 1000, }:
-        { wsServerInfo: ConnectivityMethod, mode: ConnectionMode, timeoutMs?: number }
+    private async connectAsync({ wsServerInfo, mode, selfSigned, timeoutMs = 1000, }:
+        { wsServerInfo: ConnectivityMethod, mode: ConnectionMode, selfSigned: boolean, timeoutMs?: number }
     ): Promise<IConnection> {
-        const socket = new ClientWebSocket()
-        const url = `${connectivityMethodToWebSocketUrl(wsServerInfo)}?${mode}=true`
+        const socket = new ClientWebsocket()
+        const url = `${connectivityMethodToWebsocketUrl(wsServerInfo)}?${mode}=true`
         let result: RunAndRaceEventsReturnType<ConnectionEvents>
         try {
             result = await runAndRaceEvents3<ConnectionEvents>([
-                () => { socket.connect(url) }],
+                () => { socket.connect(url, selfSigned) }],
             socket, ['connected', 'error'],
             timeoutMs)
         } catch (e) {