@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/src/connection/connectivityChecker.ts

@@ -0,0 +1,102 @@
+import { Logger, RunAndRaceEventsReturnType, runAndRaceEvents3 } from '@streamr/utils'
+import { v4 } from 'uuid'
+import * as Err from '../helpers/errors'
+import {
+    ConnectivityRequest, ConnectivityResponse,
+    Message, MessageType, PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectionEvents, IConnection } from './IConnection'
+import { ClientWebsocket } from './websocket/ClientWebsocket'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
+
+const logger = new Logger(module)
+
+export const connectAsync = async ({ url, selfSigned, timeoutMs = 1000 }:
+    { url: string, selfSigned: boolean, timeoutMs?: number }
+): Promise<IConnection> => {
+    const socket = new ClientWebsocket()
+    let result: RunAndRaceEventsReturnType<ConnectionEvents>
+    try {
+        result = await runAndRaceEvents3<ConnectionEvents>([
+            () => { socket.connect(url, selfSigned) }],
+        socket, ['connected', 'error'],
+        timeoutMs)
+    } catch (e) {
+        throw new Err.ConnectionFailed('WebSocket connection timed out')
+    }
+    if (result.winnerName === 'error') {
+        throw new Err.ConnectionFailed('Could not open WebSocket connection')
+    }
+    return socket
+}
+
+export const CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
+const CONNECTIVITY_CHECKER_TIMEOUT = 5000
+
+export const sendConnectivityRequest = async (
+    request: ConnectivityRequest,
+    entryPoint: PeerDescriptor
+): Promise<ConnectivityResponse> => {
+    let outgoingConnection: IConnection
+    const wsServerInfo = {
+        host: entryPoint.websocket!.host, 
+        port: entryPoint.websocket!.port,
+        tls: entryPoint.websocket!.tls,
+    }
+    const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
+    logger.debug(`Attempting connectivity check with entrypoint ${url}`)
+    try {
+        outgoingConnection = await connectAsync({
+            url,
+            selfSigned: request.selfSigned
+        })
+    } catch (e) {
+        throw new Err.ConnectionFailed(`Failed to connect to entrypoint for connectivity check: ${url}`, e)
+    }
+    // send connectivity request
+    const msg: Message = {
+        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+        messageType: MessageType.CONNECTIVITY_REQUEST, messageId: v4(),
+        body: {
+            oneofKind: 'connectivityRequest',
+            connectivityRequest: request
+        }
+    }
+    const responseAwaiter = () => {
+        return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
+            const timeoutId = setTimeout(() => {
+                // TODO should we have some handling for this floating promise?
+                outgoingConnection.close(false)
+                reject(new Err.ConnectivityResponseTimeout('timeout'))
+            }, CONNECTIVITY_CHECKER_TIMEOUT)
+            const listener = (bytes: Uint8Array) => {
+                // TODO should we have some handling for this floating promise?
+                outgoingConnection.close(false)
+                try {
+                    const message: Message = Message.fromBinary(bytes)
+                    if (message.body.oneofKind === 'connectivityResponse') {
+                        logger.debug('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
+                        const connectivityResponseMessage = message.body.connectivityResponse
+                        outgoingConnection!.off('data', listener)
+                        clearTimeout(timeoutId)
+                        resolve(connectivityResponseMessage)
+                    } else {
+                        return
+                    }
+                } catch (err) {
+                    logger.trace(`Could not parse message: ${err}`)
+                }
+            }
+            outgoingConnection!.on('data', listener)
+        })
+    }
+    try {
+        const retPromise = responseAwaiter()
+        outgoingConnection.send(Message.toBinary(msg))
+        logger.trace('ConnectivityRequest sent: ' + JSON.stringify(Message.toJson(msg)))
+        return await retPromise
+    } catch (e) {
+        logger.error('error getting connectivityresponse')
+        throw e
+    }
+}

package/src/connection/connectivityRequestHandler.ts

@@ -0,0 +1,79 @@
+import { Logger } from '@streamr/utils'
+import { v4 } from 'uuid'
+import {
+    ConnectivityRequest, ConnectivityResponse,
+    Message, MessageType
+} from '../proto/packages/dht/protos/DhtRpc'
+import { NatType } from './ConnectionManager'
+import { CONNECTIVITY_CHECKER_SERVICE_ID, connectAsync } from './connectivityChecker'
+import { IConnection } from './IConnection'
+import { ServerWebsocket } from './websocket/ServerWebsocket'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
+
+const logger = new Logger(module)
+
+export const attachConnectivityRequestHandler = (connectionToListenTo: ServerWebsocket): void => {
+    connectionToListenTo.on('data', async (data: Uint8Array) => {
+        logger.trace('server received data')
+        try {
+            const message = Message.fromBinary(data)
+            if (message.body.oneofKind === 'connectivityRequest') {
+                logger.trace('ConnectivityRequest received: ' + JSON.stringify(Message.toJson(message)))
+                try {
+                    await handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest)
+                    logger.trace('handleIncomingConnectivityRequest ok')
+                } catch (e) {
+                    logger.error('handleIncomingConnectivityRequest', { error: e })
+                }
+            }
+        } catch (err) {
+            logger.trace(`Could not parse message: ${err}`)
+        }
+    })
+}
+
+const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, connectivityRequest: ConnectivityRequest): Promise<void> => {
+    let outgoingConnection: IConnection | undefined
+    let connectivityResponseMessage: ConnectivityResponse | undefined
+    const host = connectivityRequest.host ?? connection.getRemoteAddress()
+    try {
+        const wsServerInfo = {
+            host,
+            port: connectivityRequest.port,
+            tls: connectivityRequest.tls
+        }
+        const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityProbe')
+        logger.trace(`Attempting Connectivity Check to ${url}`)
+        outgoingConnection = await connectAsync({
+            url,
+            selfSigned: connectivityRequest.selfSigned
+        })
+    } catch (err) {
+        logger.debug('error', { err })
+        connectivityResponseMessage = {
+            host,
+            natType: NatType.UNKNOWN
+        }
+    }
+    if (outgoingConnection) {
+        // TODO should we have some handling for this floating promise?
+        outgoingConnection.close(false)
+        logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
+        connectivityResponseMessage = {
+            host,
+            natType: NatType.OPEN_INTERNET,
+            websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls }
+        }
+    }
+    const msg: Message = {
+        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+        messageType: MessageType.CONNECTIVITY_RESPONSE,
+        messageId: v4(),
+        body: {
+            oneofKind: 'connectivityResponse',
+            connectivityResponse: connectivityResponseMessage!
+        }
+    }
+    connection.send(Message.toBinary(msg))
+    logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
+}

package/src/connection/simulator/Simulator.ts

@@ -148,7 +148,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
             this.latencyTable = getRegionDelayMatrix()
         }
 
-        if (this.latencyType === LatencyType.FIXED && !this.fixedLatency) {
+        if ((this.latencyType === LatencyType.FIXED) && (this.fixedLatency === undefined)) {
             throw new Error('LatencyType.FIXED requires the desired latency to be given as second parameter')
         }
 
@@ -185,7 +185,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
 
             if (sourceRegion === undefined || targetRegion === undefined || sourceRegion > 15 || targetRegion > 15) {
                 logger.error('invalid region index given to Simulator')
-                throw ('invalid region index given to Simulator')
+                throw new Error('invalid region index given to Simulator')
             }
 
             latency = this.latencyTable![sourceRegion][targetRegion]
@@ -313,6 +313,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
        
         if (Simulator.clock) {
+            // TODO should we have some handling for this floating promise?
             Simulator.clock.runAllAsync()
         }
     }

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

@@ -8,6 +8,9 @@ const logger = new Logger(module)
 // https://kapeli.com/cheat_sheets/WebSocket_Status_Codes.docset/Contents/Resources/Documents/index
 // Browsers send this automatically when closing a tab
 export const GOING_AWAY = 1001
+// The GOING_AWAY is a reserved code and we shouldn't send that from the application. Therefore
+// we have a custom counterpart
+export const CUSTOM_GOING_AWAY = 3001
 
 const BINARY_TYPE = 'arraybuffer'
 
@@ -23,6 +26,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 })
@@ -68,7 +72,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.destroyed = true
         this.stopListening()
         this.socket = undefined
-        const gracefulLeave = code === GOING_AWAY
+        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
         this.emit('disconnected', gracefulLeave, code, reason)
         this.removeAllListeners()
     }
@@ -91,7 +95,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.removeAllListeners()
         if (!this.destroyed) {
             logger.trace(`Closing socket for connection ${this.connectionId.toString()}`)
-            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
+            this.socket?.close(gracefulLeave ? CUSTOM_GOING_AWAY : undefined)
         } else {
             logger.debug('Tried to close() a stopped connection')
         }

package/src/connection/websocket/ServerWebsocket.ts

@@ -1,9 +1,9 @@
 import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
-import { connection as WsConnection } from 'websocket'
+import { Message, connection as WsConnection } from 'websocket'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
-import { GOING_AWAY } from './ClientWebsocket'
+import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
 
 const logger = new Logger(module)
 
@@ -29,37 +29,52 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     constructor(socket: WsConnection, resourceURL: Url) {
         super()
 
+        this.onMessage = this.onMessage.bind(this)
+        this.onClose = this.onClose.bind(this)
+        this.onError = this.onError.bind(this)
+
         this.resourceURL = resourceURL
         this.connectionId = new ConnectionID()
 
-        socket.on('message', (message) => {
-            logger.trace('ServerWebsocket::onMessage')
-            if (message.type === MessageType.UTF8) {
-                logger.debug('Received string Message: ' + message.utf8Data)
-            } else if (message.type === MessageType.BINARY) {
-                logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
-                this.emit('data',
-                    new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
-                        message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
-            }
-        })
-        socket.on('close', (reasonCode, description) => {
-            logger.trace('Peer ' + socket.remoteAddress + ' disconnected.')            
-            this.doDisconnect(reasonCode, description)
-        })
-
-        socket.on('error', (error) => {
-            this.emit('error', error.name)
-        })
+        socket.on('message', this.onMessage)
+        socket.on('close', this.onClose)
+        socket.on('error', this.onError)
 
         this.socket = socket
     }
 
+    private onMessage(message: Message): void {
+        logger.trace('ServerWebsocket::onMessage')
+        if (message.type === MessageType.UTF8) {
+            logger.debug('Received string Message: ' + message.utf8Data)
+        } else if (message.type === MessageType.BINARY) {
+            logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
+            this.emit('data',
+                new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
+                    message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
+        }
+    }
+
+    private onClose(reasonCode: number, description: string): void {
+        logger.trace('Peer ' + this.socket?.remoteAddress + ' disconnected.')
+        this.doDisconnect(reasonCode, description)
+    }
+
+    private onError(error: Error): void {
+        this.emit('error', error.name)
+    }
+
+    private stopListening(): void {
+        this.socket?.off('message', this.onMessage)
+        this.socket?.off('close', this.onClose)
+        this.socket?.off('error', this.onError)
+    }
+
     private doDisconnect(reasonCode: number, description: string): void {
         this.stopped = true
-        this.socket?.removeAllListeners()
+        this.stopListening()
         this.socket = undefined
-        const gracefulLeave = reasonCode === GOING_AWAY
+        const gracefulLeave = (reasonCode === GOING_AWAY) || (reasonCode === CUSTOM_GOING_AWAY)
         this.emit('disconnected', gracefulLeave, reasonCode, description)
     }
 
@@ -83,7 +98,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.emit('disconnected', gracefulLeave, undefined, 'close() called')
         this.removeAllListeners()
         if (!this.stopped) {
-            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
+            this.socket?.close(gracefulLeave ? GOING_AWAY : undefined)
         } else {
             logger.debug('Tried to close a stopped connection')
         }
@@ -93,7 +108,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         if (!this.stopped) {
             this.removeAllListeners()
             if (this.socket) {
-                this.socket.removeAllListeners()
+                this.stopListening()
                 this.socket.close()
                 this.socket = undefined
             }