Merge pull request #56 from Meteor-Community-Packages/0.6.0-refactor

0.6.0 refactor

.github/workflows/tests.yml

@@ -0,0 +1,34 @@
+name: Test suite
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        meteorRelease:
+          - '--release 1.12.1'
+          - '--release 2.3'
+          - '--release 2.8.1'
+          - '--release 2.16'
+          # Latest version
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '16.x'
+
+      - name: Install Dependencies
+        run: |
+          curl https://install.meteor.com | /bin/sh
+          npm i -g @zodern/mtest
+      - name: Run Tests
+        run: |
+          mtest --package ./ --once ${{ matrix.meteorRelease }}

History.md

@@ -1,4 +1,18 @@
 ## vNEXT
+
+## v0.6.0
+
+- Code Format Refactor
+- Changed Deps to Tracker (#49)
+- Only show log output if running in development
+- Added _timeSync Meteor Method for doing timesync over DDP instead of HTTP
+- Auto switch to DDP after initial HTTP timesync to improve subsequent round trip times
+- Added option TimeSync.forceDDP to always use DDP, even for first sync (which may be slow!)
+- Shortened resync interval from 1 minute to 30 seconds when using DDP.
+- Added tests for DDP and HTTP sync
+- Added option to set the timesync URL using `TimeSync.setSyncUrl`
+- Removed IE8 compat function
+
 ## v0.5.5
 
 - Added compatibility for Meteor 3.0-beta.7
@@ -32,11 +46,11 @@
 
 ## v0.3.4
 
-- Explicitly pull in client-side `check` for Meteor 1.2 apps. 
+- Explicitly pull in client-side `check` for Meteor 1.2 apps.
 
 ## v0.3.3
 
-- Be more robust with sync url when outside of Cordova. (#30) 
+- Be more robust with sync url when outside of Cordova. (#30)
 
 ## v0.3.2
 

client/index.js

@@ -0,0 +1,6 @@
+import { TimeSync, SyncInternals } from './timesync-client';
+
+export {
+	TimeSync,
+	SyncInternals,
+};

client/timesync-client.js

@@ -0,0 +1,194 @@
+import { Meteor } from 'meteor/meteor';
+import { Tracker } from 'meteor/tracker';
+import { HTTP } from 'meteor/http';
+
+TimeSync = {
+  loggingEnabled: Meteor.isDevelopment,
+  forceDDP: false
+};
+
+function log( /* arguments */ ) {
+  if (TimeSync.loggingEnabled) {
+    Meteor._debug.apply(this, arguments);
+  }
+}
+
+const defaultInterval = 1000;
+
+// Internal values, exported for testing
+SyncInternals = {
+  offset: undefined,
+  roundTripTime: undefined,
+  offsetTracker: new Tracker.Dependency(),
+  syncTracker: new Tracker.Dependency(),
+  isSynced: false,
+  usingDDP: false,
+  timeTick: {},
+  getDiscrepancy: function (lastTime, currentTime, interval) {
+    return currentTime - (lastTime + interval)
+  }
+};
+
+SyncInternals.timeTick[defaultInterval] = new Tracker.Dependency();
+
+const maxAttempts = 5;
+let attempts = 0;
+
+/*
+  This is an approximation of
+  http://en.wikipedia.org/wiki/Network_Time_Protocol
+
+  If this turns out to be more accurate under the connect handlers,
+  we should try taking multiple measurements.
+ */
+
+let syncUrl;
+
+TimeSync.setSyncUrl = function (url) {
+  if (url) {
+    syncUrl = url;
+  } else if (Meteor.isCordova || Meteor.isDesktop) {
+    // Only use Meteor.absoluteUrl for Cordova and Desktop; see
+    // https://github.com/meteor/meteor/issues/4696
+    // https://github.com/mizzao/meteor-timesync/issues/30
+    // Cordova should never be running out of a subdirectory...
+    syncUrl = Meteor.absoluteUrl('_timesync');
+  } else {
+    // Support Meteor running in relative paths, based on computed root url prefix
+    // https://github.com/mizzao/meteor-timesync/pull/40
+    const basePath = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || '';
+    syncUrl = basePath + '/_timesync';
+  }
+};
+TimeSync.getSyncUrl = function () {
+  return syncUrl;
+}
+TimeSync.setSyncUrl();
+
+const updateOffset = function () {
+  const t0 = Date.now();
+  if (TimeSync.forceDDP || SyncInternals.useDDP) {
+    Meteor.call('_timeSync', function (err, res) {
+      handleResponse(t0, err, res);
+    });
+  } else {
+    HTTP.get(syncUrl, function (err, res) {
+      handleResponse(t0, err, res);
+    });
+  }
+};
+
+const handleResponse = function (t0, err, res) {
+  const t3 = Date.now(); // Grab this now
+  if (err) {
+    // We'll still use our last computed offset if is defined
+    log('Error syncing to server time: ', err);
+    if (++attempts <= maxAttempts) {
+      Meteor.setTimeout(TimeSync.resync, 1000);
+    } else {
+      log('Max number of time sync attempts reached. Giving up.');
+    }
+    return;
+  }
+
+  attempts = 0; // It worked
+  const response = res.content || res;
+  const ts = parseInt(response, 10);
+  SyncInternals.isSynced = true;
+  SyncInternals.offset = Math.round(((ts - t0) + (ts - t3)) / 2);
+  SyncInternals.roundTripTime = t3 - t0; // - (ts - ts) which is 0
+  SyncInternals.offsetTracker.changed();
+}
+
+// Reactive variable for server time that updates every second.
+TimeSync.serverTime = function (clientTime, interval) {
+  check(interval, Match.Optional(Match.Integer));
+  // If a client time is provided, we don't need to depend on the tick.
+  if (!clientTime) getTickDependency(interval || defaultInterval).depend();
+
+  SyncInternals.offsetTracker.depend(); // depend on offset to enable reactivity
+  // Convert Date argument to epoch as necessary
+  return (+clientTime || Date.now()) + SyncInternals.offset;
+};
+
+// Reactive variable for the difference between server and client time.
+TimeSync.serverOffset = function () {
+  SyncInternals.offsetTracker.depend();
+  return SyncInternals.offset;
+};
+
+TimeSync.roundTripTime = function () {
+  SyncInternals.offsetTracker.depend();
+  return SyncInternals.roundTripTime;
+};
+
+TimeSync.isSynced = function () {
+  SyncInternals.offsetTracker.depend();
+  return SyncInternals.isSynced;
+};
+
+let resyncIntervalId = null;
+
+TimeSync.resync = function () {
+  if (resyncIntervalId !== null) Meteor.clearInterval(resyncIntervalId);
+
+  updateOffset();
+  resyncIntervalId = Meteor.setInterval(updateOffset, (SyncInternals.useDDP) ? 300000 : 600000);
+};
+
+// Run this as soon as we load, even before Meteor.startup()
+// Run again whenever we reconnect after losing connection
+let wasConnected = false;
+
+Tracker.autorun(function () {
+  const connected = Meteor.status().connected;
+  if (connected && !wasConnected) TimeSync.resync();
+  wasConnected = connected;
+  SyncInternals.useDDP = connected;
+});
+
+// Resync if unexpected change by more than a few seconds. This needs to be
+// somewhat lenient, or a CPU-intensive operation can trigger a re-sync even
+// when the offset is still accurate. In any case, we're not going to be able to
+// catch very small system-initiated NTP adjustments with this, anyway.
+const tickCheckTolerance = 5000;
+
+let lastClientTime = Date.now();
+
+// Set up a new interval for any amount of reactivity.
+function getTickDependency(interval) {
+
+  if (!SyncInternals.timeTick[interval]) {
+    const dep = new Tracker.Dependency();
+
+    Meteor.setInterval(function () {
+      dep.changed();
+    }, interval);
+
+    SyncInternals.timeTick[interval] = dep;
+  }
+
+  return SyncInternals.timeTick[interval];
+}
+
+// Set up special interval for the default tick, which also watches for re-sync
+Meteor.setInterval(function () {
+  const currentClientTime = Date.now();
+  const discrepancy = SyncInternals.getDiscrepancy(lastClientTime, currentClientTime, defaultInterval);
+
+  if (Math.abs(discrepancy) < tickCheckTolerance) {
+    // No problem here, just keep ticking along
+    SyncInternals.timeTick[defaultInterval].changed();
+  } else {
+    // resync on major client clock changes
+    // based on http://stackoverflow.com/a/3367542/1656818
+    log('Clock discrepancy detected. Attempting re-sync.');
+    // Refuse to compute server time and try to guess new server offset. Guessing only works if the server time hasn't changed.
+    SyncInternals.offset = SyncInternals.offset - discrepancy;
+    SyncInternals.isSynced = false;
+    SyncInternals.offsetTracker.changed();
+    TimeSync.resync();
+  }
+
+  lastClientTime = currentClientTime;
+}, defaultInterval);

package.js

@@ -1,40 +1,43 @@
 Package.describe({
-  name: "mizzao:timesync",
-  summary: "NTP-style time synchronization between server and client",
-  version: "0.5.5",
+  name: 'mizzao:timesync',
+  summary: 'NTP-style time synchronization between server and client',
+  version: '0.6.0',
   git: "https://github.com/Meteor-Community-Packages/meteor-timesync"
 });
 
 Package.onUse(function (api) {
-  api.versionsFrom(["1.12", "2.3", '3.0-beta.7']);
+  api.versionsFrom(["1.12", "2.3"]);
 
   api.use([
     'check',
     'tracker',
     'http'
   ], 'client');
 
-  api.use('webapp', 'server');
+  api.use(['webapp'], 'server');
 
-  api.use('ecmascript');
+  api.use(['ecmascript']);
 
   // Our files
-  api.addFiles('timesync-server.js', 'server');
-  api.addFiles('timesync-client.js', 'client');
+  api.addFiles('server/index.js', 'server');
+  api.addFiles('client/index.js', 'client');
 
   api.export('TimeSync', 'client');
-  api.export('SyncInternals', 'client', {testOnly: true} );
+  api.export('SyncInternals', 'client', {
+    testOnly: true
+  });
 });
 
 Package.onTest(function (api) {
   api.use([
+    'ecmascript',
     'tinytest',
     'test-helpers'
   ]);
 
-  api.use(["tracker", "underscore"], 'client');
+  api.use(['tracker', 'underscore'], 'client');
 
-  api.use("mizzao:timesync");
+  api.use('mizzao:timesync');
 
   api.addFiles('tests/client.js', 'client');
 });

server/index.js

@@ -0,0 +1 @@
+import './timesync-server';

timesync-server.js → server/timesync-server.js

@@ -1,18 +1,20 @@
+import { Meteor } from "meteor/meteor";
+
 // Use rawConnectHandlers so we get a response as quickly as possible
 // https://github.com/meteor/meteor/blob/devel/packages/webapp/webapp_server.js
 
 const url = new URL(Meteor.absoluteUrl("/_timesync"));
 
 WebApp.rawConnectHandlers.use(url.pathname,
-  function(req, res, next) {
+  function (req, res, next) {
     // Never ever cache this, otherwise weird times are shown on reload
     // http://stackoverflow.com/q/18811286/586086
-    res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
-    res.setHeader("Pragma", "no-cache");
-    res.setHeader("Expires", 0);
+    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    res.setHeader('Pragma', 'no-cache');
+    res.setHeader('Expires', 0);
 
     // Avoid MIME type warnings in browsers
-    res.setHeader("Content-Type", "text/plain");
+    res.setHeader('Content-Type', 'text/plain');
 
     // Cordova lives in a local webserver, so it does CORS
     // we need to bless it's requests in order for it to accept our results
@@ -30,3 +32,10 @@ WebApp.rawConnectHandlers.use(url.pathname,
     res.end(Date.now().toString());
   }
 );
+
+Meteor.methods({
+  _timeSync: function () {
+    this.unblock();
+    return Date.now();
+  }
+});