@streamr/dht 0.0.1-tatum.7 → 0.0.1-tatum.8

package/src/connection/WebRTC/{WebRtcConnector.ts → WebRtcConnectorRpcLocal.ts}

@@ -8,13 +8,13 @@ import { Empty } from '../../proto/google/protobuf/empty'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { NodeWebRtcConnection } from './NodeWebRtcConnection'
-import { RemoteWebrtcConnector } from './RemoteWebrtcConnector'
-import { WebRtcConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebRtcConnectorRpcRemote } from './WebRtcConnectorRpcRemote'
+import { WebRtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { ManagedWebRtcConnection } from '../ManagedWebRtcConnection'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
-import { IWebRtcConnectorService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { IWebRtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ManagedConnection } from '../ManagedConnection'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
@@ -24,6 +24,8 @@ import {
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
 import { PortRange } from '../ConnectionManager'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 
 const logger = new Logger(module)
 
@@ -36,9 +38,8 @@ export const replaceInternalIpWithExternalIp = (candidate: string, ip: string):
     return parsed.join(' ')
 }
 
-export interface WebRtcConnectorConfig {
+export interface WebRtcConnectorRpcLocalConfig {
     transport: ITransport
-    protocolVersion: string
     iceServers?: IceServer[]
     allowPrivateAddresses?: boolean
     bufferThresholdLow?: number
@@ -57,7 +58,8 @@ export interface IceServer {
     tcp?: boolean
 }
 
-export class WebRtcConnector implements IWebRtcConnectorService {
+export class WebRtcConnectorRpcLocal implements IWebRtcConnectorRpc {
+
     private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebRtcConnection> = new Map()
@@ -65,11 +67,11 @@ export class WebRtcConnector implements IWebRtcConnectorService {
     private stopped = false
     private iceServers: IceServer[]
     private allowPrivateAddresses: boolean
-    private config: WebRtcConnectorConfig
+    private config: WebRtcConnectorRpcLocalConfig
     private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        config: WebRtcConnectorConfig,
+        config: WebRtcConnectorRpcLocalConfig,
         onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
@@ -77,17 +79,17 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         this.allowPrivateAddresses = config.allowPrivateAddresses || true
         this.onIncomingConnection = onIncomingConnection
 
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnectorRpcLocal.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
         this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
-            (req: RtcOffer) => this.rtcOffer(req))
+            (req: RtcOffer, context: ServerCallContext) => this.rtcOffer(req, context))
         this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
-            (req: RtcAnswer) => this.rtcAnswer(req))
+            (req: RtcAnswer, context: ServerCallContext) => this.rtcAnswer(req, context))
         this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
-            (req: IceCandidate) => this.iceCandidate(req))
+            (req: IceCandidate, context: ServerCallContext) => this.iceCandidate(req, context))
         this.rpcCommunicator.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection',
-            (req: WebRtcConnectionRequest) => this.requestConnection(req))
+            (req: WebRtcConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context))
     }
 
     connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
@@ -116,9 +118,9 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         let managedConnection: ManagedWebRtcConnection
 
         if (offering) {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, connection)
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, connection)
         } else {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
         }
 
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
@@ -135,9 +137,10 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         connection.on('disconnected', delFunc)
         managedConnection.on('handshakeCompleted', delFunc)
 
-        const remoteConnector = new RemoteWebrtcConnector(
+        const remoteConnector = new WebRtcConnectorRpcRemote(
+            this.ownPeerDescriptor!,
             targetPeerDescriptor,
-            toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {
@@ -145,23 +148,23 @@ export class WebRtcConnector implements IWebRtcConnectorService {
                 candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
                 logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
             }
-            remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection.connectionId.toString())
+            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId.toString())
         })
 
         if (offering) {
             connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcOffer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+                remoteConnector.sendRtcOffer(description, connection.connectionId.toString())
             })
         } else {
             connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+                remoteConnector.sendRtcAnswer(description, connection.connectionId.toString())
             })
         }
 
         connection.start(offering)
 
         if (!offering) {
-            remoteConnector.requestConnection(this.ownPeerDescriptor!, connection.connectionId.toString())
+            remoteConnector.requestConnection(connection.connectionId.toString())
         }
 
         return managedConnection
@@ -196,24 +199,25 @@ export class WebRtcConnector implements IWebRtcConnectorService {
 
         if (!managedConnection) {
             connection = new NodeWebRtcConnection({ remotePeerDescriptor: remotePeer })
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
 
             managedConnection.setPeerDescriptor(remotePeer)
 
             this.ongoingConnectAttempts.set(peerKey, managedConnection)
             this.onIncomingConnection(managedConnection)
 
-            const remoteConnector = new RemoteWebrtcConnector(
+            const remoteConnector = new WebRtcConnectorRpcRemote(
+                this.ownPeerDescriptor!,
                 remotePeer,
-                toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
 
             connection.on('localCandidate', (candidate: string, mid: string) => {
-                remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection!.connectionId.toString())
+                remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
             })
 
             connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection!.connectionId.toString())
+                remoteConnector.sendRtcAnswer(description, connection!.connectionId.toString())
             })
 
             connection.start(false)
@@ -301,23 +305,31 @@ export class WebRtcConnector implements IWebRtcConnectorService {
     }
 
     // IWebRTCConnector implementation
-    async requestConnection(request: WebRtcConnectionRequest): Promise<Empty> {
-        this.onConnectionRequest(request.requester!)
+    // TODO should we read connectionId from WebRtcConnectionRequest (or remove the field)?
+    async requestConnection(_request: WebRtcConnectionRequest, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        this.onConnectionRequest(senderPeerDescriptor)
         return {}
     }
 
-    async rtcOffer(request: RtcOffer): Promise<Empty> {
-        this.onRtcOffer(request.requester!, request.target!, request.description, request.connectionId)
+    async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRtcOffer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
         return {}
     }
 
-    async rtcAnswer(request: RtcAnswer): Promise<Empty> {
-        this.onRtcAnswer(request.requester!, request.target!, request.description, request.connectionId)
+    async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRtcAnswer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
         return {}
     }
 
-    async iceCandidate(request: IceCandidate): Promise<Empty> {
-        this.onRemoteCandidate(request.requester!, request.target!, request.candidate, request.mid, request.connectionId)
+    async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRemoteCandidate(senderPeerDescriptor, receiverPeerDescriptor, request.candidate, request.mid, request.connectionId)
         return {}
     }
 }

package/src/connection/WebRTC/WebRtcConnectorRpcRemote.ts

@@ -0,0 +1,71 @@
+import { Remote } from '../../dht/contact/Remote'
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer,
+    WebRtcConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+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> {
+
+    constructor(
+        localPeerDescriptor: PeerDescriptor,
+        remotePeerDescriptor: PeerDescriptor,
+        client: ProtoRpcClient<IWebRtcConnectorRpcClient>
+    ) {
+        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
+    }
+
+    requestConnection(connectionId: string): void {
+        const request: WebRtcConnectionRequest = {
+            connectionId
+        }
+        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,4 +1,4 @@
-import { IceServer } from './WebRtcConnector'
+import { IceServer } from './WebRtcConnectorRpcLocal'
 
 export function iceServerAsString({ url, port, username, password, tcp }: IceServer): string {
     const [protocol, hostname] = url.split(':')

package/src/connection/WebSocket/{WebSocketConnector.ts → WebSocketConnectorRpcLocal.ts}

@@ -2,7 +2,7 @@ import { ClientWebSocket } from './ClientWebSocket'
 import { IConnection, ConnectionType } from '../IConnection'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { RemoteWebSocketConnector } from './RemoteWebSocketConnector'
+import { WebSocketConnectorRpcRemote } from './WebSocketConnectorRpcRemote'
 import {
     ConnectivityMethod,
     ConnectivityResponse,
@@ -11,9 +11,9 @@ import {
     WebSocketConnectionRequest,
     WebSocketConnectionResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { WebSocketConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger, binaryToHex, wait } from '@streamr/utils'
-import { IWebSocketConnectorService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { IWebSocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebSocketServer } from './WebSocketServer'
 import { ConnectivityChecker } from '../ConnectivityChecker'
@@ -26,6 +26,8 @@ import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/p
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
 import { isPrivateIPv4 } from '../../helpers/AddressTools'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 
 const logger = new Logger(module)
 
@@ -40,8 +42,7 @@ const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod) => {
 
 const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
-interface WebSocketConnectorConfig {
-    protocolVersion: string
+interface WebSocketConnectorRpcLocalConfig {
     transport: ITransport
     canConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
     onIncomingConnection: (connection: ManagedConnection) => boolean
@@ -52,7 +53,8 @@ interface WebSocketConnectorConfig {
     tlsCertificate?: TlsCertificate
 }
 
-export class WebSocketConnector implements IWebSocketConnectorService {
+export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
+
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly canConnectFunction: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
@@ -64,13 +66,11 @@ export class WebSocketConnector implements IWebSocketConnectorService {
     private readonly entrypoints?: PeerDescriptor[]
     private readonly tlsCertificate?: TlsCertificate
     private selectedPort?: number
-    private readonly protocolVersion: string
     private ownPeerDescriptor?: PeerDescriptor
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private destroyed = false
 
-    constructor(config: WebSocketConnectorConfig) {
-        this.protocolVersion = config.protocolVersion
+    constructor(config: WebSocketConnectorRpcLocalConfig) {
         this.webSocketServer = config.portRange ? new WebSocketServer({
             portRange: config.portRange!,
             tlsCertificate: config.tlsCertificate,
@@ -83,7 +83,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
 
         this.canConnectFunction = config.canConnect.bind(this)
 
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnectorRpcLocal.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
 
@@ -91,12 +91,12 @@ export class WebSocketConnector implements IWebSocketConnectorService {
             WebSocketConnectionRequest,
             WebSocketConnectionResponse,
             'requestConnection',
-            (req: WebSocketConnectionRequest) => this.requestConnection(req)
+            (req: WebSocketConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context)
         )
     }
 
     private attachHandshaker(connection: IConnection) {
-        const handshaker = new Handshaker(this.ownPeerDescriptor!, this.protocolVersion, connection)
+        const handshaker = new Handshaker(this.ownPeerDescriptor!, connection)
         handshaker.once('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
             this.onServerSocketHandshakeRequest(peerDescriptor, connection)
         })
@@ -155,13 +155,13 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                         }
                         return preconfiguredConnectivityResponse
                     } else {
-                        // Do real connectivity checking     
+                        // Do real connectivity checking
                         return await this.connectivityChecker!.sendConnectivityRequest(entryPoint)
                     }
                 }
             } catch (err) {
                 if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
-                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} ` 
+                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} `
                         + `and URL ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`
                     logger.error(error, { error: err })
                     await wait(2000)
@@ -195,8 +195,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
 
             const url = connectivityMethodToWebSocketUrl(targetPeerDescriptor.websocket!)
 
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion,
-                ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
+            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
             managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
             this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -219,13 +218,14 @@ export class WebSocketConnector implements IWebSocketConnectorService {
 
     private requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         setImmediate(() => {
-            const remoteConnector = new RemoteWebSocketConnector(
+            const remoteConnector = new WebSocketConnectorRpcRemote(
+                ownPeerDescriptor,
                 targetPeerDescriptor,
-                toProtoRpcClient(new WebSocketConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new WebSocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            remoteConnector.requestConnection(ownPeerDescriptor, ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection(ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
         })
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion, ConnectionType.WEBSOCKET_SERVER)
+        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -242,8 +242,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
             ongoingConnectReguest.acceptHandshake()
             this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion,
-                ConnectionType.WEBSOCKET_SERVER, undefined, serverWebSocket)
+            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebSocket)
 
             managedConnection.setPeerDescriptor(peerDescriptor)
 
@@ -273,14 +272,15 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         await this.webSocketServer?.stop()
     }
 
-    // IWebSocketConnectorService implementation
-    public async requestConnection(request: WebSocketConnectionRequest): Promise<WebSocketConnectionResponse> {
-        if (!this.destroyed && this.canConnectFunction(request.requester!, request.ip, request.port)) {
+    // IWebSocketConnectorRpc implementation
+    public async requestConnection(request: WebSocketConnectionRequest, context: ServerCallContext): Promise<WebSocketConnectionResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        if (!this.destroyed && this.canConnectFunction(senderPeerDescriptor, request.ip, request.port)) {
             setImmediate(() => {
                 if (this.destroyed) {
                     return
                 }
-                const connection = this.connect(request.requester!)
+                const connection = this.connect(senderPeerDescriptor)
                 this.onIncomingConnection(connection)
             })
             const res: WebSocketConnectionResponse = {

package/src/connection/WebSocket/{RemoteWebSocketConnector.ts → WebSocketConnectorRpcRemote.ts}

@@ -2,39 +2,34 @@ import {
     PeerDescriptor,
     WebSocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebSocketConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { IWebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { Remote } from '../../dht/contact/Remote'
 
 const logger = new Logger(module)
 
-export class RemoteWebSocketConnector {
+export class WebSocketConnectorRpcRemote extends Remote<IWebSocketConnectorRpcClient> {
 
-    private peerDescriptor: PeerDescriptor
-    private client: ProtoRpcClient<IWebSocketConnectorServiceClient>
-
-    constructor(peerDescriptor: PeerDescriptor, client: ProtoRpcClient<IWebSocketConnectorServiceClient>) {
-        this.peerDescriptor = peerDescriptor
-        this.client = client
+    constructor(
+        localPeerDescriptor: PeerDescriptor,
+        remotePeerDescriptor: PeerDescriptor,
+        client: ProtoRpcClient<IWebSocketConnectorRpcClient>
+    ) {
+        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
-    async requestConnection(sourceDescriptor: PeerDescriptor, ip: string, port: number): Promise<boolean> {
-        logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.peerDescriptor)}`)
+    async requestConnection(ip: string, port: number): Promise<boolean> {
+        logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
         const request: WebSocketConnectionRequest = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
             ip,
             port
         }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor 
-        }
+        const options = this.formDhtRpcOptions()
         try {
-            const res = await this.client.requestConnection(request, options)
+            const res = await this.getClient().requestConnection(request, options)
             
             if (res.reason) {
                 logger.debug('WebSocketConnectionRequest Rejected', {