@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-testnet-one.0

package/src/connection/simulator/SimulatorConnection.ts

@@ -85,7 +85,7 @@ export class SimulatorConnection extends Connection implements IConnection {
             logger.trace('connect() called')
 
             this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
-                if (error) {
+                if (error !== undefined) {
                     logger.trace(error)
                     this.doDisconnect(false)
                 } else {

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -51,7 +51,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         this.peerConnection = new RTCPeerConnection({ iceServers: urls })
 
         this.peerConnection.onicecandidate = (event) => {
-            if (event.candidate && event.candidate.sdpMid) {
+            if ((event.candidate !== null) && (event.candidate.sdpMid !== null)) {
                 this.emit('localCandidate', event.candidate.candidate, event.candidate.sdpMid)
             }
         }
@@ -63,14 +63,14 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         if (isOffering) {
             this.peerConnection.onnegotiationneeded = async () => {
                 try {
-                    if (this.peerConnection) {
+                    if (this.peerConnection !== undefined) {
                         this.makingOffer = true
                         try {
                             await this.peerConnection.setLocalDescription()
                         } catch (err) {
                             logger.warn('error', { err })
                         }
-                        if (this.peerConnection.localDescription) {
+                        if (this.peerConnection.localDescription !== null) {
                             this.emit('localDescription', this.peerConnection.localDescription?.sdp, this.peerConnection.localDescription?.type)
                         }
                     }
@@ -93,7 +93,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
     }
 
     public async setRemoteDescription(description: string, type: string): Promise<void> {
-        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || !this.peerConnection ||
+        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || (this.peerConnection === undefined) ||
             this.peerConnection.signalingState != 'stable')
 
         const ignoreOffer = this.isOffering && offerCollision
@@ -106,13 +106,13 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             logger.warn('error', { err })
         }
 
-        if (type.toLowerCase() === RtcDescription.OFFER && this.peerConnection) {
+        if ((type.toLowerCase() === RtcDescription.OFFER) && (this.peerConnection !== undefined)) {
             try {
                 await this.peerConnection.setLocalDescription()
             } catch (err) {
                 logger.warn('error', { err })
             }
-            if (this.peerConnection.localDescription) {
+            if (this.peerConnection.localDescription !== null) {
                 this.emit('localDescription', this.peerConnection.localDescription.sdp, this.peerConnection.localDescription.type)
             }
         }
@@ -148,7 +148,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             
             this.removeAllListeners()
 
-            if (this.dataChannel) {
+            if (this.dataChannel !== undefined) {
                 try {
                     this.dataChannel.close()
                 } catch (e) {
@@ -158,7 +158,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
             this.dataChannel = undefined
 
-            if (this.peerConnection) {
+            if (this.peerConnection !== undefined) {
                 try {
                     this.peerConnection.close()
                 } catch (e) {
@@ -209,7 +209,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
     }
 
     private stopListening() {
-        if (this.dataChannel) {
+        if (this.dataChannel !== undefined) {
             this.dataChannel.onopen = null
             this.dataChannel.onclose = null
             this.dataChannel.onerror = null
@@ -217,7 +217,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             this.dataChannel.onmessage = null
         }
 
-        if (this.peerConnection) {
+        if (this.peerConnection !== undefined) {
             this.peerConnection.onicecandidate = null
             this.peerConnection.onicegatheringstatechange = null
             this.peerConnection.onnegotiationneeded = null

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -161,7 +161,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         if (!this.closed) {
             logger.trace(
                 `Closing Node WebRTC Connection to ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`
-                + `${reason ? `, reason: ${reason}` : ''}`
+                + `${(reason !== undefined) ? `, reason: ${reason}` : ''}`
             )
 
             this.closed = true

package/src/connection/webrtc/WebrtcConnector.ts

@@ -178,7 +178,7 @@ export class WebrtcConnector {
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {
-            if (this.config.externalIp) {
+            if (this.config.externalIp !== undefined) {
                 candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
                 logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
             }

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -123,7 +123,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
     private isIceCandidateAllowed(candidate: string): boolean {
         if (!this.config.allowPrivateAddresses) {
             const address = getAddressFromIceCandidate(candidate)
-            if (address && isPrivateIPv4(address)) {
+            if ((address !== undefined) && isPrivateIPv4(address)) {
                 return false
             }
         }

package/src/connection/webrtc/WebrtcConnectorRpcRemote.ts

@@ -1,4 +1,4 @@
-import { Remote } from '../../dht/contact/Remote'
+import { RpcRemote } from '../../dht/contact/RpcRemote'
 import {
     IceCandidate,
     PeerDescriptor,
@@ -12,7 +12,7 @@ import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
 
-export class WebrtcConnectorRpcRemote extends Remote<IWebrtcConnectorRpcClient> {
+export class WebrtcConnectorRpcRemote extends RpcRemote<IWebrtcConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,

package/src/connection/webrtc/iceServerAsString.ts

@@ -9,7 +9,7 @@ export function iceServerAsString({ url, port, username, password, tcp }: IceSer
         return `${protocol}:${hostname}:${port}`
     }
     if (username !== undefined && password !== undefined) {
-        return `${protocol}:${username}:${password}@${hostname}:${port}${tcp ? '?transport=tcp' : ''}`
+        return `${protocol}:${username}:${password}@${hostname}:${port}${(tcp !== undefined) ? '?transport=tcp' : ''}`
     }
     throw new Error(`username (${username}) and password (${password}) must be supplied together`)
 }

package/src/connection/websocket/ClientWebsocket.ts

@@ -23,6 +23,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.connectionId = new ConnectionID()
     }
 
+    // TODO explicit default value for "selfSigned" or make it required
     public connect(address: string, selfSigned?: boolean): void {
         if (!this.destroyed) {
             this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })

package/src/connection/websocket/WebsocketConnector.ts

@@ -16,7 +16,7 @@ import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/Dht
 import { Logger, binaryToHex, wait } from '@streamr/utils'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
-import { ConnectivityChecker } from '../ConnectivityChecker'
+import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { ServerWebsocket } from './ServerWebsocket'
@@ -29,6 +29,9 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { WebsocketServerStartError } from '../../helpers/errors'
 import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
+import { attachConnectivityRequestHandler } from '../connectivityRequestHandler'
+import * as Err from '../../helpers/errors'
+
 const logger = new Logger(module)
 
 export type Action = 'connectivityRequest' | 'connectivityProbe'
@@ -59,7 +62,6 @@ export class WebsocketConnector {
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly websocketServer?: WebsocketServer
-    private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
     private onNewConnection: (connection: ManagedConnection) => boolean
     private host?: string
@@ -77,7 +79,7 @@ export class WebsocketConnector {
 
     constructor(config: WebsocketConnectorConfig) {
         this.websocketServer = config.portRange ? new WebsocketServer({
-            portRange: config.portRange!,
+            portRange: config.portRange,
             tlsCertificate: config.tlsCertificate,
             maxMessageSize: config.maxMessageSize,
             enableTls: config.serverEnableTls
@@ -134,13 +136,12 @@ export class WebsocketConnector {
             updateCertificate: (certificate: string, privateKey: string) => this.websocketServer!.updateCertificate(certificate, privateKey)
         })
         logger.trace(`AutoCertifying subdomain...`)
-        await this.autoCertifierClient!.start()
+        await this.autoCertifierClient.start()
     }
 
     private setHost(hostName: string): void {
         logger.trace(`Setting host name to ${hostName}`)
         this.host = hostName
-        this.connectivityChecker!.setHost(hostName)
     }
 
     public async start(): Promise<void> {
@@ -151,7 +152,7 @@ export class WebsocketConnector {
                 const action = query?.action as (Action | undefined)
                 logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteAddress() })
                 if (action === 'connectivityRequest') {
-                    this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
+                    attachConnectivityRequestHandler(serverSocket)
                 } else if (action === 'connectivityProbe') {
                     // no-op
                 } else {
@@ -160,7 +161,6 @@ export class WebsocketConnector {
             })
             const port = await this.websocketServer.start()
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.serverEnableTls, this.host)
         }
     }
 
@@ -189,12 +189,22 @@ export class WebsocketConnector {
                         return preconfiguredConnectivityResponse
                     } else {
                         // Do real connectivity checking
-                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint, selfSigned)
+                        const connectivityRequest = {
+                            port: this.selectedPort!,
+                            host: this.host, 
+                            tls: this.serverEnableTls,
+                            selfSigned
+                        }
+                        if (!this.abortController.signal.aborted) {
+                            return await sendConnectivityRequest(connectivityRequest, entryPoint)
+                        } else {
+                            throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
+                        }
                     }
                 }
             } catch (err) {
                 if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
-                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} `
+                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.nodeId)} `
                         + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
                     logger.error(error, { error: err })
                     await wait(2000)
@@ -257,6 +267,7 @@ export class WebsocketConnector {
                 targetPeerDescriptor,
                 toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
+            // TODO should we have some handling for this floating promise?
             remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
         })
         const managedConnection = new ManagedConnection(
@@ -265,7 +276,7 @@ export class WebsocketConnector {
             undefined,
             undefined,
             targetPeerDescriptor
-        )        
+        )
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -273,7 +284,7 @@ export class WebsocketConnector {
     }
 
     private onServerSocketHandshakeRequest(
-        sourcePeerDescriptor: PeerDescriptor, 
+        sourcePeerDescriptor: PeerDescriptor,
         serverWebsocket: IConnection,
         targetPeerDescriptor?: PeerDescriptor
     ) {
@@ -322,7 +333,6 @@ export class WebsocketConnector {
 
         const attempts = Array.from(this.connectingConnections.values())
         await Promise.allSettled(attempts.map((conn) => conn.close(false)))
-        this.connectivityChecker?.destroy()
         await this.websocketServer?.stop()
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -7,11 +7,11 @@ import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Remote } from '../../dht/contact/Remote'
+import { RpcRemote } from '../../dht/contact/RpcRemote'
 
 const logger = new Logger(module)
 
-export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends RpcRemote<IWebsocketConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,