@streamr/dht 0.0.1-tatum.0

package/src/connection/WebRTC/BrowserWebRtcConnection.ts

@@ -0,0 +1,227 @@
+import EventEmitter from 'eventemitter3'
+import { WebRtcConnectionEvents, IWebRtcConnection, RtcDescription } from './IWebRtcConnection'
+import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
+import { Logger } from '@streamr/utils'
+import { DisconnectionType } from '../../transport/ITransport'
+
+const logger = new Logger(module)
+
+export const WEB_RTC_CLEANUP = new class {
+    // eslint-disable-next-line class-methods-use-this
+    cleanUp(): void {
+    }
+}
+
+type Events = WebRtcConnectionEvents & ConnectionEvents
+
+export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRtcConnection, IConnection {
+
+    public connectionId: ConnectionID = new ConnectionID()
+    public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
+
+    // We need to keep track of connection state ourselves because
+    // RTCPeerConnection.connectionState is not supported on Firefox
+
+    private lastState: RTCPeerConnectionState = 'connecting'
+
+    private iceServers = []
+    private peerConnection?: RTCPeerConnection
+    private dataChannel?: RTCDataChannel
+    private makingOffer = false
+    private isOffering = false
+    private closed = false
+
+    public start(isOffering: boolean): void {
+        this.isOffering = isOffering
+        const urls: RTCIceServer[] = this.iceServers.map(({ url, port, username, password }) => ({
+            urls: `${url}:${port}`,
+            username,
+            credential: password
+        }))
+        this.peerConnection = new RTCPeerConnection({ iceServers: urls })
+
+        this.peerConnection.onicecandidate = (event) => {
+            if (event.candidate && event.candidate.sdpMid) {
+                this.emit('localCandidate', event.candidate.candidate, event.candidate.sdpMid)
+            }
+        }
+
+        this.peerConnection.onicegatheringstatechange = () => {
+            logger.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`)
+        }
+
+        if (isOffering) {
+            this.peerConnection.onnegotiationneeded = async () => {
+                try {
+                    if (this.peerConnection) {
+                        this.makingOffer = true
+                        try {
+                            await this.peerConnection.setLocalDescription()
+                        } catch (err) {
+                            logger.warn('error', { err })
+                        }
+                        if (this.peerConnection.localDescription) {
+                            this.emit('localDescription', this.peerConnection.localDescription?.sdp, this.peerConnection.localDescription?.type)
+                        }
+                    }
+                } catch (err) {
+                    logger.error('error', { err })
+                } finally {
+                    this.makingOffer = false
+                }
+            }
+
+            const dataChannel = this.peerConnection.createDataChannel('streamrDataChannel')
+            this.setupDataChannel(dataChannel)
+        } else {
+            this.peerConnection.ondatachannel = (event) => {
+                this.setupDataChannel(event.channel)
+                logger.trace('connection.onDataChannel')
+                this.openDataChannel(event.channel)
+            }
+        }
+    }
+
+    public async setRemoteDescription(description: string, type: string): Promise<void> {
+        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || !this.peerConnection ||
+            this.peerConnection.signalingState != 'stable')
+
+        const ignoreOffer = this.isOffering && offerCollision
+        if (ignoreOffer) {
+            return
+        }
+        try {
+            await this.peerConnection?.setRemoteDescription({ sdp: description, type: type.toLowerCase() as RTCSdpType })
+        } catch (err) {
+            logger.warn('error', { err })
+        }
+
+        if (type.toLowerCase() === RtcDescription.OFFER && this.peerConnection) {
+            try {
+                await this.peerConnection.setLocalDescription()
+            } catch (err) {
+                logger.warn('error', { err })
+            }
+            if (this.peerConnection.localDescription) {
+                this.emit('localDescription', this.peerConnection.localDescription.sdp, this.peerConnection.localDescription.type)
+            }
+        }
+    }
+
+    public addRemoteCandidate(candidate: string, mid: string): void {
+        try {
+            this.peerConnection?.addIceCandidate({ candidate: candidate, sdpMid: mid }).then(() => { return }).catch((err: any) => {
+                logger.warn('error', { err })
+            })
+        } catch (err) {
+            logger.warn('error', { err })
+        }
+    }
+
+    public isOpen(): boolean {
+        return this.lastState === 'connected'
+    }
+
+    // IConnection implementation
+    
+    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
+        this.doClose(disconnectionType, reason)
+    }
+    
+    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+        if (!this.closed) {
+            this.closed = true
+            this.lastState = 'closed'
+
+            this.stopListening()
+            this.emit('disconnected', disconnectionType, undefined, reason)
+            
+            this.removeAllListeners()
+
+            if (this.dataChannel) {
+                try {
+                    this.dataChannel.close()
+                } catch (e) {
+                    logger.warn(`dc.close() errored: ${e}`)
+                }
+            }
+
+            this.dataChannel = undefined
+
+            if (this.peerConnection) {
+                try {
+                    this.peerConnection.close()
+                } catch (e) {
+                    logger.warn(`conn.close() errored: ${e}`)
+                }
+            }
+            this.peerConnection = undefined
+            
+        }
+    }
+
+    public destroy(): void {
+        this.removeAllListeners()
+        this.doClose('OTHER')
+    }
+
+    public send(data: Uint8Array): void {
+        if (this.lastState === 'connected') {
+            this.dataChannel?.send(data as Buffer)
+        } else {
+            logger.warn('Tried to send on a connection with last state ' + this.lastState)
+        }
+    }
+
+    private setupDataChannel(dataChannel: RTCDataChannel): void {
+        dataChannel.onopen = () => {
+            logger.trace('dc.onOpen')
+            this.openDataChannel(dataChannel)
+        }
+
+        dataChannel.onclose = () => {
+            logger.trace('dc.onClosed')
+            this.doClose('OTHER')
+        }
+
+        dataChannel.onerror = (err) => {
+            logger.warn(`dc.onError: ${err}`)
+        }
+
+        dataChannel.onbufferedamountlow = () => {
+            //this.emitLowBackpressure()
+        }
+
+        dataChannel.onmessage = (msg) => {
+            logger.trace('dc.onmessage')
+            this.emit('data', new Uint8Array(msg.data))
+        }
+    }
+
+    private stopListening() {
+        if (this.dataChannel) {
+            this.dataChannel.onopen = null
+            this.dataChannel.onclose = null
+            this.dataChannel.onerror = null
+            this.dataChannel.onbufferedamountlow = null
+            this.dataChannel.onmessage = null
+        }
+
+        if (this.peerConnection) {
+            this.peerConnection.onicecandidate = null
+            this.peerConnection.onicegatheringstatechange = null
+            this.peerConnection.onnegotiationneeded = null
+            this.peerConnection.ondatachannel = null
+        }
+    }
+
+    private openDataChannel(dataChannel: RTCDataChannel): void {
+        this.dataChannel = dataChannel
+        this.lastState = 'connected'
+        this.emit('connected')
+    }
+
+    public setConnectionId(connectionID: string): void {
+        this.connectionId = new ConnectionID(connectionID)
+    }
+}

package/src/connection/WebRTC/IWebRtcConnection.ts

@@ -0,0 +1,24 @@
+export interface WebRtcConnectionEvents {
+    localDescription: (description: string, type: string) => void
+    localCandidate: (candidate: string, mid: string) => void
+}
+
+export enum RtcDescription {
+    OFFER = 'offer',
+    ANSWER = 'answer'
+}
+
+export interface IWebRtcConnection {
+    start(isOffering: boolean): void
+
+    on(event: 'localDescription', listener: (description: string, type: string) => void): this
+    on(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
+    once(event: 'localDescription', listener: (description: string, type: string) => void): this
+    once(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
+    off(event: 'localDescription', listener: (description: string, type: string) => void): this 
+    off(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
+   
+    setRemoteDescription(description: string, type: string): Promise<void>
+    addRemoteCandidate(candidate: string, mid: string): void
+    isOpen(): boolean
+}

package/src/connection/WebRTC/NodeWebRtcConnection.ts

@@ -0,0 +1,256 @@
+import { IWebRtcConnection, WebRtcConnectionEvents } from './IWebRtcConnection'
+import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import EventEmitter from 'eventemitter3'
+import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
+import { Logger } from '@streamr/utils'
+import { IllegalRTCPeerConnectionState } from '../../helpers/errors'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { DisconnectionType } from '../../transport/ITransport'
+import { iceServerAsString } from './iceServerAsString'
+import { IceServer } from './WebRtcConnector'
+
+const logger = new Logger(module)
+
+const MAX_MESSAGE_SIZE = 1048576
+
+export const WEB_RTC_CLEANUP = new class {
+    // eslint-disable-next-line class-methods-use-this
+    cleanUp(): void {
+        nodeDatachannel.cleanup()
+    }
+}
+
+export interface Params {
+    remotePeerDescriptor: PeerDescriptor
+    bufferThresholdHigh?: number
+    bufferThresholdLow?: number
+    connectingTimeout?: number
+    iceServers?: IceServer[]
+}
+
+// Re-defined accoring to https://github.com/microsoft/TypeScript/blob/main/src/lib/dom.generated.d.ts
+// because importing single dom definitions in not possible
+
+enum RTCPeerConnectionStateEnum {
+    closed = 'closed',
+    connected = 'connected',
+    connecting = 'connecting',
+    disconnected = 'disconnected',
+    failed = 'failed',
+    new = 'new'
+}
+
+nodeDatachannel.initLogger('Fatal')
+
+type RTCPeerConnectionState = keyof typeof RTCPeerConnectionStateEnum
+
+type Events = WebRtcConnectionEvents & ConnectionEvents
+
+export class NodeWebRtcConnection extends EventEmitter<Events> implements IConnection, IWebRtcConnection {
+
+    public connectionId: ConnectionID
+    private connection?: PeerConnection
+    private dataChannel?: DataChannel
+    private lastState: RTCPeerConnectionState = 'connecting'
+    private remoteDescriptionSet = false
+    private connectingTimeoutRef?: NodeJS.Timeout
+
+    public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
+    private readonly iceServers: IceServer[]
+    private readonly bufferThresholdHigh: number // TODO: buffer handling must be implemented before production use
+    private readonly bufferThresholdLow: number
+    private readonly connectingTimeout: number
+    private readonly remotePeerDescriptor: PeerDescriptor
+    private closed = false
+
+    constructor(params: Params) {
+        super()
+        this.connectionId = new ConnectionID()
+        this.iceServers = params.iceServers || []
+        this.bufferThresholdHigh = params.bufferThresholdHigh || 2 ** 17
+        this.bufferThresholdLow = params.bufferThresholdLow || 2 ** 15
+        this.connectingTimeout = params.connectingTimeout || 20000
+        this.remotePeerDescriptor = params.remotePeerDescriptor
+    }
+
+    public start(isOffering: boolean): void {
+        logger.trace(`Staring new connection for peer: ${this.remotePeerDescriptor.kademliaId.toString()}`)
+        const hexId = keyFromPeerDescriptor(this.remotePeerDescriptor)
+        logger.trace(`Staring new connection for peer: ${hexId} offering: ${isOffering}`)
+        this.connection = new PeerConnection(hexId, {
+            iceServers: this.iceServers.map(iceServerAsString),
+            maxMessageSize: MAX_MESSAGE_SIZE
+        })
+
+        this.connectingTimeoutRef = setTimeout(() => {
+            logger.trace('connectingTimeout, this.closed === ' + this.closed)
+            this.doClose('OTHER')
+        }, this.connectingTimeout)
+
+        this.connection.onStateChange((state: string) => this.onStateChange(state))
+        this.connection.onGatheringStateChange((_state: string) => {})
+
+        this.connection.onLocalDescription((description: string, type: DescriptionType) => {
+            this.emit('localDescription', description, type.toString())
+        })
+        this.connection.onLocalCandidate((candidate: string, mid: string) => {
+            this.emit('localCandidate', candidate, mid)
+        })
+        if (isOffering) {
+            const dataChannel = this.connection.createDataChannel('streamrDataChannel')
+            this.setupDataChannel(dataChannel)
+        } else {
+            this.connection.onDataChannel((dataChannel) => this.onDataChannel(dataChannel))
+        }
+    }
+
+    public async setRemoteDescription(description: string, type: string): Promise<void> {
+        if (this.connection) {
+            try {
+                logger.trace(`Setting remote descriptor for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                this.connection!.setRemoteDescription(description, type as DescriptionType)
+                this.remoteDescriptionSet = true
+            } catch (err) {
+                logger.warn(`Failed to set remote descriptor for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+            }
+        } else {
+            this.doClose('OTHER', `Tried to set description for non-existent connection`)
+        }
+    }
+
+    public addRemoteCandidate(candidate: string, mid: string): void {
+        if (this.connection) {
+            if (this.remoteDescriptionSet) {
+                try {
+                    logger.trace(`Setting remote candidate for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    this.connection!.addRemoteCandidate(candidate, mid)
+                } catch (err) {
+                    logger.warn(`Failed to set remote candidate for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    this.doClose('OTHER')
+                }
+            } else {
+                this.doClose('OTHER', `Tried to set candidate before description`)
+            }
+        } else {
+            this.doClose('OTHER', `Tried to set candidate for non-existent connection`)
+        }
+    }
+
+    public send(data: Uint8Array): void {
+        if (this.isOpen()) {
+            try {
+                this.dataChannel!.sendMessageBinary(data as Buffer)
+            } catch (err) {
+                logger.warn('Failed to send binary message to ' + keyFromPeerDescriptor(this.remotePeerDescriptor) + err)
+            }
+        }
+    }
+
+    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
+        this.doClose(disconnectionType, reason)
+    }
+
+    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+        if (!this.closed) {
+            logger.trace(
+                `Closing Node WebRTC Connection to ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`
+                + `${reason ? `, reason: ${reason}` : ''}`
+            )
+
+            this.closed = true
+            
+            this.emit('disconnected', disconnectionType, undefined, reason)
+            this.removeAllListeners()
+            
+            if (this.connectingTimeoutRef) {
+                clearTimeout(this.connectingTimeoutRef)
+            }
+
+            if (this.dataChannel) {
+                try {
+                    logger.trace('closing datachannel')
+                    this.dataChannel.close()
+                } catch (e) {
+                    logger.warn('dc.close() errored: %s', e)
+                }
+            }
+            
+            if (this.connection) {
+                try {
+                    this.connection.close()
+                } catch (e) {
+                    logger.warn('conn.close() errored: %s', e)
+                }
+            }
+        }
+    }
+
+    public destroy(): void {
+        this.removeAllListeners()
+        this.doClose('OTHER')
+    }
+
+    private onDataChannel(dataChannel: DataChannel): void {
+        this.openDataChannel(dataChannel)
+        this.setupDataChannel(dataChannel)
+    }
+
+    private setupDataChannel(dataChannel: DataChannel): void {
+        dataChannel.setBufferedAmountLowThreshold(this.bufferThresholdLow)
+        dataChannel.onOpen(() => {
+            logger.trace(`dc.onOpened`)
+            this.openDataChannel(dataChannel)
+        })
+
+        dataChannel.onClosed(() => {
+            logger.trace(`dc.closed`)
+            this.doClose('OTHER', 'DataChannel closed')
+        })
+
+        dataChannel.onError((err) => logger.error('error', { err }))
+
+        dataChannel.onBufferedAmountLow(() => {
+            logger.trace(`dc.onBufferedAmountLow`)
+        })
+
+        dataChannel.onMessage((msg) => {
+            logger.trace(`dc.onMessage`)
+            this.emit('data', msg as Buffer)
+        })
+    }
+
+    private openDataChannel(dataChannel: DataChannel): void {
+        if (this.connectingTimeoutRef) {
+            clearTimeout(this.connectingTimeoutRef)
+        }
+        this.dataChannel = dataChannel
+        logger.trace(`DataChannel opened for peer ${this.remotePeerDescriptor.kademliaId.toString()}`)
+        this.emit('connected')
+    }
+
+    private onStateChange(state: string): void {
+        logger.trace('onStateChange ' + state)
+        if (!Object.keys(RTCPeerConnectionStateEnum).filter((s) => isNaN(+s)).includes(state)) {
+            throw new IllegalRTCPeerConnectionState('NodeWebRtcConnection used an unknown state: ' + state)
+        } else {
+            this.lastState = state as RTCPeerConnectionState
+        }
+        
+        if (state === RTCPeerConnectionStateEnum.closed
+            || state === RTCPeerConnectionStateEnum.disconnected
+            || state === RTCPeerConnectionStateEnum.failed
+        ) {
+            this.doClose('OTHER')
+        }
+        
+    }
+
+    isOpen(): boolean {
+        return !this.closed && this.lastState === 'connected' && !!this.dataChannel
+    }
+
+    public setConnectionId(connectionID: string): void {
+        this.connectionId = new ConnectionID(connectionID)
+    }
+}

package/src/connection/WebRTC/RemoteWebrtcConnector.ts

@@ -0,0 +1,93 @@
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer,
+    WebRtcConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { IWebRtcConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { ProtoRpcClient } from '@streamr/proto-rpc'
+import { Logger } from '@streamr/utils'
+
+const logger = new Logger(module)
+
+export class RemoteWebrtcConnector {
+
+    private peerDescriptor: PeerDescriptor
+    private client: ProtoRpcClient<IWebRtcConnectorServiceClient>
+
+    constructor(peerDescriptor: PeerDescriptor, client: ProtoRpcClient<IWebRtcConnectorServiceClient>) {
+        this.peerDescriptor = peerDescriptor
+        this.client = client
+    }
+
+    requestConnection(sourceDescriptor: PeerDescriptor, connectionId: string): void {
+        const request: WebRtcConnectionRequest = {
+            target: this.peerDescriptor,
+            requester: sourceDescriptor,
+            connectionId
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: sourceDescriptor as PeerDescriptor,
+            targetDescriptor: this.peerDescriptor as PeerDescriptor,
+            notification: true
+        }
+
+        this.client.requestConnection(request, options).catch((_e) => {
+            logger.trace('Failed to send requestConnection')
+        })
+    }
+
+    sendRtcOffer(sourceDescriptor: PeerDescriptor, description: string, connectionId: string): void {
+        const request: RtcOffer = {
+            target: this.peerDescriptor,
+            requester: sourceDescriptor,
+            connectionId,
+            description
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: sourceDescriptor as PeerDescriptor,
+            targetDescriptor: this.peerDescriptor as PeerDescriptor,
+        }
+
+        this.client.rtcOffer(request, options).catch((_e) => {
+            logger.trace('Failed to send rtcOffer')
+        })
+    }
+
+    sendRtcAnswer(sourceDescriptor: PeerDescriptor, description: string, connectionId: string): void {
+        const request: RtcAnswer = {
+            target: this.peerDescriptor,
+            requester: sourceDescriptor,
+            connectionId,
+            description
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: sourceDescriptor as PeerDescriptor,
+            targetDescriptor: this.peerDescriptor as PeerDescriptor,
+        }
+
+        this.client.rtcAnswer(request, options).catch((_e) => {
+            logger.trace('Failed to send rtcAnswer')
+        })
+    }
+
+    sendIceCandidate(sourceDescriptor: PeerDescriptor, candidate: string, mid: string, connectionId: string): void {
+        const request: IceCandidate = {
+            target: this.peerDescriptor,
+            requester: sourceDescriptor,
+            connectionId,
+            mid,
+            candidate
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: sourceDescriptor as PeerDescriptor,
+            targetDescriptor: this.peerDescriptor as PeerDescriptor,
+        }
+        this.client.iceCandidate(request, options).catch((_e) => {
+            logger.trace('Failed to send iceCandidate')
+        })
+    }
+}
+