iotagent-node-lib 4.5.0 → 4.7.0

package/lib/model/dbConn.js

@@ -31,7 +31,6 @@ const config = require('../commonConfig');
 const constants = require('../constants');
 const alarms = require('../services/common/alarmManagement');
 const logger = require('logops');
-const async = require('async');
 const errors = require('../errors');
 let defaultDb;
 const DEFAULT_DB_NAME = 'iotagent';
@@ -40,9 +39,9 @@ const context = {
 };
 
 function loadModels() {
-    require('./Device').load(defaultDb);
-    require('./Group').load(defaultDb);
-    require('./Command').load(defaultDb);
+    require('./Device').load();
+    require('./Group').load();
+    require('./Command').load();
 }
 
 /**
@@ -50,93 +49,52 @@ function loadModels() {
  *
  * @this Reference to the dbConn module itself.
  */
+
 function init(host, db, port, options, callback) {
-    /*jshint camelcase:false, validthis:true */
     let url;
     let retries = 0;
     let lastError;
-    const maxRetries =
-        (config.getConfig().mongodb && config.getConfig().mongodb.retries) || constants.DEFAULT_MONGODB_RETRIES;
+    const maxRetries = config.getConfig().mongodb?.retries || constants.DEFAULT_MONGODB_RETRIES;
 
     function addPort(item) {
-        return item + ':' + port;
-    }
-
-    function commaConcat(previous, current, currentIndex) {
-        if (currentIndex !== 0) {
-            previous += ',';
-        }
-
-        previous += current;
-
-        return previous;
+        return `${item}:${port}`;
     }
 
     url = 'mongodb://';
 
     if (options.auth) {
-        url += options.auth.user + ':' + options.auth.password + '@';
+        url += `${encodeURIComponent(options.auth.user)}:${encodeURIComponent(options.auth.password)}@`;
     }
 
-    const hosts = host.split(',').map(addPort).reduce(commaConcat, '');
-
-    url += hosts + '/' + db;
+    const hosts = host.split(',').map(addPort).join(',');
+    url += `${hosts}/${db}`;
 
     if (options.extraArgs) {
-        if (options.extraArgs instanceof Object && Object.keys(options.extraArgs).length > 0) {
-            url += '?';
-            url += Object.entries(options.extraArgs)
-                .map(function ([k, v]) {
-                    return encodeURIComponent(k) + '=' + encodeURIComponent(v);
-                })
-                .join('&');
+        const query = new URLSearchParams(options.extraArgs).toString();
+        if (query) {
+            url += `?${query}`;
         }
         delete options.extraArgs;
     }
 
-    /* eslint-disable-next-line no-unused-vars */
-    function createConnectionHandler(error, results) {
-        if (defaultDb) {
-            logger.info(context, 'Successfully connected to MongoDB.');
-            module.exports.db = defaultDb;
-            loadModels();
-        } else {
-            logger.error(context, 'MONGODB-002: Error found after [%d] attempts: %s', retries, error || lastError);
-        }
-
-        callback(error);
-    }
-
-    function retryCheck() {
-        return !defaultDb && retries < maxRetries;
-    }
-
-    function connectionAttempt(url, options, callback) {
-        logger.info(context, 'Attempting to connect to MongoDB instance with url %j. Attempt %d', url, retries);
-        // FIXME: useNewUrlParser is no longer used in underlying mongodb driver 4.x
-        // (see https://github.com/mongodb/node-mongodb-native/blob/HEAD/etc/notes/CHANGES_4.0.0.md)
-        // but not sure if current mongoose version is still using mongodb 3.x internally
-        // probably mongodb-connectionoptions-test.js needs to be fixed if useNewUrlParser is removed at the end
-        options.useNewUrlParser = true;
-        options.useUnifiedTopology = true;
-        mongoose.set('useCreateIndex', true);
-        /* eslint-disable-next-line no-unused-vars */
-        const candidateDb = mongoose.createConnection(url, options, function (error, result) {
-            if (error) {
-                logger.error(context, 'MONGODB-001: Error trying to connect to MongoDB: %s', error);
-                lastError = error;
-            } else {
-                defaultDb = candidateDb;
+    function connectionAttempt(callback) {
+        logger.info(context, `Attempting to connect to MongoDB at ${url}. Attempt ${retries + 1}`);
 
+        mongoose
+            .connect(url, options)
+            .then(() => {
+                defaultDb = mongoose.connection;
+                logger.info(context, 'Successfully connected to MongoDB.');
+                loadModels();
                 defaultDb.on('error', function (error) {
                     logger.error(context, 'Mongo Driver error: %j', error);
+                    lastError = error;
                     alarms.raise(constants.MONGO_ALARM, error);
                 });
                 /* eslint-disable-next-line no-unused-vars */
                 defaultDb.on('connecting', function (error) {
                     logger.debug(context, 'Mongo Driver connecting');
                 });
-
                 defaultDb.on('connected', function () {
                     logger.debug(context, 'Mongo Driver connected');
                 });
@@ -159,72 +117,52 @@ function init(host, db, port, options, callback) {
                 defaultDb.on('close', function () {
                     logger.debug(context, 'Mongo Driver close');
                 });
-            }
-
-            callback();
-        });
-    }
-
-    function tryCreateConnection(callback) {
-        const attempt = async.apply(connectionAttempt, url, options, callback);
-        const seconds =
-            (config.getConfig().mongodb && config.getConfig().mongodb.retryTime) ||
-            constants.DEFAULT_MONGODB_RETRY_TIME;
-
-        retries++;
-
-        if (retries === 1) {
-            logger.info(context, 'First connection attempt');
-            attempt();
-        } else {
-            logger.info(context, 'Waiting %d seconds before attempting again.', seconds);
-            setTimeout(attempt, seconds * 1000);
-        }
+                callback();
+            })
+            .catch((err) => {
+                logger.error(context, `MONGODB-001: Error trying to connect to MongoDB: ${err}`);
+                lastError = err;
+                retries++;
+                if (retries < maxRetries) {
+                    const retryTime = config.getConfig().mongodb?.retryTime || constants.DEFAULT_MONGODB_RETRY_TIME;
+                    logger.info(context, `Retrying in ${retryTime} seconds...`);
+                    setTimeout(() => connectionAttempt(callback), retryTime * 1000);
+                } else {
+                    logger.error(
+                        context,
+                        'MONGODB-002: Error to connect found after %d attempts: %s',
+                        retries,
+                        lastError
+                    );
+                    callback(err);
+                }
+            });
     }
 
-    defaultDb = null;
-    async.whilst(retryCheck, tryCreateConnection, createConnectionHandler);
+    connectionAttempt(callback);
 }
 
 function configureDb(callback) {
-    /*jshint camelcase:false, validthis:true */
     const currentConfig = config.getConfig();
-
-    if (
-        (currentConfig.deviceRegistry && currentConfig.deviceRegistry.type === 'mongodb') ||
-        (currentConfig.stats && currentConfig.stats.persistence === true)
-    ) {
-        if (!currentConfig.mongodb || !currentConfig.mongodb.host) {
+    if (currentConfig.deviceRegistry?.type === 'mongodb') {
+        if (!currentConfig.mongodb?.host) {
             logger.fatal(context, 'MONGODB-003: No host found for MongoDB driver.');
             callback(new errors.BadConfiguration('No host found for MongoDB driver'));
         } else {
-            let dbName = currentConfig.mongodb.db;
+            const dbName = currentConfig.mongodb.db || DEFAULT_DB_NAME;
             const port = currentConfig.mongodb.port || 27017;
             const options = {};
 
-            if (!currentConfig.mongodb.db) {
-                dbName = DEFAULT_DB_NAME;
-            }
-
-            if (currentConfig.mongodb.replicaSet) {
-                options.replicaSet = currentConfig.mongodb.replicaSet;
-            }
-
-            if (currentConfig.mongodb.ssl) {
-                options.ssl = currentConfig.mongodb.ssl;
-            }
-
-            if (currentConfig.mongodb.extraArgs) {
-                options.extraArgs = currentConfig.mongodb.extraArgs;
-            }
+            if (currentConfig.mongodb.replicaSet) options.replicaSet = currentConfig.mongodb.replicaSet;
+            if (currentConfig.mongodb.ssl) options.ssl = currentConfig.mongodb.ssl;
+            if (currentConfig.mongodb.extraArgs) options.extraArgs = currentConfig.mongodb.extraArgs;
 
             if (currentConfig.mongodb.user && currentConfig.mongodb.password) {
-                options.auth = {};
-                options.auth.user = currentConfig.mongodb.user;
-                options.auth.password = currentConfig.mongodb.password;
-                // authSource only applies if auth is set
+                options.auth = {
+                    user: currentConfig.mongodb.user,
+                    password: currentConfig.mongodb.password
+                };
                 if (currentConfig.mongodb.authSource) {
-                    // Overload extraArgs if it was set
                     options.extraArgs = {
                         ...options.extraArgs,
                         authSource: currentConfig.mongodb.authSource
@@ -232,7 +170,7 @@ function configureDb(callback) {
                 }
             }
 
-            init(config.getConfig().mongodb.host, dbName, port, options, callback);
+            init(currentConfig.mongodb.host, dbName, port, options, callback);
         }
     } else {
         callback();

package/lib/services/commands/commandRegistryMongoDB.js

@@ -22,7 +22,7 @@
  */
 
 const logger = require('logops');
-const dbService = require('../../model/dbConn');
+const mongoose = require('mongoose');
 const intoTrans = require('../common/domain').intoTrans;
 const errors = require('../../errors');
 const Command = require('../../model/Command');
@@ -45,24 +45,26 @@ function findCommand(service, subservice, deviceId, name, callback) {
 
     query.select({ __v: 0 });
 
-    query.exec(function handleGet(error, data) {
-        if (error) {
+    query
+        .exec({})
+        .then((data) => {
+            if (data) {
+                callback(null, data);
+            } else {
+                logger.debug(
+                    context,
+                    'Command for DeviceID [%j] with name [%j] not found with [%j]',
+                    deviceId,
+                    name,
+                    queryObj
+                );
+                callback(new errors.CommandNotFound(name, queryObj));
+            }
+        })
+        .catch((error) => {
             logger.debug(context, 'Internal MongoDB Error getting command: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else if (data) {
-            callback(null, data);
-        } else {
-            logger.debug(
-                context,
-                'Command for DeviceID [%j] with name [%j] not found with [%j]',
-                deviceId,
-                name,
-                queryObj
-            );
-            callback(new errors.CommandNotFound(name, queryObj));
-        }
-    });
+        });
 }
 
 function updateCommand(service, subservice, deviceId, command, callback) {
@@ -72,9 +74,14 @@ function updateCommand(service, subservice, deviceId, command, callback) {
         } else {
             commandDAO.value = command.value;
 
-            commandDAO.save(function (error) {
-                callback(error, commandDAO.toObject());
-            });
+            commandDAO
+                .save({})
+                .then((commandDAOs) => {
+                    callback(null, commandDAOs.toObject());
+                })
+                .catch((error) => {
+                    callback(error);
+                });
         }
     });
 }
@@ -94,15 +101,15 @@ function createCommand(service, subservice, deviceId, command, callback) {
 
     logger.debug(context, 'Storing command for deviceId [%s] with name [%s]', deviceId, command.name);
 
-    commandObj.save(function saveHandler(error, commandDAO) {
-        if (error) {
+    commandObj
+        .save({})
+        .then((commandDAO) => {
+            callback(null, commandDAO.toObject());
+        })
+        .catch((error) => {
             logger.debug(context, 'Error storing command information: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else {
-            callback(null, commandDAO.toObject());
-        }
-    });
+        });
 }
 
 function addCommand(service, subservice, deviceId, command, callback) {
@@ -129,16 +136,33 @@ function listCommands(service, subservice, deviceId, callback) {
     condition.deviceId = deviceId;
 
     const query = Command.model.find(condition).sort();
-
-    async.series(
-        [query.exec.bind(query), Command.model.countDocuments.bind(Command.model, condition)],
-        function (error, results) {
-            callback(error, {
-                count: results[1],
-                commands: results[0].map(toObjectFn)
+    const queryCount = Command.model.countDocuments(condition);
+    function funcQuery(cb) {
+        query
+            .exec({})
+            .then((res) => {
+                cb(null, res);
+            })
+            .catch((error) => {
+                cb(error);
             });
-        }
-    );
+    }
+    function funcQueryCount(cb) {
+        queryCount
+            .exec({})
+            .then((res) => {
+                cb(null, res);
+            })
+            .catch((error) => {
+                cb(error);
+            });
+    }
+    async.series([funcQuery, funcQueryCount], function (error, results) {
+        callback(error, {
+            count: results[1],
+            commands: results[0].map(toObjectFn)
+        });
+    });
 }
 
 function remove(service, subservice, deviceId, name, callback) {
@@ -155,26 +179,29 @@ function remove(service, subservice, deviceId, name, callback) {
         if (error) {
             callback(error);
         } else {
-            Command.model.deleteOne({ _id: command._id }, function (error, commandResult) {
-                if (error) {
+            const query = Command.model.deleteOne({ _id: command._id });
+            query
+                .exec({})
+                .then((commandResult) => {
+                    if (commandResult && commandResult.result && commandResult.result.n === 1) {
+                        logger.debug(context, 'Command [%s] successfully removed.', name);
+
+                        callback(null, commandResult);
+                    } else {
+                        const deviceInfo = {
+                            service,
+                            subservice,
+                            deviceId,
+                            name
+                        };
+                        logger.debug(context, 'Command [%s] not found for removal with %j', name, deviceInfo);
+                        callback(new errors.CommandNotFound(name, deviceInfo));
+                    }
+                })
+                .catch((error) => {
                     logger.debug(context, 'Internal MongoDB Error getting command: %s', error);
-
                     callback(new errors.InternalDbError(error));
-                } else if (commandResult && commandResult.result && commandResult.result.n === 1) {
-                    logger.debug(context, 'Command [%s] successfully removed.', name);
-
-                    callback(null, commandResult);
-                } else {
-                    const deviceInfo = {
-                        service,
-                        subservice,
-                        deviceId,
-                        name
-                    };
-                    logger.debug(context, 'Command [%s] not found for removal with %j', name, deviceInfo);
-                    callback(new errors.CommandNotFound(name, deviceInfo));
-                }
-            });
+                });
         }
     });
 }
@@ -190,35 +217,48 @@ function listToObject(commandList) {
 }
 
 function removeFromDate(creationDate, callback) {
-    const query = { creationDate: { $lt: creationDate } };
+    const condition = { creationDate: { $lt: creationDate } };
 
     if (Command.model) {
-        Command.model.find(query).exec(function (error, commandList) {
-            if (!error && commandList && commandList.length > 0) {
-                Command.model.deleteOne(query, function (error) {
-                    if (error) {
-                        logger.debug(context, 'Internal MongoDB Error removing expired commands: %s', error);
-
-                        callback(new errors.InternalDbError(error));
-                    } else {
-                        logger.debug(
-                            context,
-                            'Expired commands successfully removed from MongoDB for date [%s]',
-                            creationDate
-                        );
-
-                        callback(null, listToObject(commandList));
-                    }
-                });
-            }
-        });
+        const query = Command.model.find(condition);
+        query
+            .exec({})
+            .then((commandList) => {
+                if (commandList && commandList.length > 0) {
+                    const queryDel = Command.model.deleteOne(condition);
+                    queryDel
+                        .exec({})
+                        .then(() => {
+                            logger.debug(
+                                context,
+                                'Expired commands successfully removed from MongoDB for date [%s]',
+                                creationDate
+                            );
+                            callback(null, listToObject(commandList));
+                        })
+                        .catch((error) => {
+                            logger.debug(context, 'Internal MongoDB Error removing expired commands: %s', error);
+                            callback(new errors.InternalDbError(error));
+                        });
+                }
+            })
+            .catch((error) => {
+                logger.debug(context, 'Internal MongoDB Error looking for expired commands: %s', error);
+            });
     } else {
         callback(null, []);
     }
 }
 
 function clear(callback) {
-    dbService.db.db.dropDatabase(callback);
+    mongoose.connection
+        .dropDatabase()
+        .then(() => {
+            callback(null);
+        })
+        .catch((error) => {
+            callback(error);
+        });
 }
 
 function init(newConfig, callback) {

package/lib/services/common/alarmManagement.js

@@ -22,6 +22,7 @@
  */
 
 let alarmRepository = {};
+const statsRegistry = require('../stats/statsRegistry');
 const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.Alarms'
@@ -41,6 +42,7 @@ function raise(alarmName, description) {
         };
 
         logger.error(context, 'Raising [%s]: %j', alarmName, description);
+        statsRegistry.add('raiseAlarm', 1, function () {});
     }
 }
 
@@ -53,6 +55,7 @@ function release(alarmName) {
     if (alarmRepository[alarmName]) {
         delete alarmRepository[alarmName];
         logger.error(context, 'Releasing [%s]', alarmName);
+        statsRegistry.add('releaseAlarm', 1, function () {});
     }
 }
 

package/lib/services/common/iotManagerService.js

@@ -63,7 +63,9 @@ function register(callback) {
             entityNameExp: service.entityNameExp,
             payloadType: service.payloadType,
             endpoint: service.endpoint,
-            transport: service.transport
+            transport: service.transport,
+            useCBflowControl: service.useCBflowControl,
+            storeLastMeasure: service.storeLastMeasure
         };
     }
 

package/lib/services/devices/deviceRegistryMemory.js

@@ -210,8 +210,44 @@ function getDevicesByAttribute(name, value, service, subservice, callback) {
     }
 }
 
+function storeDeviceField(fieldName, fieldValue, typeInformation, callback) {
+    if (
+        typeInformation &&
+        typeInformation.id &&
+        typeInformation.apikey &&
+        typeInformation.service &&
+        typeInformation.subservice
+    ) {
+        getDevice(
+            typeInformation.id,
+            typeInformation.apikey,
+            typeInformation.service,
+            typeInformation.subservice,
+            function (error, data) {
+                if (!error) {
+                    if (data) {
+                        if (fieldName === 'lastMeasure') {
+                            data.lastMeasure = { timestamp: new Date().toISOString(), measure: fieldValue };
+                        } else {
+                            data[fieldName] = fieldValue;
+                        }
+                    }
+                    if (callback) {
+                        callback(null, data);
+                    }
+                } else {
+                    callback(error, null);
+                }
+            }
+        );
+    } else {
+        callback(null, null);
+    }
+}
+
 exports.getDevicesByAttribute = getDevicesByAttribute;
 exports.store = storeDevice;
+exports.storeDeviceField = storeDeviceField;
 exports.update = update;
 exports.remove = removeDevice;
 exports.list = listDevices;