antietcd 1.1.4 → 1.2.0

package/etctree.js

@@ -1,5 +1,5 @@
 // Simple in-memory etcd-like key/value store
-// (c) Vitaliy Filippov, 2024
+// (c) Vitaliy Filippov, 2024+
 // License: Mozilla Public License 2.0 or Vitastor Network Public License 1.1
 
 const crypto = require('crypto');
@@ -19,8 +19,9 @@ const { RequestError } = require('./common.js');
 
 class EtcTree
 {
-    constructor()
+    constructor(cfg)
     {
+        this.cfg = cfg || {};
         this.state = {};
         this.leases = {};
         this.watchers = {};
@@ -30,6 +31,7 @@ class EtcTree
         this.replicate = null;
         this.paused = false;
         this.active_immediate = [];
+        this.notify_queue = [];
     }
 
     destroy()
@@ -97,13 +99,13 @@ class EtcTree
 
     _key_parts(key)
     {
-        const parts = key.replace(/\/\/+/g, '/').replace(/\/$/g, ''); // trim beginning?
+        const parts = (''+key).replace(/\/\/+/g, '/').replace(/\/$/g, ''); // trim beginning?
         return parts === '' ? [] : parts.split('/');
     }
 
     _get_range(req)
     {
-        const key = req.key;
+        const key = ''+req.key;
         const end = req.range_end;
         if (end != null && (key !== '' && end !== '') && (key[key.length-1] != '/' || end[end.length-1] != '0' ||
             end.substr(0, end.length-1) !== key.substr(0, key.length-1)))
@@ -237,7 +239,17 @@ class EtcTree
         }
         // Then find and apply the difference in data
         this._restore_diff(update_only, this.state, snapshot.state, null, this.state.watchers || [], notifications);
-        this._notify(notifications);
+        if (notifications.length)
+        {
+            if (!this.cfg.use_locks)
+            {
+                this._notify(notifications);
+            }
+            else
+            {
+                this.notify_queue.push({ revision: this.mod_revision, notifications });
+            }
+        }
     }
 
     _restore_diff(update_only, cur_old, cur_new, prefix, watchers, notifications)
@@ -362,13 +374,13 @@ class EtcTree
         }
         const expires = Date.now() + req.TTL*1000;
         this.leases[id] = { ttl: req.TTL, expires, timer_id: null, keys: {} };
-        this.mod_revision++;
+        const next_revision = ++this.mod_revision;
         this._set_expire(id);
         if (this.replicate)
         {
-            await this.replicate({ header: { revision: this.mod_revision }, leases: [ { id, ttl: req.TTL, expires } ] });
+            await this.replicate({ header: { revision: next_revision }, leases: [ { id, ttl: req.TTL, expires } ] });
         }
-        return { header: { revision: this.mod_revision }, ID: id, TTL: req.TTL };
+        return { header: { revision: next_revision }, ID: id, TTL: req.TTL };
     }
 
     async api_keepalive_lease(req)
@@ -386,14 +398,14 @@ class EtcTree
         }
         const ttl = this.leases[id].ttl;
         lease.expires = Date.now() + ttl*1000;
-        this.mod_revision++;
+        const next_revision = ++this.mod_revision;
         this._set_expire(id);
         if (this.replicate)
         {
-            await this.replicate({ header: { revision: this.mod_revision }, leases: [ { id, ttl, expires: lease.expires } ] });
+            await this.replicate({ header: { revision: next_revision }, leases: [ { id, ttl, expires: lease.expires } ] });
         }
         // extra wrapping in { result: ... }
-        return { result: { header: { revision: this.mod_revision }, ID: id, TTL: ''+ttl } };
+        return { result: { header: { revision: next_revision }, ID: id, TTL: ''+ttl } };
     }
 
     load_lease(lease)
@@ -449,26 +461,10 @@ class EtcTree
                 return null;
             throw new RequestError(400, 'unknown lease');
         }
-        this.mod_revision++;
-        this._sync_revoke_lease(req.ID, notifications, this.mod_revision);
-        if (this.replicate)
-        {
-            await this.notify_replicator(notifications, [ { id: req.ID } ]);
-        }
-        this._notify(notifications);
-        return { header: { revision: this.mod_revision } };
-    }
-
-    async notify_replicator(notifications, leases)
-    {
-        // First replicate the change and then notify watchers about it
-        const all_changes = {};
-        for (const chg of notifications)
-        {
-            all_changes[chg.key] = { ...chg };
-            delete all_changes[chg.key].watchers;
-        }
-        await this.replicate({ header: { revision: this.mod_revision }, events: Object.values(all_changes), leases });
+        const next_revision = ++this.mod_revision;
+        this._sync_revoke_lease(req.ID, notifications, next_revision);
+        await this._notify_and_replicate(next_revision, notifications, [ { id: req.ID } ]);
+        return { header: { revision: next_revision } };
     }
 
     async apply_replication(msg)
@@ -503,11 +499,7 @@ class EtcTree
                 }
             }
         }
-        if (this.replicate)
-        {
-            await this.notify_replicator(notifications, msg.leases);
-        }
-        this._notify(notifications);
+        await this._notify_and_replicate(msg.header.revision, notifications, msg.leases);
     }
 
     // forget deletions before compact_revision
@@ -533,7 +525,8 @@ class EtcTree
     api_create_watch(req, send, stream_id)
     {
         const { parts, all } = this._get_range(req);
-        if (req.start_revision && this.compact_revision && this.compact_revision > req.start_revision)
+        if (req.start_revision && req.start_revision > 1 &&
+            this.compact_revision && this.compact_revision > req.start_revision)
         {
             // Deletions up to this.compact_revision are forgotten
             return { canceled: true, cancel_reason: 'Revisions up to '+this.compact_revision+' are compacted', compact_revision: this.compact_revision };
@@ -567,23 +560,18 @@ class EtcTree
             cur.key_watchers = cur.key_watchers || [];
             cur.key_watchers.push(watch_id);
         }
-        if (req.start_revision && req.start_revision <= this.mod_revision)
+        let events = undefined;
+        if (req.start_revision)
         {
             // Send initial changes
-            const imm = setImmediate(() =>
-            {
-                this.active_immediate = this.active_immediate.filter(i => i !== imm);
-                const events = [];
-                const { cur } = this._get_subtree([], false, false);
-                this._get_modified(events, cur, null, req.start_revision);
-                send({ result: { header: { revision: this.mod_revision }, events } });
-            });
-            this.active_immediate.push(imm);
+            events = [];
+            const { cur } = this._get_subtree([], false, false);
+            this._get_modified(events, cur, null, req.start_revision);
         }
-        return { header: { revision: this.mod_revision }, watch_id, created: true };
+        return { header: { revision: this.mod_revision }, watch_id, created: true, events };
     }
 
-    _get_modified(events, cur, prefix, min_rev)
+    _get_modified(events, cur, prefix, min_rev, with_watchers)
     {
         if (cur.mod_revision >= min_rev)
         {
@@ -595,6 +583,10 @@ class EtcTree
                     mod_revision: cur.mod_revision,
                 },
             };
+            if (with_watchers)
+            {
+                ev.watchers = [ ...with_watchers, ...(cur.watchers||[]), ...(cur.key_watchers||[]) ];
+            }
             if (cur.lease)
             {
                 ev.kv.lease = cur.lease;
@@ -603,9 +595,13 @@ class EtcTree
         }
         if (cur.children)
         {
+            if (with_watchers)
+            {
+                with_watchers = [ ...with_watchers, ...(cur.watchers||[]) ];
+            }
             for (const k in cur.children)
             {
-                this._get_modified(events, cur.children[k], prefix === null ? k : prefix+'/'+k, min_rev);
+                this._get_modified(events, cur.children[k], prefix === null ? k : prefix+'/'+k, min_rev, with_watchers);
             }
         }
     }
@@ -638,12 +634,63 @@ class EtcTree
         return { canceled: true };
     }
 
-    _notify(notifications)
+    async _notify_and_replicate(next_revision, notifications, leases)
     {
-        if (!notifications.length)
+        if (notifications.length)
+        {
+            // First schedule notifications, then replicate. Replication may fail.
+            // And we don't want to miss events in that case.
+            if (!this.cfg.use_locks)
+            {
+                this._notify(notifications);
+            }
+            else
+            {
+                this.notify_queue.push({ revision: next_revision, notifications });
+            }
+            if (this.replicate)
+            {
+                const all_changes = {};
+                for (const chg of notifications)
+                {
+                    all_changes[chg.key] = { ...chg };
+                    delete all_changes[chg.key].watchers;
+                }
+                await this.replicate({ header: { revision: next_revision }, events: Object.values(all_changes), leases });
+            }
+        }
+    }
+
+    resume_notifications(max_revision)
+    {
+        let i = 0;
+        while (i < this.notify_queue.length &&
+            this.notify_queue[i].revision <= max_revision)
+        {
+            this._notify(this.notify_queue[i].notifications);
+            i++;
+        }
+        this.notify_queue.splice(0, i);
+    }
+
+    resync_notifications()
+    {
+        if (!this.notify_queue.length)
         {
             return;
         }
+        const first_unnotified_revision = this.notify_queue
+            .flatMap(msg => msg.notifications.map(m => m.revision))
+            .reduce((a, c) => (a < c ? a : c));
+        const events = [];
+        const { cur } = this._get_subtree([], false, false);
+        this._get_modified(events, cur, null, first_unnotified_revision, []);
+        const notifications = events.map(n => ({ ...n.kv, watchers: n.watchers }));
+        this._notify(notifications);
+    }
+
+    _notify(notifications)
+    {
         const by_watcher = {};
         for (const notif of notifications)
         {
@@ -671,18 +718,14 @@ class EtcTree
         const failed = (compare || []).filter(chk => !this._check(chk)).length > 0;
         const responses = [];
         const notifications = [];
-        const next_revision = this.mod_revision + 1;
+        let next_revision = this.mod_revision + 1;
         for (const req of (failed ? failure : success) || [])
         {
             responses.push(this._txn_action(req, next_revision, notifications));
         }
-        if (this.replicate && notifications.length)
-        {
-            // First replicate the change and then notify watchers about it
-            await this.notify_replicator(notifications);
-        }
-        this._notify(notifications);
-        return { header: { revision: this.mod_revision }, succeeded: !failed, responses };
+        next_revision = this.mod_revision;
+        await this._notify_and_replicate(next_revision, notifications);
+        return { header: { revision: next_revision }, succeeded: !failed, responses };
     }
 
     _txn_action(req, cur_revision, notifications)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "antietcd",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Simplistic etcd replacement based on TinyRaft",
   "main": "antietcd.js",
   "scripts": {
-    "lint": "eslint common.js anticli.js antipersistence.js anticluster.js antietcd.js etctree.js etctree.spec.js",
+    "lint": "eslint common.js anticli.js antipersistence.js anticluster.js antietcd.js antilocker.js etctree.js etctree.spec.js",
     "test": "node etctree.spec.js"
   },
   "repository": {
@@ -21,7 +21,7 @@
     "antietcd-app.js",
     "antietcd.js",
     "antietcd.d.ts",
-    "antietcd.js",
+    "antilocker.js",
     "antipersistence.js",
     "common.js",
     "etctree.js",