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

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -0,0 +1,132 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { Logger } from '@streamr/utils'
+import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
+import { PeerIDKey } from '../../helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { Empty } from '../../proto/google/protobuf/empty'
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IWebrtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { ManagedConnection } from '../ManagedConnection'
+import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
+import { NodeWebrtcConnection } from './NodeWebrtcConnection'
+import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
+
+const logger = new Logger(module)
+
+interface WebrtcConnectorRpcLocalConfig {
+    connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
+    onIncomingConnection: (connection: ManagedConnection) => boolean
+    // TODO pass accessor methods instead of passing a mutable entity
+    ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection>
+    rpcCommunicator: ListeningRpcCommunicator
+    getLocalPeerDescriptor: () => PeerDescriptor
+    allowPrivateAddresses: boolean
+}
+
+export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
+
+    private readonly config: WebrtcConnectorRpcLocalConfig
+
+    constructor(config: WebrtcConnectorRpcLocalConfig) {
+        this.config = config
+    }
+
+    async requestConnection(context: ServerCallContext): Promise<Empty> {
+        const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        if (this.config.ongoingConnectAttempts.has(keyFromPeerDescriptor(targetPeerDescriptor))) {
+            return {}
+        }
+        const managedConnection = this.config.connect(targetPeerDescriptor)
+        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+        this.config.onIncomingConnection(managedConnection)
+        return {}
+    }
+
+    async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
+        const remotePeer = (context as DhtCallContext).incomingSourceDescriptor!
+        const peerKey = keyFromPeerDescriptor(remotePeer)
+        let managedConnection = this.config.ongoingConnectAttempts.get(peerKey)
+        let connection = managedConnection?.getWebrtcConnection()
+
+        if (!managedConnection) {
+            connection = new NodeWebrtcConnection({ remotePeerDescriptor: remotePeer })
+            managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
+            managedConnection.setPeerDescriptor(remotePeer)
+            this.config.ongoingConnectAttempts.set(peerKey, managedConnection)
+            this.config.onIncomingConnection(managedConnection)
+            const remoteConnector = new WebrtcConnectorRpcRemote(
+                this.config.getLocalPeerDescriptor(),
+                remotePeer,
+                toProtoRpcClient(new WebrtcConnectorRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            )
+            connection.on('localCandidate', (candidate: string, mid: string) => {
+                remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
+            })
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcAnswer(description, connection!.connectionId.toString())
+            })
+            connection.start(false)
+        }
+
+        // Always use offerers connectionId
+        connection!.setConnectionId(request.connectionId)
+        connection!.setRemoteDescription(request.description, 'offer')
+
+        managedConnection.on('handshakeRequest', () => {
+            if (this.config.ongoingConnectAttempts.has(peerKey)) {
+                this.config.ongoingConnectAttempts.delete(peerKey)
+            }
+            managedConnection!.acceptHandshake()
+        })
+        return {}
+    }
+
+    async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
+        const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
+        if (!connection) {
+            return {}
+        } else if (connection.connectionId.toString() !== request.connectionId) {
+            logger.trace(`Ignoring RTC answer due to connectionId mismatch`)
+            return {}
+        }
+        connection.setRemoteDescription(request.description, 'answer')
+        return {}
+    }
+
+    async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
+        const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
+
+        if (!connection) {
+            return {}
+        } else if (connection.connectionId.toString() !== request.connectionId) {
+            logger.trace(`Ignoring remote candidate due to connectionId mismatch`)
+            return {}
+        } else if (this.isIceCandidateAllowed(request.candidate)) {
+            connection.addRemoteCandidate(request.candidate, request.mid)
+        }
+        return {}
+    }
+
+    private isIceCandidateAllowed(candidate: string): boolean {
+        if (!this.config.allowPrivateAddresses) {
+            const address = getAddressFromIceCandidate(candidate)
+            if (address && isPrivateIPv4(address)) {
+                return false
+            }
+        }
+        return true
+    }
+}

package/src/connection/{WebRTC/WebRtcConnectorRpcRemote.ts → webrtc/WebrtcConnectorRpcRemote.ts}

@@ -4,27 +4,26 @@ import {
     PeerDescriptor,
     RtcAnswer,
     RtcOffer,
-    WebRtcConnectionRequest
+    WebrtcConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebRtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IWebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
 
-export class WebRtcConnectorRpcRemote extends Remote<IWebRtcConnectorRpcClient> {
+export class WebrtcConnectorRpcRemote extends Remote<IWebrtcConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebRtcConnectorRpcClient>
+        client: ProtoRpcClient<IWebrtcConnectorRpcClient>
     ) {
         super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
-    requestConnection(connectionId: string): void {
-        const request: WebRtcConnectionRequest = {
-            connectionId
+    requestConnection(): void {
+        const request: WebrtcConnectionRequest = {
         }
         const options = this.formDhtRpcOptions({
             notification: true

package/src/connection/{WebRTC → webrtc}/iceServerAsString.ts

@@ -1,4 +1,4 @@
-import { IceServer } from './WebRtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnector'
 
 export function iceServerAsString({ url, port, username, password, tcp }: IceServer): string {
     const [protocol, hostname] = url.split(':')

package/src/connection/websocket/AutoCertifierClientFacade.ts

@@ -0,0 +1,91 @@
+import {
+    AutoCertifierClient,
+    HasSessionRequest,
+    HasSessionResponse, 
+    CertifiedSubdomain,
+    SERVICE_ID as AUTO_CERTIFIER_SERVICE_ID,
+    HasSession
+} from '@streamr/autocertifier-client'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { Logger, waitForEvent3 } from '@streamr/utils'
+import { ITransport } from '../../transport/ITransport' 
+
+const START_TIMEOUT = 60 * 1000
+
+const defaultAutoCertifierClientFactory = (
+    configFile: string,
+    autoCertifierUrl: string,
+    autoCertifierRpcCommunicator: ListeningRpcCommunicator,
+    wsServerPort: number
+) => new AutoCertifierClient(
+    configFile,
+    wsServerPort,
+    autoCertifierUrl, 
+    (_serviceId: string, rpcMethodName: string, method: HasSession) => {
+        autoCertifierRpcCommunicator.registerRpcMethod(
+            HasSessionRequest,
+            HasSessionResponse,
+            rpcMethodName,
+            method
+        )                       
+    }
+)
+
+export interface IAutoCertifierClient {
+    start(): Promise<void>
+    stop(): void
+    on(eventName: string, cb: (subdomain: CertifiedSubdomain) => void): void
+}
+
+interface AutoCertifierClientFacadeConfig {
+    url: string
+    configFile: string
+    transport: ITransport
+    wsServerPort: number
+    // TODO: setHost and updateCertificate could be passed in a single onCertificateUpdated function.
+    setHost: (host: string) => void
+    updateCertificate: (certificate: string, privateKey: string) => void
+    // TOD: could just pass the client?
+    createClientFactory?: () => IAutoCertifierClient
+}
+
+const logger = new Logger(module)
+
+export class AutoCertifierClientFacade {
+
+    private autoCertifierClient: IAutoCertifierClient
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+    private readonly setHost: (host: string) => void
+    private readonly updateCertificate: (certificate: string, privateKey: string) => void
+
+    constructor(config: AutoCertifierClientFacadeConfig) {
+        this.setHost = config.setHost
+        this.updateCertificate = config.updateCertificate
+        this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, config.transport)
+        this.autoCertifierClient = config.createClientFactory ? config.createClientFactory() 
+            : defaultAutoCertifierClientFactory(
+                config.configFile,
+                config.url,
+                this.rpcCommunicator,
+                config.wsServerPort
+            )
+    }
+
+    async start(): Promise<void> {
+        this.autoCertifierClient.on('updatedCertificate', (subdomain: CertifiedSubdomain) => {
+            this.setHost(subdomain.fqdn)
+            this.updateCertificate(subdomain.certificate, subdomain.privateKey)
+            logger.trace(`Updated certificate`)
+        })
+        await Promise.all([
+            waitForEvent3(this.autoCertifierClient as any, 'updatedCertificate', START_TIMEOUT),
+            this.autoCertifierClient.start()
+        ])
+    }
+
+    stop(): void {
+        this.autoCertifierClient.stop()
+        this.rpcCommunicator.destroy()
+    }
+
+}

package/src/connection/{WebSocket/ClientWebSocket.ts → websocket/ClientWebsocket.ts}

@@ -1,16 +1,19 @@
-import { IConnection, ConnectionID, ConnectionType, ConnectionEvents } from '../IConnection'
-import { w3cwebsocket as WebSocket, ICloseEvent, IMessageEvent } from 'websocket'
-import EventEmitter from 'eventemitter3'
 import { Logger } from '@streamr/utils'
-import { DisconnectionType } from '../../transport/ITransport'
+import EventEmitter from 'eventemitter3'
+import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
+import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
 
 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
+
 const BINARY_TYPE = 'arraybuffer'
 
-export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
     public readonly connectionId: ConnectionID
-    private socket?: WebSocket
+    private socket?: Websocket
     public connectionType = ConnectionType.WEBSOCKET_CLIENT
 
     private destroyed = false
@@ -20,14 +23,13 @@ export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements I
         this.connectionId = new ConnectionID()
     }
 
-    public connect(address: string): void {
+    public connect(address: string, selfSigned?: boolean): void {
         if (!this.destroyed) {
-            this.socket = new WebSocket(address)
+            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
             this.socket.binaryType = BINARY_TYPE
-
             this.socket.onerror = (error: Error) => {
                 if (!this.destroyed) {
-                    logger.trace('WebSocket Client error: ' + error)
+                    logger.trace('WebSocket Client error: ' + error?.message, { error })
                     this.emit('error', error.name)
                 }
             }
@@ -44,7 +46,7 @@ export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements I
             this.socket.onclose = (event: ICloseEvent) => {
                 if (!this.destroyed) {
                     logger.trace('Websocket Closed')
-                    this.doDisconnect('OTHER', event.code, event.reason)
+                    this.doDisconnect(event.code, event.reason)
                 }
             }
 
@@ -62,12 +64,12 @@ export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements I
         }
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType, code?: number, reason?: string) {
+    private doDisconnect(code?: number, reason?: string) {
         this.destroyed = true
         this.stopListening()
         this.socket = undefined
-
-        this.emit('disconnected', disconnectionType, code, reason)
+        const gracefulLeave = code === GOING_AWAY
+        this.emit('disconnected', gracefulLeave, code, reason)
         this.removeAllListeners()
     }
 
@@ -77,17 +79,17 @@ export class ClientWebSocket extends EventEmitter<ConnectionEvents> implements I
                 logger.trace(`Sending data with size ${data.byteLength}`)
                 this.socket?.send(data.buffer)
             } else {
-                logger.warn('Tried to send data on a non-open connection')
+                logger.debug('Tried to send data on a non-open connection')
             }
         } else {
             logger.debug('Tried to send() on stopped connection')
         }
     }
 
-    public async close(): Promise<void> {
+    public async close(gracefulLeave: boolean): Promise<void> {
         if (!this.destroyed) {
             logger.trace(`Closing socket for connection ${this.connectionId.toString()}`)
-            this.socket?.close()
+            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
         } else {
             logger.debug('Tried to close() a stopped connection')
         }

package/src/connection/{WebSocket/ServerWebSocket.ts → websocket/ServerWebsocket.ts}

@@ -2,8 +2,8 @@ import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { connection as WsConnection } from 'websocket'
 import { Logger } from '@streamr/utils'
-import { DisconnectionType } from '../../transport/ITransport'
 import { Url } from 'url'
+import { GOING_AWAY } from './ClientWebsocket'
 
 const logger = new Logger(module)
 
@@ -18,7 +18,7 @@ enum MessageType {
     BINARY = 'binary'
 }
 
-export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
     public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
@@ -33,40 +33,34 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
         this.connectionId = new ConnectionID()
 
         socket.on('message', (message) => {
-            if (!this.stopped) {
-                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))
-                }
+            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) => {
-            if (!this.stopped) {
-                logger.trace(' Peer ' + socket.remoteAddress + ' disconnected.')
-                this.doDisconnect('OTHER', reasonCode, description)
-            }
+            logger.trace('Peer ' + socket.remoteAddress + ' disconnected.')            
+            this.doDisconnect(reasonCode, description)
         })
 
         socket.on('error', (error) => {
-            if (!this.stopped) {
-                this.emit('error', error.name)
-            }
+            this.emit('error', error.name)
         })
 
         this.socket = socket
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType, reasonCode: number, description: string): void {
+    private doDisconnect(reasonCode: number, description: string): void {
         this.stopped = true
         this.socket?.removeAllListeners()
         this.socket = undefined
-
-        this.emit('disconnected', disconnectionType, reasonCode, description)
+        const gracefulLeave = reasonCode === GOING_AWAY
+        this.emit('disconnected', gracefulLeave, reasonCode, description)
     }
 
     public send(data: Uint8Array): void {
@@ -80,16 +74,16 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
                 this.socket.sendBytes(Buffer.from(data))
             }
         } else {
-            logger.error('Tried to call send() on a stopped socket')
+            logger.debug('Tried to call send() on a stopped socket')
         }
 
     }
 
-    public async close(): Promise<void> {
+    public async close(gracefulLeave: boolean): Promise<void> {
         if (!this.stopped) {
-            this.socket?.close()
+            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
         } else {
-            logger.error('Tried to close a stopped connection')
+            logger.debug('Tried to close a stopped connection')
         }
     }
 
@@ -103,7 +97,7 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
             }
             this.stopped = true
         } else {
-            logger.error('Tried to destroy() a stopped connection')
+            logger.debug('Tried to destroy() a stopped connection')
         }
     }