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

package/src/connection/ConnectivityChecker.ts

@@ -1,58 +1,58 @@
 import {
-    ConnectivityMethod,
     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 { 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' }
 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')
         }
         let outgoingConnection: IConnection
+        const wsServerInfo = {
+            host: entryPoint.websocket!.host, 
+            port: entryPoint.websocket!.port,
+            tls: entryPoint.websocket!.tls,
+        }
+        const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
         try {
             outgoingConnection = await this.connectAsync({
-                wsServerInfo: {
-                    host: entryPoint.websocket!.host, 
-                    port: entryPoint.websocket!.port,
-                    tls: entryPoint.websocket!.tls,
-                },
-                mode: ConnectionMode.REQUEST
+                url,
+                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 ${url}`, 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 +64,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 +98,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 +124,7 @@ export class ConnectivityChecker {
     }
 
     private async handleIncomingConnectivityRequest(
-        connection: ServerWebSocket,
+        connection: ServerWebsocket,
         connectivityRequest: ConnectivityRequest
     ): Promise<void> {
         if (this.destroyed) {
@@ -135,24 +139,23 @@ export class ConnectivityChecker {
                 port: connectivityRequest.port,
                 tls: connectivityRequest.tls
             }
-            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebSocketUrl(wsServerInfo)}`)
+            const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityProbe')
+            logger.trace(`Attempting Connectivity Check to ${url}`)
             outgoingConnection = await this.connectAsync({
-                wsServerInfo,
-                mode: ConnectionMode.PROBE
+                url,
+                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 +174,14 @@ 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({ url, selfSigned, timeoutMs = 1000, }:
+        { url: string, selfSigned: boolean, timeoutMs?: number }
     ): Promise<IConnection> {
-        const socket = new ClientWebSocket()
-        const url = `${connectivityMethodToWebSocketUrl(wsServerInfo)}?${mode}=true`
+        const socket = new ClientWebsocket()
         let result: RunAndRaceEventsReturnType<ConnectionEvents>
         try {
             result = await runAndRaceEvents3<ConnectionEvents>([
-                () => { socket.connect(url) }],
+                () => { socket.connect(url, selfSigned) }],
             socket, ['connected', 'error'],
             timeoutMs)
         } catch (e) {

package/src/connection/ConnectorFacade.ts

@@ -6,23 +6,25 @@ import {
 import { ITransport } from '../transport/ITransport'
 import { PortRange, TlsCertificate } from './ConnectionManager'
 import { ManagedConnection } from './ManagedConnection'
-import { Simulator } from './Simulator/Simulator'
-import { SimulatorConnector } from './Simulator/SimulatorConnector'
-import { IceServer, WebRtcConnectorRpcLocal } from './WebRTC/WebRtcConnectorRpcLocal'
-import { WebSocketConnectorRpcLocal } from './WebSocket/WebSocketConnectorRpcLocal'
+import { Simulator } from './simulator/Simulator'
+import { SimulatorConnector } from './simulator/SimulatorConnector'
+import { IceServer, WebrtcConnector } from './webrtc/WebrtcConnector'
+import { WebsocketConnector, WebsocketConnectorConfig } from './websocket/WebsocketConnector'
 
 export interface ConnectorFacade {
     createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
-    getOwnPeerDescriptor: () => PeerDescriptor | undefined
+    getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
-        onIncomingConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean,
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        autoCertifierTransport: ITransport
     ) => Promise<void>
     stop: () => Promise<void>
 }
 
 const logger = new Logger(module)
 
+// TODO: Wrap component specific configs to their own objects.
 export interface DefaultConnectorFacadeConfig {
     transport: ITransport
     websocketHost?: string
@@ -37,38 +39,47 @@ export interface DefaultConnectorFacadeConfig {
     webrtcPortRange?: PortRange
     maxMessageSize?: number
     tlsCertificate?: TlsCertificate
-    createOwnPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
+    websocketServerEnableTls?: boolean
+    autoCertifierUrl?: string
+    autoCertifierConfigFile?: string
+    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
 }
 
 export class DefaultConnectorFacade implements ConnectorFacade {
 
     private readonly config: DefaultConnectorFacadeConfig
-    private ownPeerDescriptor?: PeerDescriptor
-    private webSocketConnector?: WebSocketConnectorRpcLocal
-    private webrtcConnector?: WebRtcConnectorRpcLocal
+    private localPeerDescriptor?: PeerDescriptor
+    private websocketConnector?: WebsocketConnector
+    private webrtcConnector?: WebrtcConnector
 
     constructor(config: DefaultConnectorFacadeConfig) {
         this.config = config
     }
 
     async start(
-        onIncomingConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean,
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        autoCertifierTransport: ITransport
     ): Promise<void> {
-        logger.trace(`Creating WebSocketConnector`)
-        this.webSocketConnector = new WebSocketConnectorRpcLocal({
+        logger.trace(`Creating WebsocketConnectorRpcLocal`)
+        const webSocketConnectorConfig = {
             transport: this.config.transport!,
-            // TODO should we use canConnect also for WebRtcConnector? (NET-1142)
+            // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
             canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
-            onIncomingConnection,
+            onNewConnection,
             portRange: this.config.websocketPortRange,
             host: this.config.websocketHost,
             entrypoints: this.config.entryPoints,
             tlsCertificate: this.config.tlsCertificate,
+            serverEnableTls: this.config.websocketServerEnableTls!,
+            autoCertifierUrl: this.config.autoCertifierUrl!,
+            autoCertifierConfigFile: this.config.autoCertifierConfigFile!,
+            autoCertifierTransport,
             maxMessageSize: this.config.maxMessageSize
-        })
-        logger.trace(`Creating WebRTCConnector`)
-        this.webrtcConnector = new WebRtcConnectorRpcLocal({
+        }
+        this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
+        logger.trace(`Creating WebRtcConnectorRpcLocal`)
+        this.webrtcConnector = new WebrtcConnector({
             transport: this.config.transport!,
             iceServers: this.config.iceServers,
             allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
@@ -78,50 +89,90 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             externalIp: this.config.externalIp,
             portRange: this.config.webrtcPortRange,
             maxMessageSize: this.config.maxMessageSize
-        }, onIncomingConnection)
-        await this.webSocketConnector.start()
-        const connectivityResponse = await this.webSocketConnector.checkConnectivity()
-        const ownPeerDescriptor = this.config.createOwnPeerDescriptor(connectivityResponse)
-        this.ownPeerDescriptor = ownPeerDescriptor
-        this.webSocketConnector.setOwnPeerDescriptor(ownPeerDescriptor)
-        this.webrtcConnector.setOwnPeerDescriptor(ownPeerDescriptor)
+        }, onNewConnection)
+        await this.websocketConnector.start()
+        // TODO: generate a PeerDescriptor in a single function. Requires changes to the createOwnPeerDescriptor
+        // function in the config. Currently it's given by the DhtNode and it sets the PeerDescriptor for the
+        // DhtNode in each call. 
+        // LocalPeerDescriptor could be stored in one place and passed from there to the connectors
+        const temporarilySelfSigned = (!this.config.tlsCertificate && this.config.websocketServerEnableTls === true)
+        const connectivityResponse = await this.websocketConnector.checkConnectivity(temporarilySelfSigned)
+        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        this.setLocalPeerDescriptor(localPeerDescriptor)
+        if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
+            try {
+                await this.websocketConnector!.autoCertify()
+                const connectivityResponse = await this.websocketConnector!.checkConnectivity(false)
+                const autocertifiedLocalPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+                if (autocertifiedLocalPeerDescriptor.websocket !== undefined) {
+                    this.setLocalPeerDescriptor(autocertifiedLocalPeerDescriptor)
+                } else {
+                    logger.warn('Connectivity check failed after auto-certification, disabling WebSocket server TLS')
+                    await this.restartWebsocketConnector({
+                        ...webSocketConnectorConfig,
+                        serverEnableTls: false
+                    })
+                }
+            } catch (err) {
+                logger.warn('Failed to auto-certify, disabling WebSocket server TLS')
+                await this.restartWebsocketConnector({
+                    ...webSocketConnectorConfig,
+                    serverEnableTls: false
+                })
+            }
+        }
+    }
+
+    private setLocalPeerDescriptor(peerDescriptor: PeerDescriptor) {
+        this.localPeerDescriptor = peerDescriptor
+        this.websocketConnector!.setLocalPeerDescriptor(peerDescriptor)
+        this.webrtcConnector!.setLocalPeerDescriptor(peerDescriptor)
+    }
+    
+    async restartWebsocketConnector(webSocketConnectorConfig: WebsocketConnectorConfig): Promise<void> {
+        await this.websocketConnector!.destroy()
+        this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
+        await this.websocketConnector.start()
+        const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
+        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        this.setLocalPeerDescriptor(localPeerDescriptor)
     }
 
     createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
-        if (this.webSocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
-            return this.webSocketConnector!.connect(peerDescriptor)
+        if (this.websocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
+            return this.websocketConnector!.connect(peerDescriptor)
         } else {
             return this.webrtcConnector!.connect(peerDescriptor)
         }
     }
 
-    getOwnPeerDescriptor(): PeerDescriptor | undefined {
-        return this.ownPeerDescriptor
+    getLocalPeerDescriptor(): PeerDescriptor | undefined {
+        return this.localPeerDescriptor
     }
 
     async stop(): Promise<void> {
-        await this.webSocketConnector!.destroy()
+        await this.websocketConnector!.destroy()
         await this.webrtcConnector!.stop()
     }
 }
 
 export class SimulatorConnectorFacade implements ConnectorFacade {
 
-    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly localPeerDescriptor: PeerDescriptor
     private simulatorConnector?: SimulatorConnector
     private simulator: Simulator
 
-    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        this.ownPeerDescriptor = ownPeerDescriptor
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+        this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
     }
 
-    async start(onIncomingConnection: (connection: ManagedConnection) => boolean): Promise<void> {
+    async start(onNewConnection: (connection: ManagedConnection) => boolean): Promise<void> {
         logger.trace(`Creating SimulatorConnector`)
         this.simulatorConnector = new SimulatorConnector(
-            this.ownPeerDescriptor,
+            this.localPeerDescriptor,
             this.simulator,
-            onIncomingConnection
+            onNewConnection
         )
         this.simulator.addConnector(this.simulatorConnector)
     }
@@ -130,8 +181,8 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
         return this.simulatorConnector!.connect(peerDescriptor)
     }
 
-    getOwnPeerDescriptor(): PeerDescriptor {
-        return this.ownPeerDescriptor
+    getLocalPeerDescriptor(): PeerDescriptor {
+        return this.localPeerDescriptor
     }
 
     async stop(): Promise<void> {

package/src/connection/Handshaker.ts

@@ -1,48 +1,48 @@
 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 { Message, HandshakeRequest, HandshakeResponse, MessageType, PeerDescriptor, HandshakeError } 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
+    handshakeRequest: (source: PeerDescriptor, target?: PeerDescriptor) => void
+    handshakeCompleted: (remote: PeerDescriptor) => void
+    handshakeFailed: (error?: HandshakeError) => void
 }
 
 export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
-    private ownPeerDescriptor: PeerDescriptor
+    private localPeerDescriptor: PeerDescriptor
     private connection: IConnection
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         connection: IConnection
     ) {
         super()
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.connection = connection
-        this.connection.on('data', this.onData)
+        this.connection.on('data', (data: Uint8Array) => this.onData(data))
     }
 
-    private onData = (data: Uint8Array) => {
+    private onData(data: Uint8Array) {
         try {
             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!)
+                this.emit('handshakeRequest', handshake.sourcePeerDescriptor!, handshake.targetPeerDescriptor)
             }
             if (message.body.oneofKind === 'handshakeResponse') {
                 logger.trace('handshake response received')
                 const handshake = message.body.handshakeResponse
-                if (handshake.responseError) {
-                    this.emit('handshakeFailed', handshake.responseError)
+                if (handshake.error !== undefined) {
+                    this.emit('handshakeFailed', handshake.error)
                 } else {
-                    this.emit('handshakeCompleted', handshake.peerDescriptor!)
+                    this.emit('handshakeCompleted', handshake.sourcePeerDescriptor!)
                 }
             }
         } catch (err) {
@@ -51,10 +51,10 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         
     }
 
-    public sendHandshakeRequest(): void {
+    public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {
         const outgoingHandshake: HandshakeRequest = {
-            sourceId: this.ownPeerDescriptor.kademliaId,
-            peerDescriptor: this.ownPeerDescriptor
+            sourcePeerDescriptor: this.localPeerDescriptor,
+            targetPeerDescriptor: remotePeerDescriptor
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -69,13 +69,10 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         logger.trace('handshake request sent')
     }
 
-    public sendHandshakeResponse(error?: string): void {
+    public sendHandshakeResponse(error?: HandshakeError): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
-            sourceId: this.ownPeerDescriptor.kademliaId,
-            peerDescriptor: this.ownPeerDescriptor
-        }
-        if (error) {
-            outgoingHandshakeResponse.responseError = error
+            sourcePeerDescriptor: this.localPeerDescriptor,
+            error
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -87,6 +84,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
             }
         }
         this.connection.send(Message.toBinary(msg))
-        logger.trace('handshake request sent')
+        logger.trace('handshake response sent')
     }
 }

package/src/connection/IConnection.ts

@@ -1,10 +1,9 @@
 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 
+    disconnected: (gracefulLeave: boolean, code?: number, reason?: string) => void 
     error: (name: string) => void
 }
 
@@ -29,19 +28,19 @@ 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
+    on(event: 'disconnected', listener: (gracefulLeave: boolean, 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
+    once(event: 'disconnected', listener: (gracefulLeave: boolean, 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
+    off(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): void
     
     send(data: Uint8Array): void
-    close(disconnectionType: DisconnectionType): Promise<void>
+    close(gracefulLeave: boolean): Promise<void>
     destroy(): void
 }