mongodb-livedata-server 0.0.1

package/meteor/ddp/crossbar.ts

@@ -0,0 +1,148 @@
+import { clone, equals } from "../ejson/ejson";
+
+// A "crossbar" is a class that provides structured notification registration.
+// See _match for the definition of how a notification matches a trigger.
+// All notifications and triggers must have a string key named 'collection'.
+
+export class _Crossbar {
+    private listenersByCollection: Record<string, any> = {};
+    private listenersByCollectionCount: Record<string, number> = {};
+    private nextId: number;
+
+    constructor(options) {
+        options = options || {};
+
+        this.nextId = 1;
+    }
+
+    // msg is a trigger or a notification
+    _collectionForMessage(msg: { collection?: any }) {
+        if (!msg.hasOwnProperty('collection')) {
+            return '';
+        } else if (typeof (msg.collection) === 'string') {
+            if (msg.collection === '')
+                throw Error("Message has empty collection!");
+            return msg.collection;
+        } else {
+            throw Error("Message has non-string collection!");
+        }
+    }
+
+    // Listen for notification that match 'trigger'. A notification
+    // matches if it has the key-value pairs in trigger as a
+    // subset. When a notification matches, call 'callback', passing
+    // the actual notification.
+    //
+    // Returns a listen handle, which is an object with a method
+    // stop(). Call stop() to stop listening.
+    //
+    // XXX It should be legal to call fire() from inside a listen()
+    // callback?
+    listen(trigger, callback) {
+        var self = this;
+        var id = self.nextId++;
+
+        var collection = self._collectionForMessage(trigger);
+        var record = { trigger: clone(trigger), callback: callback };
+        if (!self.listenersByCollection.hasOwnProperty(collection)) {
+            self.listenersByCollection[collection] = {};
+            self.listenersByCollectionCount[collection] = 0;
+        }
+        self.listenersByCollection[collection][id] = record;
+        self.listenersByCollectionCount[collection]++;
+
+        return {
+            stop: function () {
+                delete self.listenersByCollection[collection][id];
+                self.listenersByCollectionCount[collection]--;
+                if (self.listenersByCollectionCount[collection] === 0) {
+                    delete self.listenersByCollection[collection];
+                    delete self.listenersByCollectionCount[collection];
+                }
+            }
+        };
+    }
+
+    // Fire the provided 'notification' (an object whose attribute
+    // values are all JSON-compatibile) -- inform all matching listeners
+    // (registered with listen()).
+    //
+    // If fire() is called inside a write fence, then each of the
+    // listener callbacks will be called inside the write fence as well.
+    //
+    // The listeners may be invoked in parallel, rather than serially.
+    fire(notification: Record<string, any>) {
+        var self = this;
+
+        var collection = self._collectionForMessage(notification);
+
+        if (!self.listenersByCollection.hasOwnProperty(collection)) {
+            return;
+        }
+
+        var listenersForCollection = self.listenersByCollection[collection];
+        var callbackIds = [];
+        Object.entries<{ trigger: Record<string, any> }>(listenersForCollection).forEach(function ([id, l]) {
+            if (self._matches(notification, l.trigger)) {
+                callbackIds.push(id);
+            }
+        });
+
+        // Listener callbacks can yield, so we need to first find all the ones that
+        // match in a single iteration over self.listenersByCollection (which can't
+        // be mutated during this iteration), and then invoke the matching
+        // callbacks, checking before each call to ensure they haven't stopped.
+        // Note that we don't have to check that
+        // self.listenersByCollection[collection] still === listenersForCollection,
+        // because the only way that stops being true is if listenersForCollection
+        // first gets reduced down to the empty object (and then never gets
+        // increased again).
+        for (const id of callbackIds) {
+            if (listenersForCollection.hasOwnProperty(id)) {
+                listenersForCollection[id].callback(notification);
+            }
+        }
+    }
+
+    // A notification matches a trigger if all keys that exist in both are equal.
+    //
+    // Examples:
+    //  N:{collection: "C"} matches T:{collection: "C"}
+    //    (a non-targeted write to a collection matches a
+    //     non-targeted query)
+    //  N:{collection: "C", id: "X"} matches T:{collection: "C"}
+    //    (a targeted write to a collection matches a non-targeted query)
+    //  N:{collection: "C"} matches T:{collection: "C", id: "X"}
+    //    (a non-targeted write to a collection matches a
+    //     targeted query)
+    //  N:{collection: "C", id: "X"} matches T:{collection: "C", id: "X"}
+    //    (a targeted write to a collection matches a targeted query targeted
+    //     at the same document)
+    //  N:{collection: "C", id: "X"} does not match T:{collection: "C", id: "Y"}
+    //    (a targeted write to a collection does not match a targeted query
+    //     targeted at a different document)
+    _matches(notification: Record<string, any>, trigger: Record<string, any>) {
+        // Most notifications that use the crossbar have a string `collection` and
+        // maybe an `id` that is a string or ObjectID. We're already dividing up
+        // triggers by collection, but let's fast-track "nope, different ID" (and
+        // avoid the overly generic EJSON.equals). This makes a noticeable
+        // performance difference; see https://github.com/meteor/meteor/pull/3697
+        if (typeof (notification.id) === 'string' && typeof (trigger.id) === 'string' && notification.id !== trigger.id) {
+            return false;
+        }
+
+        return Object.entries(trigger).every(([key, triggerValue]) => {
+            return !notification.hasOwnProperty(key) || equals(triggerValue, notification[key]);
+        });
+    }
+
+}
+
+// The "invalidation crossbar" is a specific instance used by the DDP server to
+// implement write fence notifications. Listener callbacks on this crossbar
+// should call beginWrite on the current write fence before they return, if they
+// want to delay the write fence from firing (ie, the DDP method-data-updated
+// message from being sent).
+export const _InvalidationCrossbar = new _Crossbar({
+    factName: "invalidation-crossbar-listeners"
+});

package/meteor/ddp/heartbeat.ts

@@ -0,0 +1,97 @@
+// Heartbeat options:
+//   heartbeatInterval: interval to send pings, in milliseconds.
+//   heartbeatTimeout: timeout to close the connection if a reply isn't
+//     received, in milliseconds.
+//   sendPing: function to call to send a ping on the connection.
+//   onTimeout: function to call to close the connection.
+
+export class Heartbeat {
+    private heartbeatInterval: number;
+    private heartbeatTimeout: number;
+    private _sendPing: Function;
+    private _onTimeout: Function;
+    private _seenPacket: boolean;
+    private _heartbeatIntervalHandle: any;
+    private _heartbeatTimeoutHandle: any;
+
+    constructor(options) {
+      this.heartbeatInterval = options.heartbeatInterval;
+      this.heartbeatTimeout = options.heartbeatTimeout;
+      this._sendPing = options.sendPing;
+      this._onTimeout = options.onTimeout;
+      this._seenPacket = false;
+  
+      this._heartbeatIntervalHandle = null;
+      this._heartbeatTimeoutHandle = null;
+    }
+  
+    stop() {
+      this._clearHeartbeatIntervalTimer();
+      this._clearHeartbeatTimeoutTimer();
+    }
+  
+    start() {
+      this.stop();
+      this._startHeartbeatIntervalTimer();
+    }
+  
+    _startHeartbeatIntervalTimer() {
+      this._heartbeatIntervalHandle = setInterval(
+        () => this._heartbeatIntervalFired(),
+        this.heartbeatInterval
+      );
+    }
+  
+    _startHeartbeatTimeoutTimer() {
+      this._heartbeatTimeoutHandle = setTimeout(
+        () => this._heartbeatTimeoutFired(),
+        this.heartbeatTimeout
+      );
+    }
+  
+    _clearHeartbeatIntervalTimer() {
+      if (this._heartbeatIntervalHandle) {
+        clearInterval(this._heartbeatIntervalHandle);
+        this._heartbeatIntervalHandle = null;
+      }
+    }
+  
+    _clearHeartbeatTimeoutTimer() {
+      if (this._heartbeatTimeoutHandle) {
+        clearTimeout(this._heartbeatTimeoutHandle);
+        this._heartbeatTimeoutHandle = null;
+      }
+    }
+  
+    // The heartbeat interval timer is fired when we should send a ping.
+    _heartbeatIntervalFired() {
+      // don't send ping if we've seen a packet since we last checked,
+      // *or* if we have already sent a ping and are awaiting a timeout.
+      // That shouldn't happen, but it's possible if
+      // `this.heartbeatInterval` is smaller than
+      // `this.heartbeatTimeout`.
+      if (! this._seenPacket && ! this._heartbeatTimeoutHandle) {
+        this._sendPing();
+        // Set up timeout, in case a pong doesn't arrive in time.
+        this._startHeartbeatTimeoutTimer();
+      }
+      this._seenPacket = false;
+    }
+  
+    // The heartbeat timeout timer is fired when we sent a ping, but we
+    // timed out waiting for the pong.
+    _heartbeatTimeoutFired() {
+      this._heartbeatTimeoutHandle = null;
+      this._onTimeout();
+    }
+  
+    messageReceived() {
+      // Tell periodic checkin that we have seen a packet, and thus it
+      // does not need to send a ping this cycle.
+      this._seenPacket = true;
+      // If we were waiting for a pong, we got it.
+      if (this._heartbeatTimeoutHandle) {
+        this._clearHeartbeatTimeoutTimer();
+      }
+    }
+  };