@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/replication-webrtc/connection-handler-simple-peer.ts

@@ -0,0 +1,302 @@
+import { Subject } from 'rxjs';
+import {
+    ensureNotFalsy,
+    getFromMapOrThrow,
+    PROMISE_RESOLVE_VOID,
+    promiseWait,
+    randomToken
+} from '../../plugins/utils/index.ts';
+import type {
+    WebRTCConnectionHandler,
+    WebRTCConnectionHandlerCreator,
+    WebRTCMessage,
+    PeerWithMessage,
+    PeerWithResponse,
+    SyncOptionsWebRTC
+} from './webrtc-types.ts';
+
+import type {
+    SimplePeer as Peer,
+    Instance as SimplePeerInstance,
+    Options as SimplePeerOptions
+} from 'simple-peer';
+import {
+    default as _Peer
+    // @ts-ignore
+} from 'simple-peer/simplepeer.min.js';
+
+const Peer = _Peer as Peer
+
+import type { RxError, RxTypeError } from '../../types/index.d.ts';
+import { newRxError } from '../../rx-error.ts';
+
+export type SimplePeer = SimplePeerInstance & {
+    // add id to make debugging easier
+    id: string;
+};
+
+export type SimplePeerInitMessage = {
+    type: 'init';
+    yourPeerId: string;
+};
+export type SimplePeerJoinMessage = {
+    type: 'join';
+    room: string;
+};
+export type SimplePeerJoinedMessage = {
+    type: 'joined';
+    otherPeerIds: string[];
+};
+export type SimplePeerSignalMessage = {
+    type: 'signal';
+    room: string;
+    senderPeerId: string;
+    receiverPeerId: string;
+    data: string;
+};
+export type SimplePeerPingMessage = {
+    type: 'ping';
+};
+
+export type PeerMessage =
+    SimplePeerInitMessage |
+    SimplePeerJoinMessage |
+    SimplePeerJoinedMessage |
+    SimplePeerSignalMessage |
+    SimplePeerPingMessage;
+
+
+function sendMessage(ws: WebSocket, msg: PeerMessage) {
+    ws.send(JSON.stringify(msg));
+}
+
+const DEFAULT_SIGNALING_SERVER_HOSTNAME = 'signaling.rxdb.info';
+export const DEFAULT_SIGNALING_SERVER = 'wss://' + DEFAULT_SIGNALING_SERVER_HOSTNAME + '/';
+let defaultServerWarningShown = false;
+
+export type SimplePeerWrtc = SimplePeerOptions['wrtc'];
+export type SimplePeerConfig = SimplePeerOptions['config'];
+export type SimplePeerWebSocketConstructor = { new(url: string): WebSocket; };
+
+export type SimplePeerConnectionHandlerOptions = {
+    /**
+     * If no server is specified, the default signaling server
+     * from signaling.rxdb.info is used.
+     * This server is not reliable and you should use
+     * your own signaling server instead.
+     */
+    signalingServerUrl?: string;
+    wrtc?: SimplePeerWrtc;
+    config?: SimplePeerConfig;
+    webSocketConstructor?: SimplePeerWebSocketConstructor;
+};
+
+export const SIMPLE_PEER_PING_INTERVAL = 1000 * 60 * 2;
+
+/**
+ * Returns a connection handler that uses simple-peer and the signaling server.
+ */
+export function getConnectionHandlerSimplePeer({
+    signalingServerUrl = DEFAULT_SIGNALING_SERVER,
+    wrtc,
+    config,
+    webSocketConstructor = WebSocket
+}: SimplePeerConnectionHandlerOptions): WebRTCConnectionHandlerCreator<SimplePeer> {
+    ensureProcessNextTickIsSet();
+
+    if (
+        signalingServerUrl.includes(DEFAULT_SIGNALING_SERVER_HOSTNAME) &&
+        !defaultServerWarningShown
+    ) {
+        defaultServerWarningShown = true;
+        console.warn(
+            [
+                'RxDB Warning: You are using the RxDB WebRTC replication plugin',
+                'but you did not specify your own signaling server url.',
+                'By default it will use a signaling server provided by RxDB at ' + DEFAULT_SIGNALING_SERVER,
+                'This server is made for demonstration purposes and tryouts. It is not reliable and might be offline at any time.',
+                'In production you must always use your own signaling server instead.',
+                'Learn how to run your own server at https://rxdb.info/replication-webrtc.html',
+                'Also leave a ⭐ at the RxDB github repo 🙏 https://github.com/pubkey/rxdb 🙏'
+            ].join(' ')
+        );
+    }
+
+    const creator: WebRTCConnectionHandlerCreator<SimplePeer> = async (options: SyncOptionsWebRTC<any, SimplePeer>) => {
+
+        const connect$ = new Subject<SimplePeer>();
+        const disconnect$ = new Subject<SimplePeer>();
+        const message$ = new Subject<PeerWithMessage<SimplePeer>>();
+        const response$ = new Subject<PeerWithResponse<SimplePeer>>();
+        const error$ = new Subject<RxError | RxTypeError>();
+
+        const peers = new Map<string, SimplePeer>();
+        let closed = false;
+        let ownPeerId: string;
+        let socket: WebSocket | undefined = undefined;
+        createSocket();
+
+
+        /**
+         * Send ping signals to the server.
+         */
+        (async () => {
+            while (true) {
+                await promiseWait(SIMPLE_PEER_PING_INTERVAL / 2);
+                if (closed) {
+                    break;
+                }
+                if (socket) {
+                    sendMessage(socket, { type: 'ping' });
+                }
+            }
+        })();
+
+
+        /**
+         * @recursive calls it self on socket disconnects
+         * so that when the user goes offline and online
+         * again, it will recreate the WebSocket connection.
+         */
+        function createSocket() {
+            if (closed) {
+                return;
+            }
+            socket = new webSocketConstructor(signalingServerUrl);
+            socket.onclose = () => createSocket();
+            socket.onopen = () => {
+                ensureNotFalsy(socket).onmessage = (msgEvent: any) => {
+                    const msg: PeerMessage = JSON.parse(msgEvent.data as any);
+                    switch (msg.type) {
+                        case 'init':
+                            ownPeerId = msg.yourPeerId;
+                            sendMessage(ensureNotFalsy(socket), {
+                                type: 'join',
+                                room: options.topic
+                            });
+                            break;
+                        case 'joined':
+                            /**
+                             * PeerId is created by the signaling server
+                             * to prevent spoofing it.
+                             */
+                            function createPeerConnection(remotePeerId: string) {
+                                let disconnected = false;
+                                const newSimplePeer: SimplePeer = new Peer({
+                                    initiator: remotePeerId > ownPeerId,
+                                    wrtc,
+                                    config,
+                                    trickle: true
+                                }) as any;
+                                newSimplePeer.id = randomToken(10);
+                                peers.set(remotePeerId, newSimplePeer);
+
+
+                                newSimplePeer.on('signal', (signal: any) => {
+                                    sendMessage(ensureNotFalsy(socket), {
+                                        type: 'signal',
+                                        senderPeerId: ownPeerId,
+                                        receiverPeerId: remotePeerId,
+                                        room: options.topic,
+                                        data: signal
+                                    });
+                                });
+
+                                newSimplePeer.on('data', (messageOrResponse: any) => {
+                                    messageOrResponse = JSON.parse(messageOrResponse.toString());
+                                    if (messageOrResponse.result) {
+                                        response$.next({
+                                            peer: newSimplePeer,
+                                            response: messageOrResponse
+                                        });
+                                    } else {
+                                        message$.next({
+                                            peer: newSimplePeer,
+                                            message: messageOrResponse
+                                        });
+                                    }
+                                });
+
+                                newSimplePeer.on('error', (error: Error) => {
+                                    error$.next(newRxError('RC_WEBRTC_PEER', {
+                                        error
+                                    }));
+                                    newSimplePeer.destroy();
+                                    if (!disconnected) {
+                                        disconnected = true;
+                                        disconnect$.next(newSimplePeer);
+                                    }
+                                });
+
+                                newSimplePeer.on('connect', () => {
+                                    connect$.next(newSimplePeer);
+                                });
+
+                                newSimplePeer.on('close', () => {
+                                    if (!disconnected) {
+                                        disconnected = true;
+                                        disconnect$.next(newSimplePeer);
+                                    }
+                                    createPeerConnection(remotePeerId);
+                                });
+                            }
+                            msg.otherPeerIds.forEach(remotePeerId => {
+                                if (
+                                    remotePeerId === ownPeerId ||
+                                    peers.has(remotePeerId)
+                                ) {
+                                    return;
+                                } else {
+                                    createPeerConnection(remotePeerId);
+                                }
+
+                            });
+                            break;
+                        case 'signal':
+                            const peer = getFromMapOrThrow(peers, msg.senderPeerId);
+                            peer.signal(msg.data);
+                            break;
+                    }
+                }
+            }
+        };
+
+        const handler: WebRTCConnectionHandler<SimplePeer> = {
+            error$,
+            connect$,
+            disconnect$,
+            message$,
+            response$,
+            async send(peer: SimplePeer, message: WebRTCMessage) {
+                await peer.send(JSON.stringify(message));
+            },
+            close() {
+                closed = true;
+                ensureNotFalsy(socket).close();
+                error$.complete();
+                connect$.complete();
+                disconnect$.complete();
+                message$.complete();
+                response$.complete();
+                return PROMISE_RESOLVE_VOID;
+            }
+        };
+        return handler;
+    };
+    return creator;
+}
+
+
+/**
+ * Multiple people had problems because it requires to have
+ * the nextTick() method in the runtime. So we check here and
+ * throw a helpful error.
+ */
+export function ensureProcessNextTickIsSet() {
+    if (
+        typeof process === 'undefined' ||
+        typeof process.nextTick !== 'function'
+    ) {
+        throw newRxError('RC7');
+    }
+}

package/src/plugins/replication-webrtc/connection-handler-webtorrent.ts

@@ -0,0 +1,137 @@
+// /**
+//  * Uses the Webtorrent servers as signaling server, works similar to p2pt.
+//  * We could not use p2pt directly because it has so many bugs and behaves wrong in
+//  * cases with more than 2 peers.
+//  * @link https://github.com/subins2000/p2pt/blob/master/p2pt.js
+//  */
+
+// import { Subject } from 'rxjs';
+// import { PROMISE_RESOLVE_VOID, randomToken } from '../../util';
+// import { P2PConnectionHandler, P2PConnectionHandlerCreator, P2PMessage, P2PPeer, PeerWithMessage, PeerWithResponse } from './p2p-types';
+// const wrtc = require('wrtc');
+
+// const WebSocketTracker = require('bittorrent-tracker/lib/client/websocket-tracker');
+// const Client = require('bittorrent-tracker');
+// const randombytes = require('randombytes');
+// const EventEmitter = require('events');
+// const sha1 = require('simple-sha1');
+// const debug = require('debug')('p2pt');
+
+
+// export const P2PT_DEFAULT_TRACKERS = [
+//     'wss://tracker.files.fm:7073/announce',
+//     'wss://tracker.btorrent.xyz',
+//     'wss://spacetradersapi-chatbox.herokuapp.com:443/announce',
+//     'wss://qot.abiir.top:443/announce'
+// ];
+
+// export function getConnectionHandlerWebtorrent(
+//     trackers: string[] = P2PT_DEFAULT_TRACKERS,
+//     /**
+//      * Port is only required in Node.js,
+//      * not on browsers.
+//      */
+//     torrentClientPort = 18669
+// ): P2PConnectionHandlerCreator {
+//     const creator: P2PConnectionHandlerCreator = (options) => {
+//         /**
+//          * @link https://github.com/webtorrent/bittorrent-tracker#client
+//          */
+//         const requiredOpts = {
+//             infoHash: sha1.sync(options.topic).toLowerCase(),
+//             peerId: randombytes(20),
+//             announce: trackers,
+//             port: torrentClientPort,
+//             wrtc
+//         }
+//         const client = new Client(requiredOpts);
+
+//         const connect$ = new Subject<P2PPeer>();
+//         const disconnect$ = new Subject<P2PPeer>();
+//         const message$ = new Subject<PeerWithMessage>();
+//         const response$ = new Subject<PeerWithResponse>();
+
+
+//         client.on('error', function (err) {
+//             console.error('fatal client error! ' + requiredOpts.peerId.toString('hex'));
+//             console.log(err.message)
+//         })
+
+//         client.on('warning', function (err) {
+//             // a tracker was unavailable or sent bad data to the client. you can probably ignore it
+//             console.log(err.message)
+//         })
+
+//         client.on('update', function (data) {
+//             console.log('got an announce response from tracker: ' + data.announce)
+//             console.log('number of seeders in the swarm: ' + data.complete)
+//             console.log('number of leechers in the swarm: ' + data.incomplete)
+//         });
+
+//         const knownPeers = new Set<string>();
+//         client.on('peer', function (peer: P2PPeer) {
+//             console.log('found a peer: ' + peer.id + '    ' + requiredOpts.peerId.toString('hex')) // 85.10.239.191:48623
+//             if (knownPeers.has(peer.id)) {
+//                 return;
+//             }
+//             knownPeers.add(peer.id);
+//             peer.once('connect', () => {
+//                 connect$.next(peer);
+//             });
+//             peer.on('data', (data: Buffer) => {
+//                 console.log('# GOT DATA FROM PEER:');
+//                 const messageOrResponse = JSON.parse(data as any);
+//                 console.dir(messageOrResponse);
+//                 if (messageOrResponse.result) {
+//                     response$.next({
+//                         peer: peer as any,
+//                         response: messageOrResponse
+//                     });
+//                 } else {
+//                     message$.next({
+//                         peer,
+//                         message: JSON.parse(data)
+//                     });
+//                 }
+//             });
+//             peer.on('signal', (signal) => {
+//                 console.log('GOT SIGNAL: ' + requiredOpts.peerId.toString('hex'));
+//                 console.dir(signal);
+//                 client.signal(signal);
+//                 client.update();
+//                 client.scrape();
+//             });
+//         });
+
+//         client.on('scrape', function (data) {
+//             console.log('number of leechers in the swarm: ' + data.incomplete)
+//         })
+
+//         const handler: P2PConnectionHandler = {
+//             connect$,
+//             disconnect$,
+//             message$,
+//             response$,
+//             async send(peer: P2PPeer, message: P2PMessage) {
+//                 await peer.send(JSON.stringify(message));
+//             },
+//             close() {
+//                 client.close();
+//                 connect$.complete();
+//                 disconnect$.complete();
+//                 message$.complete();
+//                 response$.complete();
+//                 return PROMISE_RESOLVE_VOID;
+//             }
+//         }
+//         client.start();
+//         client.update();
+//         client.scrape();
+//         setInterval(() => {
+//             // client.update();
+//         }, 10000);
+//         return handler;
+//     };
+
+//     return creator;
+// }