@streamr/dht 0.0.1-tatum.0

package/test/integration/WebRtcConnectionManagement.test.ts

@@ -0,0 +1,205 @@
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import { ConnectionType } from '../../src/connection/IConnection'
+import { ITransport } from '../../src/transport/ITransport'
+import * as Err from '../../src/helpers/errors'
+import { SimulatorTransport } from '../../src/exports'
+
+describe('WebRTC Connection Management', () => {
+
+    let manager1: ConnectionManager
+    let manager2: ConnectionManager
+
+    let simulator: Simulator
+
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: PeerID.fromString('peer1').value,
+        nodeName: 'peer1',
+        type: NodeType.NODEJS,
+    }
+
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString('peer2').value,
+        nodeName: 'peer2',
+        type: NodeType.NODEJS,
+    }
+
+    let connectorTransport1: ITransport
+    let connectorTransport2: ITransport
+
+    beforeEach(async () => {
+
+        simulator = new Simulator(LatencyType.FIXED, 500)
+
+        connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        manager1 = new ConnectionManager({ transportLayer: connectorTransport1, nodeName: peerDescriptor1.nodeName })
+
+        connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        manager2 = new ConnectionManager({ transportLayer: connectorTransport2, nodeName: peerDescriptor2.nodeName })
+
+        await manager1.start((_msg) => peerDescriptor1)
+        await manager2.start((_msg) => peerDescriptor2)
+
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            manager1.stop(),
+            manager2.stop(),
+            connectorTransport1.stop(),
+            connectorTransport2.stop()
+        ])
+        simulator.stop()
+    })
+
+    const serviceId = 'dummy'
+
+    // TODO: fix flaky test, ticket NET-911
+    it('Peer1 can open WebRTC Datachannels', (done) => {
+        const dummyMessage: Message = {
+            serviceId: 'unknown',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer'
+        }
+
+        manager2.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(manager1.getConnection(peerDescriptor2)!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager2.getConnection(peerDescriptor1)!.connectionType).toEqual(ConnectionType.WEBRTC)
+
+            done()
+        })
+        dummyMessage.targetDescriptor = peerDescriptor2
+        manager1.send(dummyMessage).catch((e) => {
+            throw e
+        })
+    }, 60000)
+
+    it('Peer2 can open WebRTC Datachannel', (done) => {
+        const dummyMessage: Message = {
+            serviceId: serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            }, 
+            messageType: MessageType.RPC,
+            messageId: 'mockerer'
+        }
+        manager1.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(manager1.getConnection(peerDescriptor2)!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager2.getConnection(peerDescriptor1)!.connectionType).toEqual(ConnectionType.WEBRTC)
+
+            done()
+        })
+        dummyMessage.targetDescriptor = peerDescriptor1
+        manager2.send(dummyMessage)
+    }, 60000)
+
+    it('Connecting to self throws', async () => {
+        const dummyMessage: Message = {
+            serviceId: serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer'
+        }
+        dummyMessage.targetDescriptor = peerDescriptor1
+        await expect(manager1.send(dummyMessage))
+            .rejects
+            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
+    })
+
+    it('Connects and disconnects webrtc connections', async () => {
+        const msg: Message = {
+            serviceId: serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            }
+        }
+
+        const dataPromise = new Promise<void>((resolve, _reject) => {
+            manager2.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+
+        const connectedPromise1 = new Promise<void>((resolve, _reject) => {
+            manager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                //expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+
+        const connectedPromise2 = new Promise<void>((resolve, _reject) => {
+            manager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
+            manager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        msg.targetDescriptor = peerDescriptor2
+        manager1.send(msg).catch((_e) => { })
+
+        await Promise.all([dataPromise, connectedPromise1, connectedPromise2])
+
+        // @ts-expect-error private field
+        manager1.closeConnection(peerDescriptor2)
+
+        await Promise.all([disconnectedPromise1, disconnectedPromise2])
+
+    }, 20000)
+
+    it('Disconnects webrtcconnection while being connected', async () => {
+        const msg: Message = {
+            serviceId: serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+        }
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        msg.targetDescriptor = peerDescriptor2
+        manager1.send(msg).catch((e) => {
+            expect(e.code).toEqual('CONNECTION_FAILED')
+        })
+
+        // @ts-expect-error private field
+        manager1.closeConnection(peerDescriptor2)
+
+        await disconnectedPromise1
+
+    }, 20000)
+})

package/test/integration/WebRtcConnectorRpc.test.ts

@@ -0,0 +1,145 @@
+import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { WebRtcConnectorServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer,
+    WebRtcConnectionRequest
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Empty } from '../../src/proto/google/protobuf/empty'
+import { generateId } from '../utils/utils'
+import { IWebRtcConnectorService } from '../../src/proto/packages/dht/protos/DhtRpc.server'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { waitForCondition } from '@streamr/utils'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+describe('WebRTC rpc messages', () => {
+    let rpcCommunicator1: RpcCommunicator
+    let rpcCommunicator2: RpcCommunicator
+    let client: ProtoRpcClient<WebRtcConnectorServiceClient>
+
+    let requestConnectionCounter: number
+    let rtcOfferCounter: number
+    let rtcAnswerCounter: number
+    let iceCandidateCounter: number
+
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: generateId('peer1'),
+        type: 0
+    }
+
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: generateId('peer2'),
+        type: 0
+    }
+
+    beforeEach(() => {
+        requestConnectionCounter = 0
+        rtcOfferCounter = 0
+        rtcAnswerCounter = 0
+        iceCandidateCounter = 0
+
+        rpcCommunicator1 = new RpcCommunicator()
+        const serverFunctions: IWebRtcConnectorService = {
+
+            requestConnection: async (_urequest: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> => {
+                requestConnectionCounter += 1
+                const res: Empty = {}
+                return res
+            },
+
+            rtcOffer: async (_urequest: RtcOffer, _context: ServerCallContext): Promise<Empty> => {
+                rtcOfferCounter += 1
+                const res: Empty = {}
+                return res
+            },
+
+            rtcAnswer: async (_urequest: RtcAnswer, _context: ServerCallContext): Promise<Empty> => {
+                rtcAnswerCounter += 1
+                const res: Empty = {}
+                return res
+            },
+
+            iceCandidate: async (_urequest: IceCandidate, _context: ServerCallContext): Promise<Empty> => {
+                iceCandidateCounter += 1
+                const res: Empty = {}
+                return res
+            }
+        }
+
+        rpcCommunicator2 = new RpcCommunicator()
+        rpcCommunicator2.registerRpcNotification(RtcOffer, 'rtcOffer', serverFunctions.rtcOffer)
+        rpcCommunicator2.registerRpcNotification(RtcAnswer, 'rtcAnswer', serverFunctions.rtcAnswer)
+        rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
+        rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
+
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            rpcCommunicator2.handleIncomingMessage(message)
+        })
+
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            rpcCommunicator1.handleIncomingMessage(message)
+        })
+
+        client = toProtoRpcClient(new WebRtcConnectorServiceClient(rpcCommunicator1.getRpcClientTransport()))
+    })
+
+    afterEach(async () => {
+        await rpcCommunicator1.stop()
+        await rpcCommunicator2.stop()
+    })
+
+    it('send connectionRequest', async () => {
+        client.requestConnection({
+            requester: peerDescriptor1,
+            target: peerDescriptor2,
+            connectionId: 'connectionRequest'
+        },
+        { targetDescriptor: peerDescriptor2, notification: true }
+        )
+
+        await waitForCondition(() => requestConnectionCounter === 1)
+    })
+
+    it('send rtcOffer', async () => {
+        client.rtcOffer({
+            requester: peerDescriptor1,
+            target: peerDescriptor2,
+            connectionId: 'rtcOffer',
+            description: 'aaaaaa'
+        },
+        { targetDescriptor: peerDescriptor2, notification: true }
+        )
+
+        await waitForCondition(() => rtcOfferCounter === 1)
+    })
+
+    it('send rtcAnswer', async () => {
+        client.rtcAnswer({
+            requester: peerDescriptor1,
+            target: peerDescriptor2,
+            connectionId: 'rtcOffer',
+            description: 'aaaaaa'
+        },
+        { targetDescriptor: peerDescriptor2, notification: true }
+        )
+
+        await waitForCondition(() => rtcAnswerCounter === 1)
+    })
+
+    it('send iceCandidate', async () => {
+        client.iceCandidate({
+            requester: peerDescriptor1,
+            target: peerDescriptor2,
+            connectionId: 'rtcOffer',
+            candidate: 'aaaaaa',
+            mid: 'asdasdasdasdasd'
+        },
+        { targetDescriptor: peerDescriptor2, notification: true }
+        )
+
+        await waitForCondition(() => iceCandidateCounter === 1)
+    })
+})

package/test/integration/WebSocket.test.ts

@@ -0,0 +1,64 @@
+/* eslint-disable no-console */
+
+import { WebSocketServer } from '../../src/connection/WebSocket/WebSocketServer'
+import { IConnection } from '../../src/connection/IConnection'
+import { ClientWebSocket } from '../../src/connection/WebSocket/ClientWebSocket'
+import { Logger } from '@streamr/utils'
+
+const logger = new Logger(module)
+
+describe('WebSocket', () => {
+
+    const webSocketServer = new WebSocketServer()
+    const clientWebSocket = new ClientWebSocket()
+
+    beforeAll(async () => {
+        await webSocketServer.start(9999)
+    })
+
+    it('Happy path', (done) => {
+            
+        webSocketServer.on('connected', (serverConnection: IConnection) => {
+            const time = Date.now()
+            logger.info('server side sendind msg at ' + time)
+            serverConnection.send(Uint8Array.from([1, 2, 3, 4]))
+        
+            const time2 = Date.now()
+            logger.info('server side setting listeners at ' + time2)
+            
+            serverConnection.on('data', (bytes: Uint8Array) => {
+                const time = Date.now()
+                logger.info('server side receiving message at ' + time)
+
+                logger.info('server received:' + JSON.stringify(bytes))
+               
+                expect(bytes.toString()).toBe('1,2,3,4')
+                logger.info('calling done()')
+                done()
+            })
+        })
+        
+        clientWebSocket.on('connected', () => {
+            const time = Date.now()
+            logger.info('client side setting listeners at ' + time)
+            
+            clientWebSocket.on('data', (bytes: Uint8Array) => {
+                const time = Date.now()
+                logger.info('client side receiving message at ' + time)
+
+                logger.info('client received: ' + JSON.stringify(bytes))
+                expect(bytes.toString()).toBe('1,2,3,4')
+                
+                const time2 = Date.now()
+                logger.info('client side sendind msg at ' + time2)
+                clientWebSocket.send(Uint8Array.from([1, 2, 3, 4]))
+            })
+        })
+
+        clientWebSocket.connect('ws://127.0.0.1:9999')
+    })
+
+    afterAll(async () => {
+        await webSocketServer.stop()
+    })
+})

package/test/integration/WebSocketConnectionManagement.test.ts

@@ -0,0 +1,131 @@
+/* eslint-disable promise/no-nesting */
+
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import { ConnectionType } from '../../src/connection/IConnection'
+import { ITransport } from '../../src/transport/ITransport'
+import * as Err from '../../src/helpers/errors'
+import { waitForCondition } from '@streamr/utils'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+describe('WebSocket Connection Management', () => {
+
+    const serviceId = 'test'
+    let wsServerManager: ConnectionManager
+    let noWsServerManager: ConnectionManager
+
+    const simulator = new Simulator()
+
+    const wsServerConnectorPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('peerWithServer').value,
+        type: NodeType.NODEJS,
+        websocket: {
+            ip: '127.0.0.1',
+            port: 12223
+        }
+    }
+
+    const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('peerWithoutServer').value,
+        type: NodeType.NODEJS,
+    }
+
+    let connectorTransport1: ITransport
+    let connectorTransport2: ITransport
+
+    beforeEach(async () => {
+
+        connectorTransport1 = new ConnectionManager({ ownPeerDescriptor: wsServerConnectorPeerDescriptor, simulator: simulator })
+        connectorTransport2 = new ConnectionManager({ ownPeerDescriptor: noWsServerConnectorPeerDescriptor, simulator: simulator })
+
+        const config1 = {
+            transportLayer: connectorTransport1,
+            webSocketHost: '127.0.0.1',
+            webSocketPort: 12223,
+        }
+        const config2 = {
+            transportLayer: connectorTransport2
+        }
+
+        wsServerManager = new ConnectionManager(config1)
+        noWsServerManager = new ConnectionManager(config2)
+
+        await wsServerManager.start((_response) => wsServerConnectorPeerDescriptor)
+        await noWsServerManager.start((_response) => noWsServerConnectorPeerDescriptor)
+    })
+
+    afterEach(async () => {
+        await wsServerManager.stop()
+        await noWsServerManager.stop()
+        await connectorTransport1.stop()
+        await connectorTransport2.stop()
+    })
+
+    it('Can open connections to serverless peer', (done) => {
+        const dummyMessage: Message = {
+            serviceId: serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer',
+            targetDescriptor: noWsServerConnectorPeerDescriptor
+        }
+        noWsServerManager.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_SERVER)
+            expect(noWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_CLIENT)
+
+            done()
+        })
+
+        wsServerManager.send(dummyMessage)
+    })
+
+    it('Can open connections to peer with server', async () => {
+        const dummyMessage: Message = {
+            serviceId: serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer',
+            targetDescriptor: wsServerConnectorPeerDescriptor
+        }
+        await noWsServerManager.send(dummyMessage)
+        await waitForCondition(
+            () => {
+                return (!!wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)
+                    && wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)!.connectionType === ConnectionType.WEBSOCKET_SERVER)
+            }
+        )
+        await waitForCondition(
+            () => noWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType === ConnectionType.WEBSOCKET_CLIENT
+        )
+    })
+
+    it('Connecting to self throws', async () => {
+        const dummyMessage: Message = {
+            serviceId: serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer',
+            targetDescriptor: noWsServerConnectorPeerDescriptor
+        }
+        await expect(noWsServerManager.send(dummyMessage))
+            .rejects
+            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
+
+        dummyMessage.targetDescriptor = wsServerConnectorPeerDescriptor
+        await expect(wsServerManager.send(dummyMessage))
+            .rejects
+            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
+    })
+})

package/test/integration/WebSocketConnectorRpc.test.ts

@@ -0,0 +1,86 @@
+import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { WebSocketConnectorServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { generateId } from '../utils/utils'
+import {
+    PeerDescriptor,
+    WebSocketConnectionRequest,
+    WebSocketConnectionResponse
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { MockWebSocketConnectorRpc } from '../utils/utils'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+describe('WebSocketConnectorRpc', () => {
+    let rpcCommunicator1: RpcCommunicator
+    let rpcCommunicator2: RpcCommunicator
+    let client1: ProtoRpcClient<WebSocketConnectorServiceClient>
+    let client2: ProtoRpcClient<WebSocketConnectorServiceClient>
+
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: generateId('peer1'),
+        type: 0
+    }
+
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: generateId('peer2'),
+        type: 0
+    }
+
+    beforeEach(() => {
+        rpcCommunicator1 = new RpcCommunicator()
+        rpcCommunicator1.registerRpcMethod(
+            WebSocketConnectionRequest,
+            WebSocketConnectionResponse,
+            'requestConnection',
+            MockWebSocketConnectorRpc.requestConnection
+        )
+
+        rpcCommunicator2 = new RpcCommunicator()
+        rpcCommunicator2.registerRpcMethod(
+            WebSocketConnectionRequest,
+            WebSocketConnectionResponse,
+            'requestConnection',
+            MockWebSocketConnectorRpc.requestConnection
+        )
+
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            rpcCommunicator2.handleIncomingMessage(message)
+        })
+
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            rpcCommunicator1.handleIncomingMessage(message)
+        })
+
+        client1 = toProtoRpcClient(new WebSocketConnectorServiceClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new WebSocketConnectorServiceClient(rpcCommunicator2.getRpcClientTransport()))
+    })
+
+    afterEach(async () => {
+        await rpcCommunicator1.stop()
+        await rpcCommunicator2.stop()
+    })
+
+    it('Happy path', async () => {
+        const response1 = client1.requestConnection({
+            requester: peerDescriptor1,
+            target: peerDescriptor2,
+            ip: '127.0.0.1',
+            port: 9099
+        },
+        { targetDescriptor: peerDescriptor2 },
+        )
+        const res1 = await response1
+        await (expect(res1.accepted)).toEqual(true)
+
+        const response2 = client2.requestConnection({
+            requester: peerDescriptor2,
+            target: peerDescriptor1,
+            ip: '127.0.0.1',
+            port: 9111
+        },
+        { targetDescriptor: peerDescriptor1 },
+        )
+        const res2 = await response2
+        await (expect(res2.accepted)).toEqual(true)
+    })
+})