@streamr/dht 0.0.1-tatum.0

package/src/connection/ConnectivityChecker.ts

@@ -0,0 +1,173 @@
+import {
+    ConnectivityRequest, ConnectivityResponse,
+    Message, MessageType, PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectionEvents, IConnection } from './IConnection'
+import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
+import * as Err from '../helpers/errors'
+import { ClientWebSocket } from './WebSocket/ClientWebSocket'
+import { v4 } from 'uuid'
+import { NatType } from './ConnectionManager'
+import { ServerWebSocket } from './WebSocket/ServerWebSocket'
+
+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
+// ConnectivityRequest messages. 
+
+export enum ConnectionMode { REQUEST = 'connectivityRequest', PROBE = 'connectivityProbe' }
+export class ConnectivityChecker {
+
+    private static readonly CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivitychecker'
+    private static readonly CONNECTIVITY_CHECKER_TIMEOUT = 5000
+    private stopped = false
+    private webSocketPort?: number
+
+    constructor(webSocketPort?: number) {
+        this.webSocketPort = webSocketPort
+    }
+
+    public async sendConnectivityRequest(entryPoint: PeerDescriptor): Promise<ConnectivityResponse> {
+        let outgoingConnection: IConnection
+        try {
+            outgoingConnection = await this.connectAsync({
+                host: entryPoint.websocket?.ip, port: entryPoint.websocket?.port, timeoutMs: 1000,
+                mode: ConnectionMode.REQUEST
+            })
+        } catch (e) {
+            logger.error('Failed to connect to the entrypoints')
+            throw new Err.ConnectionFailed('Failed to connect to the entrypoints', e)
+        }
+        // send connectivity request
+        const connectivityRequestMessage: ConnectivityRequest = { port: this.webSocketPort! }
+        const msg: Message = {
+            serviceId: ConnectivityChecker.CONNECTIVITY_CHECKER_SERVICE_ID,
+            messageType: MessageType.CONNECTIVITY_REQUEST, messageId: v4(),
+            body: {
+                oneofKind: 'connectivityRequest',
+                connectivityRequest: connectivityRequestMessage
+            }
+        }
+        const responseAwaiter = () => {
+            return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
+                const timeoutId = setTimeout(() => {
+                    outgoingConnection.close('OTHER')
+                    reject(new Err.ConnectivityResponseTimeout('timeout'))
+                }, ConnectivityChecker.CONNECTIVITY_CHECKER_TIMEOUT)
+                const listener = (bytes: Uint8Array) => {
+                    outgoingConnection.close('OTHER')
+                    const message: Message = Message.fromBinary(bytes)
+                    if (message.body.oneofKind === 'connectivityResponse') {
+                        const connectivityResponseMessage = message.body.connectivityResponse
+                        outgoingConnection!.off('data', listener)
+                        clearTimeout(timeoutId)
+                        resolve(connectivityResponseMessage)
+                    } else {
+                        return
+                    }
+                }
+                outgoingConnection!.on('data', listener)
+            })
+        }
+        try {
+            const retPromise = responseAwaiter()
+            logger.trace('trying to send connectivity request')
+            outgoingConnection.send(Message.toBinary(msg))
+            logger.debug('connectivity request sent: ' + JSON.stringify(Message.toJson(msg)))
+            return await retPromise
+        } catch (e) {
+            logger.error('error getting connectivityresponse')
+            throw e
+        }
+    }
+
+    public listenToIncomingConnectivityRequests(connectionToListenTo: ServerWebSocket): void {
+        connectionToListenTo.on('data', (data: Uint8Array) => {
+            logger.trace('server received data')
+            const message = Message.fromBinary(data)
+            if (message.body.oneofKind === 'connectivityRequest') {
+                logger.trace('received connectivity request')
+                this.handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest).then(() => {
+                    logger.trace('handleIncomingConnectivityRequest ok')
+                    return
+                }).catch((e) => {
+                    logger.error('handleIncomingConnectivityRequest' + e)
+                })
+            }
+        })
+    }
+
+    private async handleIncomingConnectivityRequest(
+        connection: ServerWebSocket,
+        connectivityRequest: ConnectivityRequest
+    ): Promise<void> {
+        if (this.stopped) {
+            return
+        }
+        let outgoingConnection: IConnection | undefined
+        let connectivityResponseMessage: ConnectivityResponse | undefined
+        try {
+            outgoingConnection = await this.connectAsync({
+                host: connection.getRemoteAddress(),
+                port: connectivityRequest.port, timeoutMs: 1000, mode: ConnectionMode.PROBE
+            })
+        } catch (err) {
+            logger.debug('error', { err })
+            connectivityResponseMessage = {
+                openInternet: false,
+                ip: (connection as ServerWebSocket).getRemoteAddress(),
+                natType: NatType.UNKNOWN
+            }
+        }
+        if (outgoingConnection) {
+            outgoingConnection.close('OTHER')
+            logger.trace('Connectivity test produced positive result, communicating reply to the requester')
+            connectivityResponseMessage = {
+                openInternet: true,
+                ip: (connection as ServerWebSocket).getRemoteAddress(),
+                natType: NatType.OPEN_INTERNET,
+                websocket: { ip: (connection as ServerWebSocket).getRemoteAddress(), port: connectivityRequest.port }
+            }
+        }
+        const msg: Message = {
+            serviceId: ConnectivityChecker.CONNECTIVITY_CHECKER_SERVICE_ID,
+            messageType: MessageType.CONNECTIVITY_RESPONSE, messageId: v4(),
+            body: {
+                oneofKind: 'connectivityResponse',
+                connectivityResponse: connectivityResponseMessage!
+            }
+        }
+        connection.send(Message.toBinary(msg))
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    private async connectAsync({ host, port, url, timeoutMs, mode }:
+        { host?: string, port?: number, url?: string, timeoutMs: number, mode: ConnectionMode } =
+    { timeoutMs: 1000, mode: ConnectionMode.REQUEST }
+    ): Promise<IConnection> {
+        const socket = new ClientWebSocket()
+        let address = ''
+        if (url) {
+            address = url
+        } else if (host && port) {
+            address = 'ws://' + host + ':' + port
+        }
+
+        address += '?' + mode + '=true'
+
+        let result: RunAndRaceEventsReturnType<ConnectionEvents>
+        try {
+            result = await runAndRaceEvents3<ConnectionEvents>([
+                () => { socket.connect(address) }],
+            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
+    }
+}

package/src/connection/Handshaker.ts

@@ -0,0 +1,92 @@
+import { Logger } from '@streamr/utils'
+import { EventEmitter } from 'eventemitter3'
+import { v4 } from 'uuid'
+import { Message, HandshakeRequest, HandshakeResponse, MessageType, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { IConnection } from './IConnection'
+
+const logger = new Logger(module)
+
+interface HandshakerEvents {
+    handshakeRequest: (peerDescriptor: PeerDescriptor) => void
+    handshakeCompleted: (peerDescriptor: PeerDescriptor) => void
+    handshakeFailed: (reason?: string) => void
+}
+
+export class Handshaker extends EventEmitter<HandshakerEvents> {
+
+    private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
+    private ownPeerDescriptor: PeerDescriptor
+    private protocolVersion: string
+    private connection: IConnection
+
+    constructor(
+        ownPeerDescriptor: PeerDescriptor,
+        protocolVersion: string, 
+        connection: IConnection
+    ) {
+        super()
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.protocolVersion = protocolVersion
+        this.connection = connection
+        this.connection.on('data', this.onData)
+    }
+
+    private onData = (data: Uint8Array) => {
+        const message = Message.fromBinary(data)
+        if (message.body.oneofKind === 'handshakeRequest') {
+            logger.trace('handshake request received')
+            const handshake = message.body.handshakeRequest
+            this.emit('handshakeRequest', handshake.peerDescriptor!)
+        }
+        if (message.body.oneofKind === 'handshakeResponse') {
+            logger.trace('handshake response received')
+            const handshake = message.body.handshakeResponse
+            if (handshake.responseError) {
+                this.emit('handshakeFailed', handshake.responseError)
+            } else {
+                this.emit('handshakeCompleted', handshake.peerDescriptor!)
+            }
+        }
+    }
+
+    public sendHandshakeRequest(): void {
+        const outgoingHandshake: HandshakeRequest = {
+            sourceId: this.ownPeerDescriptor.kademliaId,
+            protocolVersion: this.protocolVersion,
+            peerDescriptor: this.ownPeerDescriptor
+        }
+        const msg: Message = {
+            serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
+            messageType: MessageType.HANDSHAKE_REQUEST,
+            messageId: v4(),
+            body: {
+                oneofKind: 'handshakeRequest',
+                handshakeRequest: outgoingHandshake
+            }
+        }
+        this.connection.send(Message.toBinary(msg))
+        logger.trace('handshake request sent')
+    }
+
+    public sendHandshakeResponse(error?: string): void {
+        const outgoingHandshakeResponse: HandshakeResponse = {
+            sourceId: this.ownPeerDescriptor.kademliaId,
+            protocolVersion: this.protocolVersion,
+            peerDescriptor: this.ownPeerDescriptor
+        }
+        if (error) {
+            outgoingHandshakeResponse.responseError = error
+        }
+        const msg: Message = {
+            serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
+            messageType: MessageType.HANDSHAKE_RESPONSE,
+            messageId: v4(),
+            body: {
+                oneofKind: 'handshakeResponse',
+                handshakeResponse: outgoingHandshakeResponse
+            }
+        }
+        this.connection.send(Message.toBinary(msg))
+        logger.trace('handshake request sent')
+    }
+}

package/src/connection/IConnection.ts

@@ -0,0 +1,47 @@
+import { UUID } from '../helpers/UUID'
+import { DisconnectionType } from '../transport/ITransport'
+
+export interface ConnectionEvents {
+    data: (bytes: Uint8Array) => void
+    connected: () => void
+    disconnected: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void 
+    error: (name: string) => void
+}
+
+export enum ConnectionType {
+    WEBSOCKET_SERVER = 'websocket-server',
+    WEBSOCKET_CLIENT = 'websocket-client',
+    WEBRTC = 'webrtc',
+    SIMULATOR_SERVER = 'simulator-server',
+    SIMULATOR_CLIENT = 'simulator-client',
+}
+
+export type ConnectionIDKey = string & { readonly __brand: 'connectionIDKey' } // Nominal typing 
+
+export class ConnectionID extends UUID {
+    toMapKey(): ConnectionIDKey {
+        return this.toString() as ConnectionIDKey
+    }
+}
+
+export interface IConnection {
+    
+    on(event: 'data', listener: (bytes: Uint8Array) => void): this
+    on(event: 'error', listener: (name: string) => void): this
+    on(event: 'connected', listener: () => void): this
+    on(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): this
+    
+    once(event: 'data', listener: (bytes: Uint8Array) => void): this
+    once(event: 'error', listener: (name: string) => void): this
+    once(event: 'connected', listener: () => void): this
+    once(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): this
+
+    off(event: 'data', listener: (bytes: Uint8Array) => void): void
+    off(event: 'error', listener: (name: string) => void): void
+    off(event: 'connected', listener: () => void): void
+    off(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): void
+    
+    send(data: Uint8Array): void
+    close(disconnectionType: DisconnectionType): Promise<void>
+    destroy(): void
+}

package/src/connection/IConnectionSource.ts

@@ -0,0 +1,6 @@
+import { IConnection } from './IConnection'
+
+export interface ConnectionSourceEvents {
+    connected: ((connection: IConnection) => void) 
+}
+