@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -1,245 +0,0 @@
-import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
-import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import EventEmitter from 'eventemitter3'
-import { DataChannel, DescriptionType, PeerConnection, initLogger } from 'node-datachannel'
-import { Logger } from '@streamr/utils'
-import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
-import { iceServerAsString } from './iceServerAsString'
-import { IceServer, EARLY_TIMEOUT } from './WebrtcConnector'
-import { PortRange } from '../ConnectionManager'
-import { toNodeId } from '../../identifiers'
-import { createRandomConnectionId } from '../Connection'
-
-const logger = new Logger(module)
-
-export interface Params {
-    remotePeerDescriptor: PeerDescriptor
-    bufferThresholdHigh?: number
-    bufferThresholdLow?: number
-    maxMessageSize?: number
-    iceServers?: IceServer[]  // TODO make this parameter required (empty array is a good fallback which can be set by the caller if needed)
-    portRange?: PortRange
-}
-
-// 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'
-}
-
-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
-    public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
-    private readonly iceServers: IceServer[]
-    private readonly _bufferThresholdHigh: number // TODO: buffer handling must be implemented before production use (NET-938)
-    private readonly bufferThresholdLow: number
-    private readonly remotePeerDescriptor: PeerDescriptor
-    private readonly portRange?: PortRange
-    private readonly maxMessageSize?: number
-    private closed = false
-    private offering?: boolean
-    private readonly earlyTimeout: NodeJS.Timeout
-
-    constructor(params: Params) {
-        super()
-        this.connectionId = createRandomConnectionId()
-        this.iceServers = params.iceServers ?? []
-        // eslint-disable-next-line no-underscore-dangle
-        this._bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17
-        this.bufferThresholdLow = params.bufferThresholdLow ?? 2 ** 15
-        this.remotePeerDescriptor = params.remotePeerDescriptor
-        this.maxMessageSize = params.maxMessageSize ?? 1048576
-        this.portRange = params.portRange
-        this.earlyTimeout = setTimeout(() => {
-            this.doClose(false, 'timed out due to remote descriptor not being set')
-        }, EARLY_TIMEOUT)
-    }
-
-    public start(isOffering: boolean): void {
-        const nodeId = toNodeId(this.remotePeerDescriptor)
-        this.offering = isOffering
-        logger.trace(`Starting new connection for peer ${nodeId}`, { isOffering })
-        this.connection = new PeerConnection(nodeId, {
-            iceServers: this.iceServers.map(iceServerAsString),
-            maxMessageSize: this.maxMessageSize,
-            portRangeBegin: this.portRange?.min,
-            portRangeEnd: this.portRange?.max,
-        })
-
-        this.connection.onStateChange((state: string) => this.onStateChange(state))
-        this.connection.onGatheringStateChange(() => {})
-
-        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.setupDataChannel(dataChannel))
-        }
-    }
-
-    public async setRemoteDescription(description: string, type: string): Promise<void> {
-        if (this.connection) {
-            clearTimeout(this.earlyTimeout)
-            const remoteNodeId = toNodeId(this.remotePeerDescriptor)
-            try {
-                logger.trace(`Setting remote descriptor for peer: ${remoteNodeId}`)
-                this.connection.setRemoteDescription(description, type as DescriptionType)
-                this.remoteDescriptionSet = true
-            } catch {
-                logger.debug(`Failed to set remote descriptor for peer ${remoteNodeId}`)
-            }
-        } else {
-            this.doClose(false, `Tried to set description for non-existent connection`)
-        }
-    }
-
-    public addRemoteCandidate(candidate: string, mid: string): void {
-        if (this.connection) {
-            if (this.remoteDescriptionSet) {
-                const remoteNodeId = toNodeId(this.remotePeerDescriptor)
-                try {
-                    logger.trace(`Setting remote candidate for peer: ${remoteNodeId}`)
-                    this.connection.addRemoteCandidate(candidate, mid)
-                } catch {
-                    logger.debug(`Failed to set remote candidate for peer ${remoteNodeId}`)
-                }
-            } else {
-                // TODO: should queue candidates until remote description is set?
-                this.doClose(false, `Tried to set candidate before description`)
-            }
-        } else {
-            this.doClose(false, `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) {
-                const remoteNodeId = toNodeId(this.remotePeerDescriptor)
-                logger.debug('Failed to send binary message to ' + remoteNodeId + err)
-            }
-        }
-    }
-
-    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
-        this.doClose(gracefulLeave, reason)
-    }
-
-    private doClose(gracefulLeave: boolean, reason?: string): void {
-        if (!this.closed) {
-            clearTimeout(this.earlyTimeout)
-            const remoteNodeId = toNodeId(this.remotePeerDescriptor)
-            logger.trace(`Closing Node WebRTC Connection to ${remoteNodeId}` + `${(reason !== undefined) ? `, reason: ${reason}` : ''}`)
-
-            this.closed = true
-            
-            this.emit('disconnected', gracefulLeave, undefined, reason)
-            this.removeAllListeners()
-
-            if (this.dataChannel) {
-                try {
-                    logger.trace('closing datachannel')
-                    this.dataChannel.close()
-                } catch (e) {
-                    logger.trace('dc.close() errored: %s', e)
-                }
-            }
-            
-            if (this.connection) {
-                try {
-                    this.connection.close()
-                } catch (e) {
-                    logger.trace('conn.close() errored: %s', e)
-                }
-            }
-            this.connection = undefined
-            this.dataChannel = undefined
-        }
-    }
-
-    public destroy(): void {
-        this.removeAllListeners()
-        this.doClose(false)
-    }
-
-    private setupDataChannel(dataChannel: DataChannel): void {
-        this.dataChannel = dataChannel
-        dataChannel.setBufferedAmountLowThreshold(this.bufferThresholdLow)
-        dataChannel.onOpen(() => {
-            logger.trace(`dc.onOpened`)
-            this.onDataChannelOpen()
-        })
-
-        dataChannel.onClosed(() => {
-            logger.trace(`dc.closed`)
-            this.doClose(false, '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 onDataChannelOpen(): void {
-        logger.trace(`DataChannel opened for peer ${toNodeId(this.remotePeerDescriptor)}`)
-        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(false)
-        }
-        
-    }
-
-    isOpen(): boolean {
-        return !this.closed && this.lastState === 'connected' && !!this.dataChannel
-    }
-
-    public setConnectionId(connectionId: ConnectionID): void {
-        this.connectionId = connectionId
-    }
-}

package/src/connection/webrtc/WebrtcConnector.ts

@@ -1,234 +0,0 @@
-import {
-    HandshakeError,
-    IceCandidate,
-    PeerDescriptor,
-    RtcAnswer,
-    RtcOffer, WebrtcConnectionRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { ITransport } from '../../transport/ITransport'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { NodeWebrtcConnection } from './NodeWebrtcConnection'
-import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
-import { WebrtcConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { Logger } from '@streamr/utils'
-import * as Err from '../../helpers/errors'
-import { PortRange } from '../ConnectionManager'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { WebrtcConnectorRpcLocal } from './WebrtcConnectorRpcLocal'
-import { DhtAddress, areEqualPeerDescriptors, toNodeId } from '../../identifiers'
-import { getOfferer } from '../../helpers/offering'
-import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
-import { isMaybeSupportedProtocolVersion } from '../../helpers/version'
-import { PendingConnection } from '../PendingConnection'
-
-const logger = new Logger(module)
-
-export const replaceInternalIpWithExternalIp = (candidate: string, ip: string): string => {
-    const parsed = candidate.split(' ')
-    const type = parsed[7]
-    if (type === 'host') {
-        parsed[4] = ip
-    }
-    return parsed.join(' ')
-}
-
-export const EARLY_TIMEOUT = 5000
-
-export interface WebrtcConnectorOptions {
-    onNewConnection: (connection: PendingConnection) => boolean
-    transport: ITransport
-    iceServers?: IceServer[]
-    allowPrivateAddresses?: boolean
-    bufferThresholdLow?: number
-    bufferThresholdHigh?: number
-    maxMessageSize?: number
-    externalIp?: string
-    portRange?: PortRange
-}
-
-export interface IceServer {
-    url: string
-    port: number
-    username?: string
-    password?: string
-    tcp?: boolean
-}
-
-export interface ConnectingConnection {
-    managedConnection: PendingConnection
-    connection: NodeWebrtcConnection
-}
-
-export class WebrtcConnector {
-
-    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly ongoingConnectAttempts: Map<DhtAddress, ConnectingConnection> = new Map()
-    private localPeerDescriptor?: PeerDescriptor
-    private stopped = false
-    private options: WebrtcConnectorOptions
-
-    constructor(options: WebrtcConnectorOptions) {
-        this.options = options
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, options.transport, {
-            rpcRequestTimeout: 15000  // TODO use options option or named constant?
-        })
-        this.registerLocalRpcMethods(options)
-    }
-
-    private registerLocalRpcMethods(options: WebrtcConnectorOptions) {
-        const localRpc = new WebrtcConnectorRpcLocal({
-            connect: (targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean) => 
-                this.connect(targetPeerDescriptor, doNotRequestConnection),
-            onNewConnection: (connection: PendingConnection) => this.options.onNewConnection(connection),
-            ongoingConnectAttempts: this.ongoingConnectAttempts,
-            rpcCommunicator: this.rpcCommunicator,
-            getLocalPeerDescriptor: () => this.localPeerDescriptor!,
-            allowPrivateAddresses: options.allowPrivateAddresses ?? true
-        })
-        this.rpcCommunicator.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection',
-            async (_req: WebrtcConnectionRequest, context: ServerCallContext) => {
-                if (!this.stopped) {
-                    return localRpc.requestConnection(context)
-                } else {
-                    return {}
-                }
-            }
-        )
-        this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
-            async (req: RtcOffer, context: ServerCallContext) => {
-                if (!this.stopped) {
-                    return localRpc.rtcOffer(req, context)
-                } else {
-                    return {}
-                }
-            }
-        )
-        this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
-            async (req: RtcAnswer, context: ServerCallContext) => {
-                if (!this.stopped) {
-                    return localRpc.rtcAnswer(req, context)
-                } else {
-                    return {}
-                }
-            }
-        )
-        this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
-            async (req: IceCandidate, context: ServerCallContext) => {
-                if (!this.stopped) {
-                    return localRpc.iceCandidate(req, context)
-                } else {
-                    return {}
-                }
-            }
-        )
-    }
-
-    connect(targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean): PendingConnection {
-        if (areEqualPeerDescriptors(targetPeerDescriptor, this.localPeerDescriptor!)) {
-            throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
-        }
-
-        logger.trace(`Opening WebRTC connection to ${toNodeId(targetPeerDescriptor)}`)
-
-        const nodeId = toNodeId(targetPeerDescriptor)
-        const existingConnection = this.ongoingConnectAttempts.get(nodeId)
-        if (existingConnection) {
-            return existingConnection.managedConnection
-        }
-
-        const connection = this.createConnection(targetPeerDescriptor)
-
-        const localNodeId = toNodeId(this.localPeerDescriptor!)
-        const targetNodeId = toNodeId(targetPeerDescriptor)
-        const offering = (getOfferer(localNodeId, targetNodeId) === 'local')
-        let pendingConnection: PendingConnection
-        const remoteConnector = new WebrtcConnectorRpcRemote(
-            this.localPeerDescriptor!,
-            targetPeerDescriptor,
-            this.rpcCommunicator,
-            WebrtcConnectorRpcClient
-        )
-        const delFunc = () => {
-            this.ongoingConnectAttempts.delete(nodeId)
-            connection.off('disconnected', delFunc)
-            pendingConnection.off('disconnected', delFunc)
-            pendingConnection.off('connected', delFunc)
-        }
-        if (offering) {
-            pendingConnection = new PendingConnection(targetPeerDescriptor)
-            createOutgoingHandshaker(this.localPeerDescriptor!, pendingConnection, connection, targetPeerDescriptor)
-            connection.once('localDescription', (description: string) => {
-                logger.trace('Sending offer to remote peer')
-                remoteConnector.sendRtcOffer(description, connection.connectionId)
-            })
-        } else {
-            pendingConnection = new PendingConnection(targetPeerDescriptor)
-            const handshaker = createIncomingHandshaker(this.localPeerDescriptor!, pendingConnection, connection)
-            connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(description, connection.connectionId)
-            })
-            handshaker.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, remoteVersion: string) => {
-                if (!isMaybeSupportedProtocolVersion(remoteVersion)) {
-                    rejectHandshake(pendingConnection!, connection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
-                } else {
-                    acceptHandshake(handshaker, pendingConnection, connection)
-                }
-                delFunc()
-            })
-        }
-
-        this.ongoingConnectAttempts.set(targetNodeId, {
-            managedConnection: pendingConnection,
-            connection
-        })
-
-        connection.on('disconnected', delFunc)
-        pendingConnection.on('disconnected', delFunc)
-        pendingConnection.on('connected', delFunc)
-    
-        connection.on('localCandidate', (candidate: string, mid: string) => {
-            if (this.options.externalIp !== undefined) {
-                candidate = replaceInternalIpWithExternalIp(candidate, this.options.externalIp)
-                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
-            }
-            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId)
-        })
-
-        connection.start(offering)
-
-        if (!doNotRequestConnection && !offering) {
-            remoteConnector.requestConnection()
-        }
-
-        return pendingConnection
-    }
-
-    private createConnection(targetPeerDescriptor: PeerDescriptor): NodeWebrtcConnection {
-        return new NodeWebrtcConnection({
-            remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.options.iceServers,
-            bufferThresholdLow: this.options.bufferThresholdLow,
-            bufferThresholdHigh: this.options.bufferThresholdHigh,
-            portRange: this.options.portRange
-            // TODO should we pass maxMessageSize?
-        })
-    }
-
-    setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
-        this.localPeerDescriptor = peerDescriptor
-    }
-
-    public async stop(): Promise<void> {
-        logger.trace('stop()')
-        this.stopped = true
-
-        const attempts = Array.from(this.ongoingConnectAttempts.values())
-        await Promise.allSettled(attempts.map(async (conn) => {
-            conn.connection.destroy()
-            conn.managedConnection.close(false)
-        }))
-
-        this.rpcCommunicator.destroy()
-    }
-}

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -1,108 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { Logger } from '@streamr/utils'
-import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
-import { Empty } from '../../../generated/google/protobuf/empty'
-import {
-    IceCandidate,
-    PeerDescriptor,
-    RtcAnswer,
-    RtcOffer
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { IWebrtcConnectorRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { NodeWebrtcConnection } from './NodeWebrtcConnection'
-import { DhtAddress, toNodeId } from '../../identifiers'
-import { ConnectionID } from '../IConnection'
-import { ConnectingConnection } from './WebrtcConnector'
-import { PendingConnection } from '../PendingConnection'
-
-const logger = new Logger(module)
-
-interface WebrtcConnectorRpcLocalOptions {
-    connect: (targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean) => PendingConnection 
-    onNewConnection: (connection: PendingConnection) => boolean
-    // TODO pass accessor methods instead of passing a mutable entity
-    ongoingConnectAttempts: Map<DhtAddress, ConnectingConnection>
-    rpcCommunicator: ListeningRpcCommunicator
-    getLocalPeerDescriptor: () => PeerDescriptor
-    allowPrivateAddresses: boolean
-}
-
-export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
-
-    private readonly options: WebrtcConnectorRpcLocalOptions
-
-    constructor(options: WebrtcConnectorRpcLocalOptions) {
-        this.options = options
-    }
-
-    async requestConnection(context: ServerCallContext): Promise<Empty> {
-        const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.options.ongoingConnectAttempts.has(toNodeId(targetPeerDescriptor))) {
-            return {}
-        }
-        const pendingConnection = this.options.connect(targetPeerDescriptor, false)
-        this.options.onNewConnection(pendingConnection)
-        return {}
-    }
-
-    async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
-        const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = toNodeId(remotePeerDescriptor)
-        let connection: NodeWebrtcConnection
-        let pendingConnection: PendingConnection
-
-        if (!this.options.ongoingConnectAttempts.has(nodeId)) {
-            pendingConnection = this.options.connect(remotePeerDescriptor, true)
-            connection = this.options.ongoingConnectAttempts.get(nodeId)!.connection
-            this.options.onNewConnection(pendingConnection)
-        } else {
-            pendingConnection = this.options.ongoingConnectAttempts.get(nodeId)!.managedConnection
-            connection = this.options.ongoingConnectAttempts.get(nodeId)!.connection
-        }
-        // Always use offerers connectionId
-        connection!.setConnectionId(request.connectionId as ConnectionID)
-        connection!.setRemoteDescription(request.description, 'offer')
-        return {}
-    }
-
-    async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
-        const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = toNodeId(remotePeerDescriptor)
-        const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
-        if (!connection) {
-            return {}
-        } else if (connection.connectionId !== 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 nodeId = toNodeId(remotePeerDescriptor)
-        const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
-        if (!connection) {
-            return {}
-        } else if (connection.connectionId !== 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.options.allowPrivateAddresses) {
-            const address = getAddressFromIceCandidate(candidate)
-            if ((address !== undefined) && isPrivateIPv4(address)) {
-                return false
-            }
-        }
-        return true
-    }
-}

package/src/connection/webrtc/WebrtcConnectorRpcRemote.ts

@@ -1,60 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { RpcRemote } from '../../dht/contact/RpcRemote'
-import {
-    IceCandidate,
-    RtcAnswer,
-    RtcOffer,
-    WebrtcConnectionRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { WebrtcConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-
-const logger = new Logger(module)
-
-export class WebrtcConnectorRpcRemote extends RpcRemote<WebrtcConnectorRpcClient> {
-
-    requestConnection(): void {
-        const request: WebrtcConnectionRequest = {
-        }
-        const options = this.formDhtRpcOptions({
-            notification: true
-        })
-        this.getClient().requestConnection(request, options).catch((_e) => {
-            logger.trace('Failed to send requestConnection')
-        })
-    }
-
-    sendRtcOffer(description: string, connectionId: string): void {
-        const request: RtcOffer = {
-            connectionId,
-            description
-        }
-        const options = this.formDhtRpcOptions()
-        this.getClient().rtcOffer(request, options).catch((_e) => {
-            logger.trace('Failed to send rtcOffer')
-        })
-    }
-
-    sendRtcAnswer(description: string, connectionId: string): void {
-        const request: RtcAnswer = {
-            connectionId,
-            description
-        }
-        const options = this.formDhtRpcOptions()
-        this.getClient().rtcAnswer(request, options).catch((_e) => {
-            logger.trace('Failed to send rtcAnswer')
-        })
-    }
-
-    sendIceCandidate(candidate: string, mid: string, connectionId: string): void {
-        const request: IceCandidate = {
-            connectionId,
-            mid,
-            candidate
-        }
-        const options = this.formDhtRpcOptions()
-        this.getClient().iceCandidate(request, options).catch((_e) => {
-            logger.trace('Failed to send iceCandidate')
-        })
-    }
-}
-

package/src/connection/webrtc/iceServerAsString.ts

@@ -1,15 +0,0 @@
-import { IceServer } from './WebrtcConnector'
-
-export function iceServerAsString({ url, port, username, password, tcp }: IceServer): string {
-    const [protocol, hostname] = url.split(':')
-    if (hostname === undefined) {
-        throw new Error(`invalid stun/turn format: ${url}`)
-    }
-    if (username === undefined && password === undefined) {
-        return `${protocol}:${hostname}:${port}`
-    }
-    if (username !== undefined && password !== undefined) {
-        return `${protocol}:${username}:${password}@${hostname}:${port}${(tcp !== undefined) ? '?transport=tcp' : ''}`
-    }
-    throw new Error(`username (${username}) and password (${password}) must be supplied together`)
-}