keuss 2.0.6 → 2.1.0

package/backends/ps-mongo.js

@@ -1,15 +1,15 @@
-var async = require ('async');
-var _ =     require ('lodash');
+const async = require ('async');
+const _ =     require ('lodash');
 
-var MongoClient = require ('mongodb').MongoClient;
-var mongo =       require ('mongodb');
+const MongoClient = require ('mongodb').MongoClient;
+const mongo =       require ('mongodb');
 
-var Queue =                     require ('../Queue');
-var QFactory_MongoDB_defaults = require ('../QFactory-MongoDB-defaults');
+const Queue =                     require ('../Queue');
+const QFactory_MongoDB_defaults = require ('../QFactory-MongoDB-defaults');
 
 
+//////////////////////////////////////////////
 class PersistentMongoQueue extends Queue {
-
   //////////////////////////////////////////////
   constructor (name, factory, opts, orig_opts) {
     super (name, factory, opts, orig_opts);
@@ -32,54 +32,55 @@ class PersistentMongoQueue extends Queue {
 
   /////////////////////////////////////////
   // add element to queue
-  insert (entry, callback) {
-    this._col.insertOne (entry, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result.insertedId);
-    });
+  insert (entry, cb) {
+    this._col.insertOne (entry, {})
+    .then (res => cb (null, res.insertedId))
+    .catch (cb);
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  get (callback) {
-    var q = {
+  get (cb) {
+    const q = {
       mature: {$lte: Queue.nowPlusSecs (0)},
       processed: {$exists: false}
     };
 
-    var updt = {
+    const updt = {
       $set: {
         processed: new Date (),
         mature: Queue.nowPlusSecs (100 * this._opts.ttl)
       }
     };
 
-    var opts = {
-      sort: {mature : 1}
+    const opts = {
+      sort: {mature : 1},
+      includeResultMetadata: true
     };
 
-    this._col.findOneAndUpdate (q, updt, opts, (err, result) => {
-      if (err) return callback (err);
-      const v = result && result.value;
-      if (!v) return callback ();
+    this._col.findOneAndUpdate (q, updt, 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 = {
       processed: {$exists: false},
       mature: {$lte: Queue.nowPlusSecs (0)}
     };
 
-    var update = {
+    const update = {
       $set: {
         mature: Queue.nowPlusSecs (delay), 
         reserved: new Date ()
@@ -87,37 +88,38 @@ class PersistentMongoQueue extends Queue {
       $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 = {
+      reserved: {$exists: true}
+    };
 
     try {
-      query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        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 updt = {
+    const updt = {
       $set:   {
         processed: new Date (),
         mature: Queue.nowPlusSecs (100 * this._opts.ttl)
@@ -125,115 +127,121 @@ class PersistentMongoQueue extends Queue {
       $unset: {reserved: ''}
     };
 
-    var opts = {};
+    const opts = {};
 
-    this._col.updateOne (query, updt, opts, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (query, updt, opts)
+    .then (res => cb (null, res && (res.modifiedCount == 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;
     }
 
+    const query = {
+      reserved: {$exists: true}
+    };
+
     try {
-      var query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        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);
   }
 
 
   //////////////////////////////////
   // queue size including non-mature elements
-  totalSize (callback) {
-    var q = {
+  totalSize (cb) {
+    const q = {
       processed: {$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 NOT including non-mature elements
-  size (callback) {
-    var q = {
+  size (cb) {
+    const q = {
       processed: {$exists: false},
       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 = {
       mature : {$gt : Queue.now ()},
       processed: {$exists: false},
       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 = {
       mature : {$gt : Queue.now ()},
       processed: {$exists: false},
       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);
   }
 
 
   //////////////////////////////////////////////
   // remove by id
-  remove (id, callback) {
-    var query;
+  remove (id, cb) {
+    const query ={
+      processed: {$exists: false},
+      reserved: {$exists: false}
+    };
 
     try {
-      query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        processed: {$exists: false},
-        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);
     }
 
-    var updt = {
+    const updt = {
       $set:   {
         processed: new Date (),
         mature: Queue.nowPlusSecs (100 * this._opts.ttl),
@@ -241,27 +249,25 @@ class PersistentMongoQueue extends Queue {
       },
     };
 
-    var opts = {};
+    const opts = {};
 
-    this._col.updateOne (query, updt, opts, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (query, updt, opts)
+    .then (res => cb (null, res && (res.modifiedCount == 1)))
+    .catch (cb);
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  next_t (callback) {
+  next_t (cb) {
     this._col
     .find ({processed: {$exists: false}})
     .limit(1)
     .sort ({mature:1})
     .project ({mature:1})
-    .next ((err, result) => {
-      if (err) return callback (err);
-      callback (null, result && result.mature);
-    });
+    .next ()
+    .then (res => cb (null, res && res.mature))
+    .catch (cb);
   }
 
 
@@ -271,14 +277,17 @@ class PersistentMongoQueue extends Queue {
   //////////////////////////////////////////////////////////////////
   // create needed indexes for O(1) functioning
   _ensureIndexes (cb) {
-    this._col.createIndex ({mature : 1}, err => {
-      if (err) return cb (err);
-      this._col.createIndex({processed: 1}, {expireAfterSeconds: this._opts.ttl}, err => cb (err, this));
-    });
+    async.series ([
+      cb => this._col.createIndex ({mature : 1}).then (res => cb(null, res)).catch (cb),
+      cb => this._col.createIndex ({processed: 1}, {expireAfterSeconds: this._opts.ttl}).then (res => cb(null, res)).catch (cb),
+    ])
+    .then (() => cb (null, this))
+    .catch (cb);
   }
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
 class Factory extends QFactory_MongoDB_defaults {
   constructor (opts, mongo_conn) {
     super (opts);
@@ -286,6 +295,7 @@ class Factory extends QFactory_MongoDB_defaults {
     this._db = mongo_conn.db();
   }
 
+  //////////////////////////////////////////////////////////////////
   queue (name, opts, cb) {
     if (!cb) {
       cb = opts;
@@ -298,6 +308,7 @@ class Factory extends QFactory_MongoDB_defaults {
     q._ensureIndexes (cb);
   }
 
+  //////////////////////////////////////////////////////////////////
   close (cb) {
     super.close (() => {
       if (this._mongo_conn) {
@@ -309,10 +320,12 @@ class Factory extends QFactory_MongoDB_defaults {
     });
   }
 
+  //////////////////////////////////////////////////////////////////
   type () {
     return PersistentMongoQueue.Type ();
   }
 
+  //////////////////////////////////////////////////////////////////
   capabilities () {
     return {
       sched:    true,
@@ -324,20 +337,18 @@ class Factory extends QFactory_MongoDB_defaults {
   }
 }
 
+  
+//////////////////////////////////////////////////////////////////
 function creator (opts, cb) {
-  var _opts = opts || {};
-  var m_url = _opts.url || 'mongodb://localhost:27017/keuss';
+  const _opts = opts || {};
+  const m_url = _opts.url || 'mongodb://localhost:27017/keuss';
 
-  MongoClient.connect (m_url, { useNewUrlParser: true }, (err, cl) => {
-    if (err) return cb (err);
-    var F = new Factory (_opts, cl);
+  MongoClient.connect (m_url)
+  .then (cl => {
+    const F = new Factory (_opts, cl);
     F.async_init (err => cb (null, F));
-  });
+  })
+  .catch (cb);
 }
 
 module.exports = creator;
-
-
-
-
-

package/backends/redis-oq.js

@@ -171,5 +171,3 @@ function creator (opts, cb) {
 }
 
 module.exports = creator;
-
-