node-datachannel 0.5.5 → 0.7.0

package/src/web-socket-wrapper.h

@@ -0,0 +1,62 @@
+#ifndef WEB_SOCKET_WRAPPER_H
+#define WEB_SOCKET_WRAPPER_H
+
+#include <iostream>
+#include <string>
+#include <variant>
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
+
+class WebSocketWrapper : public Napi::ObjectWrap<WebSocketWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  WebSocketWrapper(const Napi::CallbackInfo &info);
+  ~WebSocketWrapper();
+
+  // Functions
+  void open(const Napi::CallbackInfo &info);
+  void close(const Napi::CallbackInfo &info);
+  Napi::Value sendMessage(const Napi::CallbackInfo &info);
+  Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
+  Napi::Value isOpen(const Napi::CallbackInfo &info);
+  Napi::Value bufferedAmount(const Napi::CallbackInfo &info);
+  Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
+  void setBufferedAmountLowThreshold(const Napi::CallbackInfo &info);
+
+  // Callbacks
+  void onOpen(const Napi::CallbackInfo &info);
+  void onClosed(const Napi::CallbackInfo &info);
+  void onError(const Napi::CallbackInfo &info);
+  void onBufferedAmountLow(const Napi::CallbackInfo &info);
+  void onMessage(const Napi::CallbackInfo &info);
+
+  // Close all existing WebSockets
+  static void CloseAll();
+
+  // Reset all Callbacks for existing WebSockets
+  static void CleanupAll();
+
+private:
+  static std::unordered_set<WebSocketWrapper *> instances;
+
+  void doClose();
+  void doCleanup();
+
+  std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnBufferedAmountLowCallback = nullptr;
+  std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
+};
+
+#endif // WEB_SOCKET_WRAPPER_H

package/test/jest-tests/basic.test.js

@@ -0,0 +1,37 @@
+import * as nodeDataChannel from '../../lib';
+
+describe('Module Definition', () => {
+    test('Module Defined', () => {
+        expect(nodeDataChannel).toBeDefined();
+        expect(nodeDataChannel.initLogger).toBeDefined();
+        expect(nodeDataChannel.PeerConnection).toBeDefined();
+        expect(typeof nodeDataChannel.PeerConnection).toBe('function');
+        expect(nodeDataChannel.DataChannel).toBeDefined();
+        expect(typeof nodeDataChannel.DataChannel).toBe('function');
+    });
+});
+
+describe('PeerConnection Classes', () => {
+    test('Create PeerConnection', () => {
+        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
+        expect(peer).toBeDefined();
+        expect(peer.onStateChange).toBeDefined();
+        expect(peer.createDataChannel).toBeDefined();
+
+        peer.close();
+    });
+
+    test('Create Data Channel', () => {
+        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
+        let dc = peer.createDataChannel('test', { protocol: 'test-protocol' });
+        expect(dc).toBeDefined();
+        expect(dc.getId()).toBeDefined();
+        expect(dc.getProtocol()).toBe('test-protocol');
+        expect(dc.getLabel()).toBe('test');
+        expect(dc.onOpen).toBeDefined();
+        expect(dc.onMessage).toBeDefined();
+
+        dc.close();
+        peer.close();
+    });
+});

package/test/jest-tests/multiple-run.test.js

@@ -0,0 +1,73 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('P2P', () => {
+    // Default is 5000 ms but we need more
+    jest.setTimeout(12000);
+
+    test.each(Array(100).fill(0))('P2P Test-%p', (i) => {
+        return new Promise((done) => {
+            let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
+            let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
+            let dc1 = null;
+            let dc2 = null;
+
+            // Mocks
+            const p1DCMessageMock = jest.fn();
+            const p2DCMessageMock = jest.fn();
+
+            // Set Callbacks
+            peer1.onStateChange(() => {
+                /** */
+            });
+            peer1.onGatheringStateChange(() => {
+                /** */
+            });
+            peer1.onLocalDescription((sdp, type) => {
+                peer2.setRemoteDescription(sdp, type);
+            });
+            peer1.onLocalCandidate((candidate, mid) => {
+                peer2.addRemoteCandidate(candidate, mid);
+            });
+
+            // Set Callbacks
+            peer2.onStateChange(() => {
+                /** */
+            });
+            peer2.onGatheringStateChange(() => {
+                /** */
+            });
+            peer2.onLocalDescription((sdp, type) => {
+                peer1.setRemoteDescription(sdp, type);
+            });
+            peer2.onLocalCandidate((candidate, mid) => {
+                peer1.addRemoteCandidate(candidate, mid);
+            });
+            peer2.onDataChannel((dc) => {
+                dc2 = dc;
+                dc2.onMessage((msg) => {
+                    p2DCMessageMock(msg);
+                    dc2.sendMessage('Hello From Peer2');
+                });
+            });
+
+            dc1 = peer1.createDataChannel('test-p2p');
+            dc1.onOpen(() => {
+                dc1.sendMessage('Hello From Peer1');
+            });
+            dc1.onMessage((msg) => {
+                p1DCMessageMock(msg);
+                peer1.close();
+                peer2.close();
+
+                // DataChannel
+                expect(p1DCMessageMock.mock.calls.length).toBe(1);
+                expect(p1DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer2');
+                expect(p2DCMessageMock.mock.calls.length).toBe(1);
+                expect(p2DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer1');
+
+                done();
+            });
+        });
+    });
+});

package/test/jest-tests/p2p.test.js

@@ -0,0 +1,99 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('P2P', () => {
+    // Default is 5000 ms but we need more
+    jest.setTimeout(30000);
+
+    test('P2P Test', () => {
+        return new Promise((done) => {
+            let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
+            let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
+            let dc1 = null;
+            let dc2 = null;
+
+            // Mocks
+            const p1StateMock = jest.fn();
+            const p1GatheringStateMock = jest.fn();
+            const p2StateMock = jest.fn();
+            const p2GatheringStateMock = jest.fn();
+            const p1SDPMock = jest.fn();
+            const p1CandidateMock = jest.fn();
+            const p2SDPMock = jest.fn();
+            const p2CandidateMock = jest.fn();
+
+            const p1DCMock = jest.fn();
+            const p1DCMessageMock = jest.fn();
+            const p2DCMock = jest.fn();
+            const p2DCMessageMock = jest.fn();
+
+            // Set Callbacks
+            peer1.onStateChange(p1StateMock);
+            peer1.onGatheringStateChange(p1GatheringStateMock);
+            peer1.onLocalDescription((sdp, type) => {
+                p1SDPMock();
+                peer2.setRemoteDescription(sdp, type);
+            });
+            peer1.onLocalCandidate((candidate, mid) => {
+                p1CandidateMock();
+                peer2.addRemoteCandidate(candidate, mid);
+            });
+
+            // Set Callbacks
+            peer2.onStateChange(p2StateMock);
+            peer2.onGatheringStateChange(p2GatheringStateMock);
+            peer2.onLocalDescription((sdp, type) => {
+                p2SDPMock();
+                peer1.setRemoteDescription(sdp, type);
+            });
+            peer2.onLocalCandidate((candidate, mid) => {
+                p2CandidateMock();
+                peer1.addRemoteCandidate(candidate, mid);
+            });
+            peer2.onDataChannel((dc) => {
+                p2DCMock();
+                dc2 = dc;
+                dc2.onMessage((msg) => {
+                    p2DCMessageMock(msg);
+                    dc2.sendMessage('Hello From Peer2');
+                });
+            });
+
+            dc1 = peer1.createDataChannel('test-p2p');
+            dc1.onOpen(() => {
+                p1DCMock();
+                dc1.sendMessage('Hello From Peer1');
+            });
+            dc1.onMessage((msg) => {
+                p1DCMessageMock(msg);
+                peer1.close();
+                peer2.close();
+
+                // State Callbacks
+                expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+                expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+                expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+                expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+                // SDP
+                expect(p1SDPMock.mock.calls.length).toBe(1);
+                expect(p2SDPMock.mock.calls.length).toBe(1);
+
+                // Candidates
+                expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+                expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+
+                // DataChannel
+                expect(p1DCMock.mock.calls.length).toBe(1);
+                expect(p1DCMessageMock.mock.calls.length).toBe(1);
+                expect(p1DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer2');
+                expect(p2DCMock.mock.calls.length).toBe(1);
+
+                expect(p2DCMessageMock.mock.calls.length).toBe(1);
+                expect(p2DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer1');
+
+                done();
+            });
+        });
+    });
+});

package/test/jest-tests/streams.test.js

@@ -0,0 +1,48 @@
+import * as nodeDataChannel from '../../lib';
+
+function waitForGathering(peer) {
+    return new Promise((resolve) => {
+        peer.onGatheringStateChange((state) => {
+            if (state === 'complete') resolve();
+        });
+        // Handle race conditions where gathering has already completed
+        if (peer.gatheringState() === 'complete') resolve();
+
+        resolve();
+    });
+}
+
+describe('DataChannel streams', () => {
+    test('can build an echo pipeline', async () => {
+        let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
+        let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
+
+        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
+        echoStream.pipe(echoStream); // Echo all received data back to the client
+
+        await waitForGathering(echoPeer);
+
+        const { sdp: echoDescSdp, type: echoDescType } = echoPeer.localDescription();
+        clientPeer.setRemoteDescription(echoDescSdp, echoDescType);
+        await waitForGathering(clientPeer);
+
+        const { sdp: clientDescSdp, type: clientDescType } = clientPeer.localDescription();
+        echoPeer.setRemoteDescription(clientDescSdp, clientDescType);
+
+        const clientChannel = await new Promise((resolve) => clientPeer.onDataChannel(resolve));
+
+        const clientResponsePromise = new Promise((resolve) => clientChannel.onMessage(resolve));
+        clientChannel.sendMessage('test message');
+
+        expect(await clientResponsePromise).toBe('test message');
+
+        clientChannel.close();
+        clientPeer.close();
+        echoPeer.close();
+    });
+});
+
+afterAll(() => {
+    // Properly cleanup so Jest does not complain about asynchronous operations that weren't stopped.
+    nodeDataChannel.cleanup();
+});

package/test/jest-tests/websocket.test.js

@@ -0,0 +1,69 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('Websocket', () => {
+    const webSocketServer = new nodeDataChannel.WebSocketServer({ bindAddress: '127.0.0.1', port: 1987 });
+    const clientSocket = new nodeDataChannel.WebSocket();
+
+    // Mocks
+    const clientOnOpenMock = jest.fn();
+    const clientOnMessageMock = jest.fn();
+    const clientOnCLosedMock = jest.fn();
+
+    const webServerOnClientMock = jest.fn();
+    const webServerOnOpenMock = jest.fn();
+    const webServerOnMessageMock = jest.fn();
+    const webServerOnClosedMock = jest.fn();
+
+    webSocketServer.onClient((serverSocket) => {
+        webServerOnClientMock();
+
+        serverSocket.onOpen(() => {
+            webServerOnOpenMock();
+        });
+
+        serverSocket.onMessage((message) => {
+            webServerOnMessageMock(message);
+            serverSocket.sendMessage('reply to ' + message);
+            serverSocket.close();
+        });
+
+        serverSocket.onClosed(() => {
+            webServerOnClosedMock();
+            serverSocket.close();
+        });
+    });
+
+    test('can create a websocket client and connect to a server', (done) => {
+        clientSocket.open('ws://127.0.0.1:1987');
+        clientSocket.onOpen(() => {
+            clientOnOpenMock();
+            clientSocket.sendMessage('Hello');
+        });
+
+        clientSocket.onMessage((message) => {
+            clientOnMessageMock(message);
+        });
+
+        clientSocket.onClosed(() => {
+            clientOnCLosedMock();
+        });
+
+        setTimeout(() => {
+            expect(clientOnMessageMock.mock.calls[0][0]).toEqual('reply to Hello');
+            expect(clientOnOpenMock.mock.calls.length).toBe(1);
+            expect(clientOnMessageMock.mock.calls.length).toBe(1);
+            expect(clientOnCLosedMock.mock.calls.length).toBe(1);
+
+            expect(webServerOnMessageMock.mock.calls[0][0]).toEqual('Hello');
+            expect(webServerOnOpenMock.mock.calls.length).toBe(1);
+            expect(webServerOnMessageMock.mock.calls.length).toBe(1);
+            expect(webServerOnClosedMock.mock.calls.length).toBe(1);
+
+            clientSocket.close();
+            webSocketServer.stop();
+
+            done();
+        }, 3000);
+    });
+});

package/test/websockets.js

@@ -0,0 +1,48 @@
+import nodeDataChannel from '../lib/index.js';
+
+nodeDataChannel.initLogger('Debug');
+nodeDataChannel.preload();
+
+const webSocketServer = new nodeDataChannel.WebSocketServer({ bindAddress: '127.0.0.1', port: 1987 });
+
+webSocketServer.onClient((serverSocket) => {
+    console.log('webSocketServer.onClient()');
+
+    serverSocket.onOpen(() => {
+        console.log('serverSocket.onOpen()');
+    });
+
+    serverSocket.onMessage((message) => {
+        console.log('serverSocket.onMessage():', message);
+        serverSocket.sendMessage('reply to ' + message);
+    });
+
+    serverSocket.onClosed(() => {
+        console.log('serverSocket.onClosed()');
+        serverSocket.close();
+    });
+});
+
+const clientSocket = new nodeDataChannel.WebSocket();
+
+clientSocket.onOpen(() => {
+    console.log('clientSocket.onOpen()');
+    clientSocket.sendMessage('Hello');
+});
+
+clientSocket.onMessage((message) => {
+    console.log('clientSocket.onMessage():', message);
+    clientSocket.close();
+    webSocketServer.stop();
+});
+
+clientSocket.onClosed(() => {
+    console.log('clientSocket.onClosed()');
+    clientSocket.close();
+});
+
+clientSocket.open('ws://127.0.0.1:1987');
+
+setTimeout(() => {
+    nodeDataChannel.cleanup();
+}, 1000);

package/test/test.js

@@ -1,185 +0,0 @@
-import { jest } from '@jest/globals';
-import * as nodeDataChannel from '../lib';
-
-describe('Module Definition', () => {
-    test('Module Defined', () => {
-        expect(nodeDataChannel).toBeDefined();
-        expect(nodeDataChannel.initLogger).toBeDefined();
-        expect(nodeDataChannel.PeerConnection).toBeDefined();
-        expect(typeof nodeDataChannel.PeerConnection).toBe('function');
-        expect(nodeDataChannel.DataChannel).toBeDefined();
-        expect(typeof nodeDataChannel.DataChannel).toBe('function');
-    });
-});
-
-describe('PeerConnection Classes', () => {
-    test('Create PeerConnection', () => {
-        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
-        expect(peer).toBeDefined();
-        expect(peer.onStateChange).toBeDefined();
-        expect(peer.createDataChannel).toBeDefined();
-
-        peer.close();
-    });
-
-    test('Create Data Channel', () => {
-        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
-        let dc = peer.createDataChannel('test', { protocol: 'test-protocol' });
-        expect(dc).toBeDefined();
-        expect(dc.getId()).toBeDefined();
-        expect(dc.getProtocol()).toBe('test-protocol');
-        expect(dc.getLabel()).toBe('test');
-        expect(dc.onOpen).toBeDefined();
-        expect(dc.onMessage).toBeDefined();
-
-        dc.close();
-        peer.close();
-    });
-});
-
-describe('P2P', () => {
-    // Default is 5000 ms but we need more
-    jest.setTimeout(30000);
-
-    let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
-    let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
-    let dc1 = null;
-    let dc2 = null;
-
-    // Mocks
-    const p1StateMock = jest.fn();
-    const p1GatheringStateMock = jest.fn();
-    const p2StateMock = jest.fn();
-    const p2GatheringStateMock = jest.fn();
-    const p1SDPMock = jest.fn();
-    const p1CandidateMock = jest.fn();
-    const p2SDPMock = jest.fn();
-    const p2CandidateMock = jest.fn();
-
-    const p1DCMock = jest.fn();
-    const p1DCMessageMock = jest.fn();
-    const p2DCMock = jest.fn();
-    const p2DCMessageMock = jest.fn();
-
-    // Set Callbacks
-    peer1.onStateChange(p1StateMock);
-    peer1.onGatheringStateChange(p1GatheringStateMock);
-    peer1.onLocalDescription((sdp, type) => {
-        p1SDPMock();
-        peer2.setRemoteDescription(sdp, type);
-    });
-    peer1.onLocalCandidate((candidate, mid) => {
-        p1CandidateMock();
-        peer2.addRemoteCandidate(candidate, mid);
-    });
-
-    // Set Callbacks
-    peer2.onStateChange(p2StateMock);
-    peer2.onGatheringStateChange(p2GatheringStateMock);
-    peer2.onLocalDescription((sdp, type) => {
-        p2SDPMock();
-        peer1.setRemoteDescription(sdp, type);
-    });
-    peer2.onLocalCandidate((candidate, mid) => {
-        p2CandidateMock();
-        peer1.addRemoteCandidate(candidate, mid);
-    });
-    peer2.onDataChannel((dc) => {
-        p2DCMock();
-        dc2 = dc;
-        dc2.onMessage((msg) => {
-            p2DCMessageMock(msg);
-        });
-        dc2.sendMessage('Hello From Peer2');
-    });
-
-    dc1 = peer1.createDataChannel('test-p2p');
-    dc1.onOpen(() => {
-        p1DCMock();
-        dc1.sendMessage('Hello From Peer1');
-    });
-    dc1.onMessage((msg) => {
-        p1DCMessageMock(msg);
-    });
-
-    test('P2P', (done) => {
-        setTimeout(() => {
-            dc1.close();
-            dc2.close();
-            peer1.close();
-            peer2.close();
-        }, 10 * 1000);
-
-        setTimeout(() => {
-            // State Callbacks
-            expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-            // SDP
-            expect(p1SDPMock.mock.calls.length).toBe(1);
-            expect(p2SDPMock.mock.calls.length).toBe(1);
-
-            // Candidates
-            expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-            // DataChannel
-            expect(p1DCMock.mock.calls.length).toBe(1);
-            expect(p1DCMessageMock.mock.calls.length).toBe(1);
-            expect(p1DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer2');
-            expect(p2DCMock.mock.calls.length).toBe(1);
-
-            expect(p2DCMessageMock.mock.calls.length).toBe(1);
-            expect(p2DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer1');
-
-            done();
-        }, 12 * 1000);
-    });
-});
-
-function waitForGathering(peer) {
-    return new Promise((resolve) => {
-        peer.onGatheringStateChange((state) => {
-            if (state === 'complete') resolve();
-        });
-        // Handle race conditions where gathering has already completed
-        if (peer.gatheringState() === 'complete') resolve();
-    });
-}
-
-describe('DataChannel streams', () => {
-    test('can build an echo pipeline', async () => {
-        let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
-        let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
-
-        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
-        echoStream.pipe(echoStream); // Echo all received data back to the client
-
-        await waitForGathering(echoPeer);
-
-        const { sdp: echoDescSdp, type: echoDescType } = echoPeer.localDescription();
-        clientPeer.setRemoteDescription(echoDescSdp, echoDescType);
-        await waitForGathering(clientPeer);
-
-        const { sdp: clientDescSdp, type: clientDescType } = clientPeer.localDescription();
-        echoPeer.setRemoteDescription(clientDescSdp, clientDescType);
-
-        const clientChannel = await new Promise((resolve) => clientPeer.onDataChannel(resolve));
-
-        const clientResponsePromise = new Promise((resolve) => clientChannel.onMessage(resolve));
-        clientChannel.sendMessage('test message');
-
-        expect(await clientResponsePromise).toBe('test message');
-
-        clientChannel.close();
-        clientPeer.close();
-        echoPeer.close();
-    });
-});
-
-afterAll(() => {
-    // Properly cleanup so Jest does not complain about asynchronous operations that weren't stopped.
-    nodeDataChannel.cleanup();
-});