@streamr/dht 0.0.1-tatum.5 → 0.0.1-tatum.7

package/dist/src/connection/ConnectionManager.js

@@ -23,39 +23,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionManager = exports.NatType = exports.ConnectionManagerConfig = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const DhtRpc_1 = require("../proto/packages/dht/protos/DhtRpc");
-const WebSocketConnector_1 = require("./WebSocket/WebSocketConnector");
-const protoToString_1 = require("../helpers/protoToString");
-const WebRtcConnector_1 = require("./WebRTC/WebRtcConnector");
+exports.ConnectionManager = exports.keyOrUnknownFromPeerDescriptor = exports.NatType = void 0;
+const proto_rpc_1 = require("@streamr/proto-rpc");
 const utils_1 = require("@streamr/utils");
+const eventemitter3_1 = require("eventemitter3");
+const Contact_1 = require("../dht/contact/Contact");
+const SortedContactList_1 = require("../dht/contact/SortedContactList");
+const DuplicateDetector_1 = require("../dht/routing/DuplicateDetector");
 const Err = __importStar(require("../helpers/errors"));
-const NodeWebRtcConnection_1 = require("./WebRTC/NodeWebRtcConnection");
-const RoutingRpcCommunicator_1 = require("../transport/RoutingRpcCommunicator");
-const proto_rpc_1 = require("@streamr/proto-rpc");
+const peerIdFromPeerDescriptor_1 = require("../helpers/peerIdFromPeerDescriptor");
+const protoToString_1 = require("../helpers/protoToString");
+const DhtRpc_1 = require("../proto/packages/dht/protos/DhtRpc");
 const DhtRpc_client_1 = require("../proto/packages/dht/protos/DhtRpc.client");
-const RemoteConnectionLocker_1 = require("./RemoteConnectionLocker");
-const SimulatorConnector_1 = require("./Simulator/SimulatorConnector");
+const RoutingRpcCommunicator_1 = require("../transport/RoutingRpcCommunicator");
 const ConnectionLockHandler_1 = require("./ConnectionLockHandler");
-const DuplicateDetector_1 = require("../dht/routing/DuplicateDetector");
-const SortedContactList_1 = require("../dht/contact/SortedContactList");
-const Contact_1 = require("../dht/contact/Contact");
-const peerIdFromPeerDescriptor_1 = require("../helpers/peerIdFromPeerDescriptor");
-class ConnectionManagerConfig {
-    constructor(conf) {
-        this.maxConnections = 80;
-        // assign given non-undefined config vars over defaults
-        let k;
-        for (k in conf) {
-            if (conf[k] === undefined) {
-                delete conf[k];
-            }
-        }
-        Object.assign(this, conf);
-    }
-}
-exports.ConnectionManagerConfig = ConnectionManagerConfig;
+const RemoteConnectionLocker_1 = require("./RemoteConnectionLocker");
+const NodeWebRtcConnection_1 = require("./WebRTC/NodeWebRtcConnection");
 var NatType;
 (function (NatType) {
     NatType["OPEN_INTERNET"] = "open_internet";
@@ -69,44 +52,62 @@ var ConnectionManagerState;
     ConnectionManagerState["STOPPING"] = "stopping";
     ConnectionManagerState["STOPPED"] = "stopped";
 })(ConnectionManagerState || (ConnectionManagerState = {}));
+const INTERNAL_SERVICE_ID = 'system/connection-manager';
+// Form an string representation from a peer description which can be undefined. This output 
+// 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)
+// - if the peerDescriptor of ManagedConnection is always available
+// - if we create stricter types for incoming messages (message.sourceDescriptor or
+//   disconnectNotice.peerDescriptor)
+// - if ManagedConnection#peerDescriptor is never undefined
+const keyOrUnknownFromPeerDescriptor = (peerDescriptor) => {
+    if (peerDescriptor !== undefined) {
+        return (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+    }
+    else {
+        return 'unknown';
+    }
+};
+exports.keyOrUnknownFromPeerDescriptor = keyOrUnknownFromPeerDescriptor;
 class ConnectionManager extends eventemitter3_1.EventEmitter {
-    constructor(conf) {
+    constructor(config) {
         super();
-        this.messageDuplicateDetector = new DuplicateDetector_1.DuplicateDetector(100000, 100);
+        this.duplicateMessageDetector = new DuplicateDetector_1.DuplicateDetector(100000, 100);
         this.locks = new ConnectionLockHandler_1.ConnectionLockHandler();
         this.connections = new Map();
         this.state = ConnectionManagerState.IDLE;
         this.onConnected = (connection) => {
             const peerDescriptor = connection.getPeerDescriptor();
             this.emit('connected', peerDescriptor);
-            logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + peerDescriptor.nodeName + ' onConnected() ' + connection.connectionType);
+            logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor) + ' onConnected() ' + connection.connectionType);
             this.onConnectionCountChange();
         };
         this.onDisconnected = (connection, disconnectionType) => {
-            logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + connection.getPeerDescriptor()?.nodeName +
-                ' onDisconnected() ' + disconnectionType);
-            const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(connection.getPeerDescriptor());
-            const storedConnection = this.connections.get(hexKey);
+            logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(connection.getPeerDescriptor()) + ' onDisconnected() ' + disconnectionType);
+            const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(connection.getPeerDescriptor());
+            const storedConnection = this.connections.get(peerIdKey);
             if (storedConnection && storedConnection.connectionId.equals(connection.connectionId)) {
-                this.locks.clearAllLocks(hexKey);
-                this.connections.delete(hexKey);
-                logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + connection.getPeerDescriptor()?.nodeName +
-                    ' deleted connection in onDisconnected() ' + disconnectionType);
+                this.locks.clearAllLocks(peerIdKey);
+                this.connections.delete(peerIdKey);
+                logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(connection.getPeerDescriptor())
+                    + ' deleted connection in onDisconnected() ' + disconnectionType);
                 this.emit('disconnected', connection.getPeerDescriptor(), disconnectionType);
                 this.onConnectionCountChange();
             }
             else {
-                logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + connection.getPeerDescriptor()?.nodeName +
-                    ' onDisconnected() did nothing, no such connection in connectionManager');
+                logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(connection.getPeerDescriptor())
+                    + ' onDisconnected() did nothing, no such connection in connectionManager');
                 if (storedConnection) {
-                    logger.trace(this.ownPeerDescriptor?.nodeName + ', ' + connection.getPeerDescriptor()?.nodeName +
-                        ' connectionIds do not match ' + storedConnection.connectionId + ' ' + connection.connectionId);
+                    logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(connection.getPeerDescriptor())
+                        + ' connectionIds do not match ' + storedConnection.connectionId + ' ' + connection.connectionId);
                 }
             }
         };
-        this.config = new ConnectionManagerConfig(conf);
+        this.config = config;
         this.onData = this.onData.bind(this);
-        this.incomingConnectionCallback = this.incomingConnectionCallback.bind(this);
+        this.onIncomingConnection = this.onIncomingConnection.bind(this);
         this.metricsContext = this.config.metricsContext || new utils_1.MetricsContext();
         this.metrics = {
             sendMessagesPerSecond: new utils_1.RateMetric(),
@@ -117,78 +118,46 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             connectionTotalFailureCount: new utils_1.CountMetric()
         };
         this.metricsContext.addMetrics('node', this.metrics);
-        if (this.config.simulator) {
-            logger.trace(`Creating SimulatorConnector`);
-            this.simulatorConnector = new SimulatorConnector_1.SimulatorConnector(ConnectionManager.PROTOCOL_VERSION, this.config.ownPeerDescriptor, this.config.simulator, this.incomingConnectionCallback);
-            this.config.simulator.addConnector(this.simulatorConnector);
-            this.ownPeerDescriptor = this.config.ownPeerDescriptor;
-            this.state = ConnectionManagerState.RUNNING;
-        }
-        else {
-            logger.trace(`Creating WebSocketConnector`);
-            this.webSocketConnector = new WebSocketConnector_1.WebSocketConnector(ConnectionManager.PROTOCOL_VERSION, this.config.transportLayer, this.canConnect.bind(this), this.incomingConnectionCallback, this.config.websocketPortRange, this.config.websocketHost, this.config.entryPoints, this.config.tlsCertificate);
-            logger.trace(`Creating WebRTCConnector`);
-            this.webrtcConnector = new WebRtcConnector_1.WebRtcConnector({
-                rpcTransport: this.config.transportLayer,
-                protocolVersion: ConnectionManager.PROTOCOL_VERSION,
-                iceServers: this.config.iceServers,
-                allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
-                bufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
-                bufferThresholdHigh: this.config.webrtcDatachannelBufferThresholdHigh,
-                connectionTimeout: this.config.webrtcNewConnectionTimeout,
-                externalIp: this.config.externalIp,
-                portRange: this.config.webrtcPortRange
-            }, this.incomingConnectionCallback);
-        }
-        this.serviceId = (this.config.serviceIdPrefix ? this.config.serviceIdPrefix : '') + 'ConnectionManager';
+        this.connectorFacade = this.config.createConnectorFacade();
         this.send = this.send.bind(this);
-        this.rpcCommunicator = new RoutingRpcCommunicator_1.RoutingRpcCommunicator(this.serviceId, this.send, {
+        this.rpcCommunicator = new RoutingRpcCommunicator_1.RoutingRpcCommunicator(INTERNAL_SERVICE_ID, this.send, {
             rpcRequestTimeout: 10000
         });
-        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.LockRequest, DhtRpc_1.LockResponse, 'lockRequest', (req, context) => this.lockRequest(req, context));
-        this.rpcCommunicator.registerRpcNotification(DhtRpc_1.UnlockRequest, 'unlockRequest', (req, context) => this.unlockRequest(req, context));
-        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.DisconnectNotice, DhtRpc_1.DisconnectNoticeResponse, 'gracefulDisconnect', (req, context) => this.gracefulDisconnect(req, context));
+        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.LockRequest, DhtRpc_1.LockResponse, 'lockRequest', (req) => this.lockRequest(req));
+        this.rpcCommunicator.registerRpcNotification(DhtRpc_1.UnlockRequest, 'unlockRequest', (req) => this.unlockRequest(req));
+        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.DisconnectNotice, DhtRpc_1.DisconnectNoticeResponse, 'gracefulDisconnect', (req) => this.gracefulDisconnect(req));
     }
     garbageCollectConnections(maxConnections, lastUsedLimit) {
         if (this.connections.size <= maxConnections) {
             return;
         }
-        const disconnectionCandidates = new SortedContactList_1.SortedContactList((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.ownPeerDescriptor), 100000);
+        const disconnectionCandidates = new SortedContactList_1.SortedContactList((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.getOwnPeerDescriptor()), 100000);
         this.connections.forEach((connection) => {
             if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
-                logger.trace('disconnecting in timeout interval: ' + this.ownPeerDescriptor?.nodeName + ', '
-                    + connection.getPeerDescriptor()?.nodeName + ' ');
+                logger.trace('disconnecting in timeout interval: ' + (0, exports.keyOrUnknownFromPeerDescriptor)(connection.getPeerDescriptor()));
                 disconnectionCandidates.addContact(new Contact_1.Contact(connection.getPeerDescriptor()));
             }
         });
         const sortedCandidates = disconnectionCandidates.getAllContacts();
         const targetNum = this.connections.size - maxConnections;
         for (let i = 0; i < sortedCandidates.length && i < targetNum; i++) {
-            logger.trace(this.ownPeerDescriptor?.nodeName + ' garbageCollecting '
-                + sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor().nodeName);
+            logger.trace('garbageCollecting ' + (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor()));
             this.gracefullyDisconnectAsync(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor(), DhtRpc_1.DisconnectMode.NORMAL).catch((_e) => { });
         }
     }
-    async start(peerDescriptorGeneratorCallback) {
+    async start() {
         if (this.state === ConnectionManagerState.RUNNING || this.state === ConnectionManagerState.STOPPED) {
             throw new Err.CouldNotStart(`Cannot start already ${this.state} module`);
         }
         this.state = ConnectionManagerState.RUNNING;
         logger.trace(`Starting ConnectionManager...`);
+        await this.connectorFacade.start((connection) => this.onIncomingConnection(connection), (peerDescriptor) => this.canConnect(peerDescriptor));
         // Garbage collection of connections
         this.disconnectorIntervalRef = setInterval(() => {
             logger.trace('disconnectorInterval');
             const LAST_USED_LIMIT = 20000;
-            this.garbageCollectConnections(this.config.maxConnections, LAST_USED_LIMIT);
+            this.garbageCollectConnections(this.config.maxConnections ?? 80, LAST_USED_LIMIT);
         }, 5000);
-        if (!this.config.simulator) {
-            await this.webSocketConnector.start();
-            const connectivityResponse = await this.webSocketConnector.checkConnectivity();
-            const ownPeerDescriptor = peerDescriptorGeneratorCallback(connectivityResponse);
-            this.ownPeerDescriptor = ownPeerDescriptor;
-            this.webSocketConnector.setOwnPeerDescriptor(ownPeerDescriptor);
-            this.webrtcConnector.setOwnPeerDescriptor(ownPeerDescriptor);
-        }
     }
     async stop() {
         if (this.state === ConnectionManagerState.STOPPED || this.state === ConnectionManagerState.STOPPING) {
@@ -199,16 +168,7 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         if (this.disconnectorIntervalRef) {
             clearInterval(this.disconnectorIntervalRef);
         }
-        if (!this.config.simulator) {
-            await this.webSocketConnector.destroy();
-            this.webSocketConnector = undefined;
-            await this.webrtcConnector.stop();
-            this.webrtcConnector = undefined;
-        }
-        else {
-            await this.simulatorConnector.stop();
-            this.simulatorConnector = undefined;
-        }
+        await this.connectorFacade.stop();
         await Promise.all(Array.from(this.connections.values()).map(async (peer) => {
             if (peer.isHandshakeCompleted()) {
                 try {
@@ -233,16 +193,13 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         }));
         this.state = ConnectionManagerState.STOPPED;
         this.rpcCommunicator.stop();
-        this.config.transportLayer = undefined;
-        this.messageDuplicateDetector.clear();
+        this.duplicateMessageDetector.clear();
         this.locks.clear();
         this.removeAllListeners();
-        if (!this.config.simulator) {
-            NodeWebRtcConnection_1.WEB_RTC_CLEANUP.cleanUp();
-        }
-    }
-    getConnectionTo(id) {
-        return this.connections.get(id);
+        // 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)
+        NodeWebRtcConnection_1.WEB_RTC_CLEANUP.cleanUp();
     }
     getNumberOfLocalLockedConnections() {
         return this.locks.getNumberOfLocalLockedConnections();
@@ -261,17 +218,17 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self');
         }
-        logger.trace(`Sending message to: ${peerDescriptor.kademliaId.toString()}`);
+        logger.trace(`Sending message to: ${(0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor)}`);
         message = {
             ...message,
             targetDescriptor: message.targetDescriptor || peerDescriptor,
-            sourceDescriptor: message.sourceDescriptor || this.ownPeerDescriptor,
+            sourceDescriptor: message.sourceDescriptor || this.getOwnPeerDescriptor(),
         };
-        const hexId = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
-        let connection = this.connections.get(hexId);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+        let connection = this.connections.get(peerIdKey);
         if (!connection && !doNotConnect) {
-            connection = this.createConnection(peerDescriptor);
-            this.incomingConnectionCallback(connection);
+            connection = this.connectorFacade.createConnection(peerDescriptor);
+            this.onIncomingConnection(connection);
         }
         else if (!connection) {
             throw new Err.SendFailed('No connection to target, doNotConnect flag is true');
@@ -282,48 +239,42 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         return connection.send(binary, doNotConnect);
     }
     isConnectionToSelf(peerDescriptor) {
-        return (0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(peerDescriptor, this.ownPeerDescriptor) || this.isOwnWebSocketServer(peerDescriptor);
+        return (0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(peerDescriptor, this.getOwnPeerDescriptor()) || this.isOwnWebSocketServer(peerDescriptor);
     }
     isOwnWebSocketServer(peerDescriptor) {
-        if ((peerDescriptor.websocket !== undefined) && (this.ownPeerDescriptor.websocket !== undefined)) {
-            return ((peerDescriptor.websocket.port === this.ownPeerDescriptor.websocket.port)
-                && (peerDescriptor.websocket.host === this.ownPeerDescriptor.websocket.host));
+        const ownPeerDescriptor = this.getOwnPeerDescriptor();
+        if ((peerDescriptor.websocket !== undefined) && (ownPeerDescriptor.websocket !== undefined)) {
+            return ((peerDescriptor.websocket.port === ownPeerDescriptor.websocket.port)
+                && (peerDescriptor.websocket.host === ownPeerDescriptor.websocket.host));
         }
         else {
             return false;
         }
     }
-    createConnection(peerDescriptor) {
-        if (this.simulatorConnector) {
-            return this.simulatorConnector.connect(peerDescriptor);
-        }
-        else if (peerDescriptor.websocket || this.ownPeerDescriptor.websocket) {
-            if (!(peerDescriptor.type === DhtRpc_1.NodeType.BROWSER && this.ownPeerDescriptor.websocket?.tls)) {
-                return this.webSocketConnector.connect(peerDescriptor);
-            }
-        }
-        return this.webrtcConnector.connect(peerDescriptor);
-    }
     getConnection(peerDescriptor) {
-        const hexId = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
-        return this.connections.get(hexId);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+        return this.connections.get(peerIdKey);
     }
+    // TODO remove this method or getOwnPeerDescriptor
     getPeerDescriptor() {
-        return this.ownPeerDescriptor;
+        return this.getOwnPeerDescriptor();
+    }
+    getOwnPeerDescriptor() {
+        return this.connectorFacade.getOwnPeerDescriptor();
     }
     hasConnection(peerDescriptor) {
-        const hexId = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
-        return this.connections.has(hexId);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+        return this.connections.has(peerIdKey);
     }
-    hasLocalLockedConnection(peerDescriptor, _serviceId) {
-        const hexId = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
-        return this.locks.isLocalLocked(hexId);
+    hasLocalLockedConnection(peerDescriptor) {
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+        return this.locks.isLocalLocked(peerIdKey);
     }
-    hasRemoteLockedConnection(peerDescriptor, _serviceId) {
-        const hexId = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
-        return this.locks.isRemoteLocked(hexId);
+    hasRemoteLockedConnection(peerDescriptor) {
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
+        return this.locks.isRemoteLocked(peerIdKey);
     }
-    canConnect(peerDescriptor, _ip, _port) {
+    canConnect(peerDescriptor) {
         // Perhaps the connection's state should be checked here
         return !this.hasConnection(peerDescriptor); // TODO: Add port range check
     }
@@ -333,18 +284,17 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             logger.trace('Filtered out non-RPC message of type ' + message.messageType);
             return;
         }
-        if (this.messageDuplicateDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger.trace('handleMessage filtered duplicate ' + this.ownPeerDescriptor?.nodeName + ', '
-                + message.sourceDescriptor?.nodeName + ' ' + message.serviceId + ' ' + message.messageId);
+        if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
+            logger.trace('handleMessage filtered duplicate ' + (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(message.sourceDescriptor)
+                + ' ' + message.serviceId + ' ' + message.messageId);
             return;
         }
-        this.messageDuplicateDetector.add(message.messageId, message.sourceDescriptor.nodeName, message);
-        if (message.serviceId === this.serviceId) {
+        this.duplicateMessageDetector.add(message.messageId);
+        if (message.serviceId === INTERNAL_SERVICE_ID) {
             this.rpcCommunicator?.handleMessageFromPeer(message);
         }
         else {
-            logger.trace('emit "message" ' + this.ownPeerDescriptor?.nodeName + ', ' + message.sourceDescriptor?.nodeName
-                + ' ' + message.serviceId + ' ' + message.messageId);
+            logger.trace('emit "message" ' + (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(message.sourceDescriptor) + ' ' + message.serviceId + ' ' + message.messageId);
             this.emit('message', message);
         }
     }
@@ -357,7 +307,7 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         let message;
         try {
             message = DhtRpc_1.Message.fromBinary(data);
-            logger.trace(`${this.ownPeerDescriptor?.nodeName} received protojson: ${(0, protoToString_1.protoToString)(message, DhtRpc_1.Message)}`);
+            logger.trace(`received protojson: ${(0, protoToString_1.protoToString)(message, DhtRpc_1.Message)}`);
         }
         catch (e) {
             logger.debug(`Parsing incoming data into Message failed: ${e}`);
@@ -371,17 +321,17 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             logger.debug(`Handling incoming data failed: ${e}`);
         }
     }
-    incomingConnectionCallback(connection) {
+    onIncomingConnection(connection) {
         if (this.state === ConnectionManagerState.STOPPED) {
             return false;
         }
-        logger.trace('incomingConnectionCallback() objectId ' + connection.objectId);
+        logger.trace('onIncomingConnection()');
         connection.offeredAsIncoming = true;
         if (!this.acceptIncomingConnection(connection)) {
             return false;
         }
         connection.on('managedData', this.onData);
-        connection.on('disconnected', (disconnectionType, _code, _reason) => {
+        connection.on('disconnected', (disconnectionType) => {
             this.onDisconnected(connection, disconnectionType);
         });
         this.emit('newConnection', connection);
@@ -389,23 +339,23 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             this.onConnected(connection);
         }
         else {
-            connection.once('handshakeCompleted', (_peerDescriptor) => {
+            connection.once('handshakeCompleted', () => {
                 this.onConnected(connection);
             });
         }
         return true;
     }
     acceptIncomingConnection(newConnection) {
-        logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + newConnection.getPeerDescriptor()?.nodeName + ' acceptIncomingConnection()');
+        logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(newConnection.getPeerDescriptor()) + ' acceptIncomingConnection()');
         const newPeerID = (0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(newConnection.getPeerDescriptor());
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(newConnection.getPeerDescriptor());
-        if (this.connections.has(hexKey)) {
-            if (newPeerID.hasSmallerHashThan((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.ownPeerDescriptor))) {
-                logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + newConnection.getPeerDescriptor()?.nodeName +
-                    ' acceptIncomingConnection() replace current connection');
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(newConnection.getPeerDescriptor());
+        if (this.connections.has(peerIdKey)) {
+            if (newPeerID.hasSmallerHashThan((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.getOwnPeerDescriptor()))) {
+                logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(newConnection.getPeerDescriptor())
+                    + ' acceptIncomingConnection() replace current connection');
                 // replace the current connection
                 const oldConnection = this.connections.get(newPeerID.toKey());
-                logger.trace('replaced: ' + this.ownPeerDescriptor?.nodeName + ', ' + newConnection.getPeerDescriptor()?.nodeName + ' ');
+                logger.trace('replaced: ' + (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(newConnection.getPeerDescriptor()));
                 const buffer = oldConnection.stealOutputBuffer();
                 for (const data of buffer) {
                     newConnection.sendNoWait(data);
@@ -418,13 +368,12 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
                 return false;
             }
         }
-        logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + newConnection.getPeerDescriptor()?.nodeName +
-            ' added to connections at acceptIncomingConnection');
-        this.connections.set(hexKey, newConnection);
+        logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(newConnection.getPeerDescriptor()) + ' added to connections at acceptIncomingConnection');
+        this.connections.set(peerIdKey, newConnection);
         return true;
     }
     async closeConnection(peerDescriptor, disconnectionType, reason) {
-        logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + peerDescriptor.nodeName + ' ' + 'closeConnection() ' + reason);
+        logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor) + ' ' + 'closeConnection() ' + reason);
         const id = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor);
         this.locks.clearAllLocks(id);
         if (this.connections.has(id)) {
@@ -432,46 +381,45 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             await connectionToClose.close(disconnectionType);
         }
         else {
-            logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + peerDescriptor.nodeName + ' ' +
-                'closeConnection() this.connections did not have the id');
+            logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor) + ' ' + 'closeConnection() this.connections did not have the id');
             this.emit('disconnected', peerDescriptor, 'OTHER');
         }
     }
     lockConnection(targetDescriptor, serviceId) {
-        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(targetDescriptor, this.ownPeerDescriptor)) {
+        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(targetDescriptor, this.getOwnPeerDescriptor())) {
             return;
         }
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
-        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.ownPeerDescriptor, targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
-        this.locks.addLocalLocked(hexKey, serviceId);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
+        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.getOwnPeerDescriptor(), targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
+        this.locks.addLocalLocked(peerIdKey, serviceId);
         remoteConnectionLocker.lockRequest(serviceId)
             .then((_accepted) => logger.trace('LockRequest successful'))
             .catch((err) => { logger.debug(err); });
     }
     unlockConnection(targetDescriptor, serviceId) {
-        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(targetDescriptor, this.ownPeerDescriptor)) {
+        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(targetDescriptor, this.getOwnPeerDescriptor())) {
             return;
         }
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
-        this.locks.removeLocalLocked(hexKey, serviceId);
-        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.ownPeerDescriptor, targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
-        if (this.connections.has(hexKey)) {
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
+        this.locks.removeLocalLocked(peerIdKey, serviceId);
+        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.getOwnPeerDescriptor(), targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
+        if (this.connections.has(peerIdKey)) {
             remoteConnectionLocker.unlockRequest(serviceId);
         }
     }
     weakLockConnection(targetDescriptor) {
-        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(targetDescriptor, this.ownPeerDescriptor)) {
+        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(targetDescriptor, this.getOwnPeerDescriptor())) {
             return;
         }
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
-        this.locks.addWeakLocked(hexKey);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
+        this.locks.addWeakLocked(peerIdKey);
     }
     weakUnlockConnection(targetDescriptor) {
-        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(targetDescriptor, this.ownPeerDescriptor)) {
+        if (this.state === ConnectionManagerState.STOPPED || (0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(targetDescriptor, this.getOwnPeerDescriptor())) {
             return;
         }
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
-        this.locks.removeWeakLocked(hexKey);
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor);
+        this.locks.removeWeakLocked(peerIdKey);
     }
     async gracefullyDisconnectAsync(targetDescriptor, disconnectMode) {
         const connection = this.connections.get((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(targetDescriptor).toKey());
@@ -502,14 +450,13 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         await promise;
     }
     async doGracefullyDisconnectAsync(targetDescriptor, disconnectMode) {
-        logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + targetDescriptor.nodeName + ' gracefullyDisconnectAsync()');
-        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.ownPeerDescriptor, targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
+        logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor) + ' gracefullyDisconnectAsync()');
+        const remoteConnectionLocker = new RemoteConnectionLocker_1.RemoteConnectionLocker(this.getOwnPeerDescriptor(), targetDescriptor, ConnectionManager.PROTOCOL_VERSION, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ConnectionLockerClient(this.rpcCommunicator.getRpcClientTransport())));
         try {
             await remoteConnectionLocker.gracefulDisconnect(disconnectMode);
         }
         catch (ex) {
-            logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + targetDescriptor.nodeName +
-                ' remoteConnectionLocker.gracefulDisconnect() failed' + ex);
+            logger.trace((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(targetDescriptor) + ' remoteConnectionLocker.gracefulDisconnect() failed' + ex);
         }
     }
     getAllConnectionPeerDescriptors() {
@@ -518,9 +465,9 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
             .map((managedConnection) => managedConnection.getPeerDescriptor());
     }
     // IConnectionLocker server implementation
-    async lockRequest(lockRequest, _context) {
+    async lockRequest(lockRequest) {
         const remotePeerId = (0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(lockRequest.peerDescriptor);
-        if ((0, peerIdFromPeerDescriptor_1.isSamePeerDescriptor)(lockRequest.peerDescriptor, this.ownPeerDescriptor)) {
+        if ((0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(lockRequest.peerDescriptor, this.getOwnPeerDescriptor())) {
             const response = {
                 accepted: false
             };
@@ -533,15 +480,14 @@ class ConnectionManager extends eventemitter3_1.EventEmitter {
         return response;
     }
     // IConnectionLocker server implementation
-    async unlockRequest(unlockRequest, _context) {
-        const hexKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(unlockRequest.peerDescriptor);
-        this.locks.removeRemoteLocked(hexKey, unlockRequest.serviceId);
+    async unlockRequest(unlockRequest) {
+        const peerIdKey = (0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(unlockRequest.peerDescriptor);
+        this.locks.removeRemoteLocked(peerIdKey, unlockRequest.serviceId);
         return {};
     }
     // IConnectionLocker server implementation
-    async gracefulDisconnect(disconnectNotice, _context) {
-        logger.trace(' ' + this.ownPeerDescriptor?.nodeName + ', ' + disconnectNotice.peerDescriptor?.nodeName
-            + ' received gracefulDisconnect notice');
+    async gracefulDisconnect(disconnectNotice) {
+        logger.trace((0, exports.keyOrUnknownFromPeerDescriptor)(disconnectNotice.peerDescriptor) + ' received gracefulDisconnect notice');
         if (disconnectNotice.disconnecMode === DhtRpc_1.DisconnectMode.LEAVING) {
             this.closeConnection(disconnectNotice.peerDescriptor, 'INCOMING_GRACEFUL_LEAVE', 'graceful leave notified');
         }