@streamr/dht 100.2.5-beta.1 → 101.0.0-beta.1

package/src/connection/ConnectorFacade.ts

@@ -5,18 +5,20 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 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, WebrtcConnector } from './webrtc/WebrtcConnector'
-import { WebsocketConnector, WebsocketConnectorConfig } from './websocket/WebsocketConnector'
+import { WebsocketClientConnector } from './websocket/WebsocketClientConnector'
 import { DhtAddress } from '../identifiers'
+import { WebsocketServerConnector, WebsocketServerConnectorOptions } from './websocket/WebsocketServerConnector'
+import { PendingConnection } from './PendingConnection'
+import { ListeningRpcCommunicator } from '../transport/ListeningRpcCommunicator'
 
 export interface ConnectorFacade {
-    createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
+    createConnection: (peerDescriptor: PeerDescriptor) => PendingConnection
     getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
-        onNewConnection: (connection: ManagedConnection) => boolean,
+        onNewConnection: (connection: PendingConnection) => boolean,
         hasConnection: (nodeId: DhtAddress) => boolean,
         autoCertifierTransport: ITransport
     ) => Promise<void>
@@ -26,7 +28,7 @@ export interface ConnectorFacade {
 const logger = new Logger(module)
 
 // TODO: Wrap component specific configs to their own objects.
-export interface DefaultConnectorFacadeConfig {
+export interface DefaultConnectorFacadeOptions {
     transport: ITransport
     websocketHost?: string
     websocketPortRange?: PortRange
@@ -35,7 +37,6 @@ export interface DefaultConnectorFacadeConfig {
     webrtcAllowPrivateAddresses?: boolean
     webrtcDatachannelBufferThresholdLow?: number
     webrtcDatachannelBufferThresholdHigh?: number
-    webrtcNewConnectionTimeout?: number
     externalIp?: string
     webrtcPortRange?: PortRange
     maxMessageSize?: number
@@ -50,76 +51,91 @@ export interface DefaultConnectorFacadeConfig {
 
 export class DefaultConnectorFacade implements ConnectorFacade {
 
-    private readonly config: DefaultConnectorFacadeConfig
+    private readonly options: DefaultConnectorFacadeOptions
     private localPeerDescriptor?: PeerDescriptor
-    private websocketConnector?: WebsocketConnector
+    private websocketConnectorRpcCommunicator?: ListeningRpcCommunicator
+    private websocketClientConnector?: WebsocketClientConnector
+    private websocketServerConnector?: WebsocketServerConnector
     private webrtcConnector?: WebrtcConnector
-    constructor(config: DefaultConnectorFacadeConfig) {
-        this.config = config
+    constructor(options: DefaultConnectorFacadeOptions) {
+        this.options = options
     }
 
     async start(
-        onNewConnection: (connection: ManagedConnection) => boolean,
+        onNewConnection: (connection: PendingConnection) => boolean,
         hasConnection: (nodeId: DhtAddress) => boolean,
         autoCertifierTransport: ITransport
     ): Promise<void> {
         logger.trace(`Creating WebsocketConnectorRpcLocal`)
-        const webSocketConnectorConfig = {
-            transport: this.config.transport,
+        this.websocketConnectorRpcCommunicator = new ListeningRpcCommunicator(
+            WebsocketClientConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, 
+            this.options.transport, 
+            { rpcRequestTimeout: 15000 }  // TODO use options option or named constant?
+        
+        )
+        const webSocketClientConnectorOptions = {
             // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
             onNewConnection,
             hasConnection,
-            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!,
+            rpcCommunicator: this.websocketConnectorRpcCommunicator
+        }
+        this.websocketClientConnector = new WebsocketClientConnector(webSocketClientConnectorOptions)
+
+        const webSocketServerConnectorOptions = {
+            rpcCommunicator: this.websocketConnectorRpcCommunicator,
+            // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
+            onNewConnection,
+            hasConnection,
+            portRange: this.options.websocketPortRange,
+            host: this.options.websocketHost,
+            entrypoints: this.options.entryPoints,
+            tlsCertificate: this.options.tlsCertificate,
+            serverEnableTls: this.options.websocketServerEnableTls!,
+            autoCertifierUrl: this.options.autoCertifierUrl!,
+            autoCertifierConfigFile: this.options.autoCertifierConfigFile!,
             autoCertifierTransport,
-            maxMessageSize: this.config.maxMessageSize,
-            geoIpDatabaseFolder: this.config.geoIpDatabaseFolder
+            maxMessageSize: this.options.maxMessageSize,
+            geoIpDatabaseFolder: this.options.geoIpDatabaseFolder
         }
-        this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
-        logger.trace(`Creating WebRtcConnectorRpcLocal`)
+        this.websocketServerConnector = new WebsocketServerConnector(webSocketServerConnectorOptions)
         this.webrtcConnector = new WebrtcConnector({
-            transport: this.config.transport,
-            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,
-            maxMessageSize: this.config.maxMessageSize
-        }, onNewConnection)
-        await this.websocketConnector.start()
+            onNewConnection,
+            transport: this.options.transport,
+            iceServers: this.options.iceServers,
+            allowPrivateAddresses: this.options.webrtcAllowPrivateAddresses,
+            bufferThresholdLow: this.options.webrtcDatachannelBufferThresholdLow,
+            bufferThresholdHigh: this.options.webrtcDatachannelBufferThresholdHigh,
+            externalIp: this.options.externalIp,
+            portRange: this.options.webrtcPortRange,
+            maxMessageSize: this.options.maxMessageSize
+        })
+        await this.websocketServerConnector.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
+        // function in the options. 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 = await this.config.createLocalPeerDescriptor(connectivityResponse)
+        const temporarilySelfSigned = (!this.options.tlsCertificate && this.options.websocketServerEnableTls === true)
+        const connectivityResponse = await this.websocketServerConnector.checkConnectivity(temporarilySelfSigned)
+        const localPeerDescriptor = await this.options.createLocalPeerDescriptor(connectivityResponse)
         this.setLocalPeerDescriptor(localPeerDescriptor)
-        if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
+        if (localPeerDescriptor.websocket && !this.options.tlsCertificate && this.options.websocketServerEnableTls) {
             try {
-                await this.websocketConnector.autoCertify()
-                const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
-                const autocertifiedLocalPeerDescriptor = await this.config.createLocalPeerDescriptor(connectivityResponse)
+                await this.websocketServerConnector.autoCertify()
+                const connectivityResponse = await this.websocketServerConnector.checkConnectivity(false)
+                const autocertifiedLocalPeerDescriptor = await this.options.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,
+                    await this.restartWebsocketServerConnector({
+                        ...webSocketServerConnectorOptions,
                         serverEnableTls: false
                     })
                 }
             } catch (err) {
                 logger.warn('Failed to auto-certify, disabling WebSocket server TLS', { err })
-                await this.restartWebsocketConnector({
-                    ...webSocketConnectorConfig,
+                await this.restartWebsocketServerConnector({
+                    ...webSocketServerConnectorOptions,
                     serverEnableTls: false
                 })
             }
@@ -128,24 +144,27 @@ export class DefaultConnectorFacade implements ConnectorFacade {
 
     private setLocalPeerDescriptor(peerDescriptor: PeerDescriptor) {
         this.localPeerDescriptor = peerDescriptor
-        this.websocketConnector!.setLocalPeerDescriptor(peerDescriptor)
+        this.websocketServerConnector!.setLocalPeerDescriptor(peerDescriptor)
+        this.websocketClientConnector!.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 = await this.config.createLocalPeerDescriptor(connectivityResponse)
+    async restartWebsocketServerConnector(options: WebsocketServerConnectorOptions): Promise<void> {
+        await this.websocketServerConnector!.destroy()
+        this.websocketServerConnector = new WebsocketServerConnector(options)
+        await this.websocketServerConnector.start()
+        const connectivityResponse = await this.websocketServerConnector.checkConnectivity(false)
+        const localPeerDescriptor = await this.options.createLocalPeerDescriptor(connectivityResponse)
         this.setLocalPeerDescriptor(localPeerDescriptor)
     }
 
-    createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
-        if (this.websocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
-            return this.websocketConnector!.connect(peerDescriptor)
+    createConnection(peerDescriptor: PeerDescriptor): PendingConnection {
+        if (this.websocketClientConnector!.isPossibleToFormConnection(peerDescriptor)) {
+            return this.websocketClientConnector!.connect(peerDescriptor)
+        } else if (this.websocketServerConnector!.isPossibleToFormConnection(peerDescriptor)) {
+            return this.websocketServerConnector!.connect(peerDescriptor)
         } else {
-            return this.webrtcConnector!.connect(peerDescriptor)
+            return this.webrtcConnector!.connect(peerDescriptor, false)
         }
     }
 
@@ -154,7 +173,9 @@ export class DefaultConnectorFacade implements ConnectorFacade {
     }
 
     async stop(): Promise<void> {
-        await this.websocketConnector!.destroy()
+        this.websocketConnectorRpcCommunicator!.destroy()
+        await this.websocketServerConnector!.destroy()
+        await this.websocketClientConnector!.destroy()
         await this.webrtcConnector!.stop()
     }
 }
@@ -170,7 +191,9 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
         this.simulator = simulator
     }
 
-    async start(onNewConnection: (connection: ManagedConnection) => boolean): Promise<void> {
+    async start(
+        onNewConnection: (connection: PendingConnection) => boolean,
+    ): Promise<void> {
         logger.trace(`Creating SimulatorConnector`)
         this.simulatorConnector = new SimulatorConnector(
             this.localPeerDescriptor,
@@ -180,7 +203,7 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
         this.simulator.addConnector(this.simulatorConnector)
     }
 
-    createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
+    createConnection(peerDescriptor: PeerDescriptor): PendingConnection {
         return this.simulatorConnector!.connect(peerDescriptor)
     }
 

package/src/connection/Handshaker.ts

@@ -4,6 +4,8 @@ import { v4 } from 'uuid'
 import { Message, HandshakeRequest, HandshakeResponse, PeerDescriptor, HandshakeError } from '../proto/packages/dht/protos/DhtRpc'
 import { IConnection } from './IConnection'
 import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../helpers/version'
+import { getNodeIdFromPeerDescriptor } from '../identifiers'
+import { PendingConnection } from './PendingConnection'
 
 const logger = new Logger(module)
 
@@ -13,9 +15,134 @@ interface HandshakerEvents {
     handshakeFailed: (error?: HandshakeError) => void
 }
 
+// Optimally the Outgoing and Incoming Handshakers could be their own separate classes
+// However, in cases where the PeerDescriptor of the other end of the connection can be known
+// only after a HandshakeRequest a base Handshaker class is needed as the IncomingHandshaker currently
+// requires knowledge of the other ends PeerDescriptor. (Note PendingConnection requires the remote PeerDescriptor)
+export const createOutgoingHandshaker = (
+    localPeerDescriptor: PeerDescriptor,
+    pendingConnection: PendingConnection,
+    connection: IConnection,
+    targetPeerDescriptor?: PeerDescriptor
+): Handshaker => {
+    const handshaker = new Handshaker(localPeerDescriptor, connection)
+    const stopHandshaker = () => {
+        handshaker.stop()
+        connection.off('disconnected', disconnectedListener)
+        connection.off('connected', connectedListener)
+        handshaker.off('handshakeCompleted', handshakeCompletedListener)
+        handshaker.off('handshakeFailed', handshakeFailedListener)
+        pendingConnection.off('disconnected', managedConnectionDisconnectedListener)
+    }
+    const handshakeFailedListener = (error?: HandshakeError) => {
+        if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR || error === HandshakeError.UNSUPPORTED_VERSION) {
+            pendingConnection.close(false)
+            stopHandshaker()
+        } else {
+            // Wait for the other end to close the connection
+        }
+    }
+    const handshakeCompletedListener = (peerDescriptor: PeerDescriptor) => {
+        logger.trace('handshake completed for outgoing connection, ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+        pendingConnection.onHandshakeCompleted(connection)
+        stopHandshaker()
+    }
+    const connectedListener = () => handshaker.sendHandshakeRequest(targetPeerDescriptor)
+    const disconnectedListener = (graceful: boolean) => { 
+        pendingConnection.close(graceful)
+        stopHandshaker()
+    }
+    const managedConnectionDisconnectedListener = () => {
+        connection.close(false)
+        stopHandshaker()
+    }
+    handshaker.once('handshakeFailed', handshakeFailedListener)
+    handshaker.once('handshakeCompleted', handshakeCompletedListener)
+    connection.once('connected', connectedListener)
+    connection.once('disconnected', disconnectedListener)
+    pendingConnection.once('disconnected', managedConnectionDisconnectedListener)
+    return handshaker
+}
+
+export const createIncomingHandshaker = (
+    localPeerDescriptor: PeerDescriptor,
+    pendingConnection: PendingConnection,
+    connection: IConnection
+): Handshaker => {
+    const handshaker = new Handshaker(localPeerDescriptor, connection)
+    const stopHandshaker = () => {
+        handshaker.stop()
+        pendingConnection.off('disconnected', connectionDisconnected)
+        connection.off('disconnected', connectionDisconnected)
+    }
+    const onHandshakeRequest = (): void => {
+        stopHandshaker()
+    }
+    const connectionDisconnected = (graceful: boolean) => {
+        pendingConnection.close(graceful)
+        stopHandshaker()
+    }
+    const managedConnectionDisconnected = () => {
+        connection.close(false)
+        stopHandshaker()
+    }
+    handshaker.on('handshakeRequest', onHandshakeRequest)
+    connection.once('disconnected', connectionDisconnected)
+    pendingConnection.once('disconnected', managedConnectionDisconnected)
+    return handshaker
+}
+
+export const rejectHandshake = (
+    pendingConnection: PendingConnection,
+    connection: IConnection,
+    handshaker: Handshaker,
+    error: HandshakeError
+): void => {
+    handshaker.sendHandshakeResponse(error)
+    connection.destroy()
+    pendingConnection.destroy()
+}
+
+export const acceptHandshake = (handshaker: Handshaker, pendingConnection: PendingConnection, connection: IConnection): void => {
+    handshaker.sendHandshakeResponse()
+    pendingConnection.onHandshakeCompleted(connection)
+}
+
+export const createHandshakeRequest = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): Message => {
+    const outgoingHandshake: HandshakeRequest = {
+        sourcePeerDescriptor: localPeerDescriptor,
+        targetPeerDescriptor: remotePeerDescriptor,
+        version: LOCAL_PROTOCOL_VERSION
+    }
+    return {
+        serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
+        messageId: v4(),
+        body: {
+            oneofKind: 'handshakeRequest',
+            handshakeRequest: outgoingHandshake
+        }
+    }
+} 
+
+export const createHandshakeResponse = (localPeerDescriptor: PeerDescriptor, error?: HandshakeError): Message => {
+    const outgoingHandshakeResponse: HandshakeResponse = {
+        sourcePeerDescriptor: localPeerDescriptor,
+        error,
+        version: LOCAL_PROTOCOL_VERSION
+    }
+    return {
+        serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
+        messageId: v4(),
+        body: {
+            oneofKind: 'handshakeResponse',
+            handshakeResponse: outgoingHandshakeResponse
+        }
+    }
+}
+
 export class Handshaker extends EventEmitter<HandshakerEvents> {
 
-    private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
+    public static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
     private localPeerDescriptor: PeerDescriptor
     private connection: IConnection
     private readonly onDataListener: (data: Uint8Array) => void
@@ -60,42 +187,19 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     }
 
     public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {
-        const outgoingHandshake: HandshakeRequest = {
-            sourcePeerDescriptor: this.localPeerDescriptor,
-            targetPeerDescriptor: remotePeerDescriptor,
-            version: LOCAL_PROTOCOL_VERSION
-        }
-        const msg: Message = {
-            serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-            messageId: v4(),
-            body: {
-                oneofKind: 'handshakeRequest',
-                handshakeRequest: outgoingHandshake
-            }
-        }
+        const msg = createHandshakeRequest(this.localPeerDescriptor, remotePeerDescriptor!)
         this.connection.send(Message.toBinary(msg))
         logger.trace('handshake request sent')
     }
 
     public sendHandshakeResponse(error?: HandshakeError): void {
-        const outgoingHandshakeResponse: HandshakeResponse = {
-            sourcePeerDescriptor: this.localPeerDescriptor,
-            error,
-            version: LOCAL_PROTOCOL_VERSION
-        }
-        const msg: Message = {
-            serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-            messageId: v4(),
-            body: {
-                oneofKind: 'handshakeResponse',
-                handshakeResponse: outgoingHandshakeResponse
-            }
-        }
+        const msg = createHandshakeResponse(this.localPeerDescriptor, error)
         this.connection.send(Message.toBinary(msg))
         logger.trace('handshake response sent')
     }
 
     public stop(): void {
         this.connection.off('data', this.onDataListener)
+        this.removeAllListeners()
     }
 }