keuss 2.0.7 → 2.2.0

package/.mocharc.yaml

@@ -0,0 +1,3 @@
+bail: false
+timeout: false
+

package/Pipeline/BaseLink.js

@@ -55,6 +55,7 @@ class BaseLink  extends EventEmitter {
   /////////////////////////////////////////
   stop () {
     this._src.cancel ();
+    debug ('%s: stopped', this._name);
   }
 
 
@@ -164,7 +165,6 @@ class BaseLink  extends EventEmitter {
       }
       catch (e) {
         debug ('catch error, emitting it: ', e);
-        console.log ('catch error, emitting it: ', e);
         this.emit (e);
         this._on_error (e, elem, ondata);
       }

package/Pipeline/Queue.js

@@ -32,125 +32,142 @@ class PipelinedMongoQueue extends Queue {
 
   /////////////////////////////////////////
   // add element to queue
-  insert (entry, callback) {
+  insert (entry, cb) {
     entry._q = this._name;
 
-    this._col.insertOne (entry, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result.insertedId);
+    this._col.insertOne (entry, {})
+    .then (res => cb (null, res.insertedId))
+    .catch (err => {
+      if (err.code == 11000) {
+        const e = new Error (`duplicated entry with _id ${entry._id}`)
+        e.code = 'EDUP';
+        cb(e)
+      }
+      else {
+        cb (err)
+      }
     });
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  get (callback) {
-    this._col.findOneAndDelete ({_q: this._name, mature: {$lte: Queue.nowPlusSecs (0)}}, {sort: {mature : 1}}, (err, result) => {
-      if (err) return callback (err);
-      const v = result && result.value;
-      if (!v) return callback ();
+  get (cb) {
+    const query = {
+      _q: this._name, 
+      mature: {$lte: Queue.nowPlusSecs (0)}
+    };
+
+    const opts = {
+      sort: {mature : 1},
+      includeResultMetadata: true
+    }
+
+    this._col.findOneAndDelete (query, opts)
+    .then (res => {
+      const v = res && res.value;
+      if (!v) return cb ();
       if (v.payload._bsontype == 'Binary') v.payload = v.payload.buffer;
-      callback (null, v);
-    });
+      cb (null, v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // reserve element: call cb (err, pl) where pl has an id
-  reserve (callback) {
-    var delay = this._opts.reserve_delay || 120;
+  reserve (cb) {
+    const delay = this._opts.reserve_delay || 120;
 
-    var query = {
+    const query = {
       _q:     this._name,
       mature: {$lte: Queue.nowPlusSecs (0)}
     };
 
-    var update = {
+    const update = {
       $set: {mature: Queue.nowPlusSecs (delay), reserved: new Date ()},
       $inc: {tries: 1}
     };
 
-    var opts = {
+    const opts = {
       sort: {mature : 1},
-      returnDocument: 'before'
+      returnDocument: 'before',
+      includeResultMetadata: true
     };
 
-    this._col.findOneAndUpdate (query, update, opts, (err, result) => {
-      if (err) return callback (err);
-      const v = result && result.value;
-      if (!v) return callback ();
+    this._col.findOneAndUpdate (query, update, opts)
+    .then (res => {
+      const v = res && res.value;
+      if (!v) return cb ();
       if (v.payload._bsontype == 'Binary') v.payload = v.payload.buffer;
-      callback (null, v);
-    });
+      cb (null, v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // commit previous reserve, by p.id
-  commit (id, callback) {
-    var query;
+  commit (id, cb) {
+    const query = {
+      _q: this._name,
+      reserved: {$exists: true}
+    }
 
     try {
-      query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        _q: this._name,
-        reserved: {$exists: true}
-      };
+      query._id = (_.isString(id) ? new mongo.ObjectId (id) : id);
     }
     catch (e) {
-      return callback ('id [' + id + '] can not be used as rollback id: ' + e);
+      return cb ('id [' + id + '] can not be used as rollback id: ' + e);
     }
 
-    this._col.deleteOne (query, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.deletedCount == 1));
-    });
+    this._col.deleteOne (query, {})
+    .then (res => cb (null, res && (res.deletedCount == 1)))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // rollback previous reserve, by p.id
-  rollback (id, next_t, callback) {
+  rollback (id, next_t, cb) {
     if (_.isFunction (next_t)) {
-      callback = next_t;
+      cb = next_t;
       next_t = null;
     }
 
-    var query;
+    const query = {
+      _q: this._name,
+      reserved: {$exists: true}
+    }
 
     try {
-      query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        _q: this._name,
-        reserved: {$exists: true}
-      };
+      query._id = (_.isString(id) ? new mongo.ObjectId (id) : id);
     }
     catch (e) {
-      return callback ('id [' + id + '] can not be used as rollback id: ' + e);
+      return cb ('id [' + id + '] can not be used as rollback id: ' + e);
     }
 
-    var update = {
+    const update = {
       $set:   {mature: (next_t ? new Date (next_t) : Queue.now ())},
       $unset: {reserved: ''}
     };
 
-    this._col.updateOne (query, update, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (query, update, {})
+    .then (res => cb (null, res && (res.modifiedCount == 1)))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // passes element to the next queue in pipeline
-  pl_step (id, next_queue, opts, callback) {
-    var q =  {
+  pl_step (id, next_queue, opts, cb) {
+    const q =  {
       _id: id,
       _q: this._name,
       reserved: {$exists: true}
     };
 
-    var upd = {
+    const upd = {
       $set:   {
         mature: opts.mature || Queue.now (),
         tries:  opts.tries || 0,
@@ -170,93 +187,101 @@ class PipelinedMongoQueue extends Queue {
       _.each (opts.hdrs, (v, k) => upd.$set['hdrs.' + k] = v);
     }
 
-    this._col.updateOne (q, upd, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (q, upd, {})
+    .then (res => cb (null, res && (res.modifiedCount == 1)))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size including non-mature elements
-  totalSize (callback) {
-    var q = {_q: this._name};
-    var opts = {};
-    this._col.countDocuments (q, opts, callback);
+  totalSize (cb) {
+    const q = {_q: this._name};
+    const opts = {};
+    this._col.countDocuments (q, opts)
+    .then (res => cb (null, res))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size NOT including non-mature elements
-  size (callback) {
-    var q = {
+  size (cb) {
+    const q = {
       _q: this._name,
       mature : {$lte : Queue.now ()}
     };
 
-    var opts = {};
-    this._col.countDocuments (q, opts, callback);
+    const opts = {};
+    this._col.countDocuments (q, opts)
+    .then (res => cb (null, res))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size of non-mature elements only
-  schedSize (callback) {
-    var q = {
+  schedSize (cb) {
+    const q = {
       _q: this._name,
       mature : {$gt : Queue.now ()},
       reserved: {$exists: false}
     };
 
-    var opts = {};
-    this._col.countDocuments (q, opts, callback);
+    const opts = {};
+    this._col.countDocuments (q, opts)
+    .then (res => cb (null, res))
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size of reserved elements only
-  resvSize (callback) {
-    var q = {
+  resvSize (cb) {
+    const q = {
       _q: this._name,
       mature : {$gt : Queue.now ()},
       reserved: {$exists: true}
     };
 
-    var opts = {};
-    this._col.countDocuments (q, opts, callback);
+    const opts = {};
+    this._col.countDocuments (q, opts)
+    .then (res => cb (null, res))
+    .catch (cb);
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  next_t (callback) {
-    this._col.find ({_q: this._name}).limit(1).sort ({mature:1}).project ({mature:1}).next ((err, result) => {
-      if (err) return callback (err);
-      callback (null, result && result.mature);
-    });
+  next_t (cb) {
+    this._col.find ({_q: this._name})
+    .limit(1)
+    .sort ({mature:1})
+    .project ({mature:1})
+    .next ()
+    .then (res => cb (null, res && res.mature))
+    .catch (cb);
   }
 
 
   //////////////////////////////////////////////
   // remove by id
-  remove (id, callback) {
-    var query;
+  remove (id, cb) {
+    const query = {
+      _q: this._name,
+      reserved: {$exists: false}
+    }
 
     try {
-      query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        _q: this._name,
-        reserved: {$exists: false}
-      };
+      query._id = (_.isString(id) ? new mongo.ObjectId (id) : id);
     }
     catch (e) {
-      return callback ('id [' + id + '] can not be used as remove id: ' + e);
+      return cb ('id [' + id + '] can not be used as remove id: ' + e);
     }
 
-    this._col.deleteOne (query, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.deletedCount == 1));
-    });
+    this._col.deleteOne (query, {})
+    .then (res => cb (null, res && (res.deletedCount == 1)))
+    .catch (cb);
   }
 
 

package/Queue.js

@@ -321,6 +321,8 @@ class Queue {
       hdrs:    opts.hdrs || {}
     };
 
+    if (opts.id) msg._id = opts.id;
+
     debug ('%s: about to insert %o', this._name, msg);
 
     // insert into queue
@@ -489,9 +491,9 @@ class Queue {
   //////////////////////////////////
   // cancel a waiting consumer
   cancel (tid) {
-   debug ('%s: cancelling tid %s', this._name, tid);
-
     if (tid) {
+      debug ('%s: cancelling tid %s', this._name, tid);
+
       let consumer_data = this._consumers_by_tid.get (tid);
 
       if (!consumer_data) {
@@ -535,18 +537,27 @@ class Queue {
 
           debug ('%s: cancelling tid %s (cid %s): callback called and removed', this._name, tid, consumer_data.cid);
         }
+        else {
+          debug ('%s: cancelling tid %s (cid %s): has no callback!', this._name, tid);
+        }
 
         if (consumer_data.cleanup_timeout) {
           clearTimeout (consumer_data.cleanup_timeout);
           consumer_data.cleanup_timeout = null;
           debug ('%s: cancelling tid %s (cid %s): cleanup timeout removed', this._name, tid, consumer_data.cid);
         }
+        else {
+          debug ('%s: cancelling tid %s (cid %s): has no cleanup timeout!', this._name, tid);
+        }
 
         if (consumer_data.wakeup_timeout) {
           clearTimeout (consumer_data.wakeup_timeout);
           consumer_data.wakeup_timeout = null;
           debug ('%s: cancelling tid %s (cid %s): wakeup timeout removed', this._name, tid, consumer_data.cid);
         }
+        else {
+          debug ('%s: cancelling tid %s (cid %s): has no wakeup timeout!', this._name, tid);
+        }
 
         debug ('%s: cancelling tid %s (cid %s): end', this._name, tid, consumer_data.cid);
       });
@@ -654,9 +665,11 @@ class Queue {
     };
 
     if (consumer.reserve) {
+      debug ('%s - tid %s: calling getOrReserve_cb with reserve', this._name, consumer.tid);
       this.reserve (getOrReserve_cb);
     }
     else {
+      debug ('%s - tid %s: calling getOrReserve_cb with get', this._name, consumer.tid);
       this.get (getOrReserve_cb);
     }
   }