keuss 2.0.6 → 2.1.0

package/backends/mongo.js

@@ -1,10 +1,12 @@
-var _ = require ('lodash');
+const _ = require ('lodash');
 
-var MongoClient = require ('mongodb').MongoClient;
-var mongo =       require ('mongodb');
+const MongoClient = require ('mongodb').MongoClient;
+const mongo =       require ('mongodb');
+const debug =       require('debug')('keuss:Queue:mongo');
+
+const Queue =                     require ('../Queue');
+const QFactory_MongoDB_defaults = require ('../QFactory-MongoDB-defaults');
 
-var Queue =                     require ('../Queue');
-var QFactory_MongoDB_defaults = require ('../QFactory-MongoDB-defaults');
 
 class SimpleMongoQueue extends Queue {
 
@@ -20,187 +22,228 @@ class SimpleMongoQueue extends Queue {
     return 'mongo:simple';
   }
 
+
   /////////////////////////////////////////
   type () {
     return 'mongo:simple';
   }
 
+
   /////////////////////////////////////////
   // 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 => {
+      debug ('inserted entry %j -> %j', entry, res)
+      cb (null, res.insertedId);
+    })
+    .catch (cb);
   }
-
+c
 
   /////////////////////////////////////////
   // get element from queue
-  get (callback) {
-    this._col.findOneAndDelete ({mature: {$lte: Queue.nowPlusSecs (0)}}, {sort: {mature : 1}}, (err, result) => {
-      if (err) return callback (err);
+  get (cb) {
+    const query = {
+      mature: {$lte: Queue.nowPlusSecs (0)}
+      };
+
+    const opts = {
+      sort: {mature : 1}, 
+      includeResultMetadata: true 
+    };
+
+    this._col.findOneAndDelete (query, opts)
+    .then (result => {
+      debug ('get() element, findOneAndDelete returned %j', result)
       const v = result && result.value;
-      if (!v) return callback ();
+      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 = {
       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 => {
+      debug ('reserve() element, findOneAndUpdate returned %j', 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) {
+  commit (id, cb) {
+    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);
     }
 
-    this._col.deleteOne (query, {}, (err, result) => {
-      if (err) return callback (err);
-      callback (null, result && (result.deletedCount == 1));
-    });
+    this._col.deleteOne (query, {})
+    .then (res => {
+      debug ('commit(%s) element, deleteOne returned %j', id, 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;
     }
 
+    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 => {
+      debug ('rollback(%s) element, updateOne returned %j', id, res)
+      cb (null, res && (res.modifiedCount == 1));
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size including non-mature elements
-  totalSize (callback) {
-    var q = {};
-    var opts = {};
-    this._col.countDocuments (q, opts, callback);
+  totalSize (cb) {
+    const q = {};
+    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 = {
       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 ()},
       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 ()},
       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 ({}).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 ({})
+    .limit(1)
+    .sort ({mature:1})
+    .project ({mature:1})
+    .next ()
+    .then (res => {
+      debug ('next_t(), find returned %j', res)
+      cb (null, res && res.mature);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////////////////
   // remove by id
-  remove (id, callback) {
+  remove (id, cb) {
+    const query =  {
+      reserved: {$exists: false}
+    };
+
     try {
-      var query =  {
-        _id: (_.isString(id) ? new mongo.ObjectID (id) : id),
-        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 => {
+      debug ('remove(%s) element, deleteOne returned %j', id, res)
+      cb (null, res && (res.deletedCount == 1));
+    })
+    .catch (cb)
   }
 
 
@@ -210,11 +253,14 @@ class SimpleMongoQueue extends Queue {
   //////////////////////////////////////////////////////////////////
   // create needed indexes for O(1) functioning
   _ensureIndexes (cb) {
-    this._col.createIndex ({mature : 1}, err => cb (err, this));
+    this._col.createIndex ({mature : 1})
+    .then (() => cb (null, this))
+    .catch (cb);
   }
 };
 
 
+///////////////////////////////////////////////////////////////////////////////
 class Factory extends QFactory_MongoDB_defaults {
   constructor (opts, mongo_conn) {
     super (opts);
@@ -262,19 +308,15 @@ 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/pl-mongo.js

@@ -31,7 +31,8 @@ class Factory extends QFactory_MongoDB_defaults {
       }
     }, {
       upsert: true
-    });
+    })
+    .finally (() => {});
   }
 
 
@@ -98,9 +99,8 @@ class Factory extends QFactory_MongoDB_defaults {
       }
     }, {
       upsert: true
-    });
-
-
+    })
+    .finally (() => {});
   }
 
 
@@ -141,11 +141,15 @@ class Factory extends QFactory_MongoDB_defaults {
   close (cb) {
     super.close (() => {
       async.parallel ([
-        cb => this._mongo_data_conn.close (cb),
-        cb => this._mongo_topology_conn.close (cb)
-      ], err => {
+        cb => this._mongo_data_conn.close ().then (res => cb (null, res)).catch (cb),
+        cb => this._mongo_topology_conn.close ().then (res => cb (null, res)).catch (cb),
+      ])
+      .then (res => {
         this._mongo_data_conn = null;
         this._mongo_topology_conn = null;
+        if (cb) return cb ();
+      })
+      .catch (err => {
         if (cb) return cb (err);
       });
     });
@@ -194,30 +198,14 @@ function creator (opts, cb) {
   }
 
   async.series ([
-    cb => MongoClient.connect (m_url, { useNewUrlParser: true }, (err, cl) => {
-      if (err) {
-        debug ('error while connecting to data mongoDB [%s]', m_url, err);
-        return cb (err);
-      }
-
-      debug ('connected OK to data mongoDB %s', m_url);
-      cb (null, cl);
-    }),
-    cb => MongoClient.connect (m_topology_url, { useNewUrlParser: true }, (err, cl) => {
-      if (err) {
-        debug ('error while connecting to topology mongoDB [%s]', m_topology_url, err);
-        return cb (err);
-      }
-
-      debug ('connected OK to topology mongoDB %s', m_topology_url);
-      cb (null, cl);
-    }),
-  ], (err, res) => {
-    if (err) return cb (err);
-
-    var F = new Factory (_opts, res[0], res[1]);
+    cb => MongoClient.connect (m_url).then (res => cb (null, res)).catch (cb),
+    cb => MongoClient.connect (m_topology_url).then (res => cb (null, res)).catch (cb),
+  ])
+  .then (res => {
+    const F = new Factory (_opts, res[0], res[1]);
     F.async_init (err => cb (null, F));
-  });
+  })
+  .catch (cb);
 }
 
 module.exports = creator;