11933245682

Committed 20 Nov 2024 12:19PM UTC coverage: 80.04% (-0.2%) from 80.208%

Build # 11933245682

Build Type

Pull #1670

github

Committed by

web-flow

Commit Message

Merge e1ab070fa into 518d322ef

Pull Request Pull Request #1670: Task/store last measure

Run Details

1945 of 2596 branches covered (74.92%)

Branch coverage included in aggregate %.

18 of 29 new or added lines in 4 files covered. (62.07%)

28 existing lines in 2 files now uncovered.

3717 of 4478 relevant lines covered (83.01%)

283.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.85

/lib/services/ngsi/ngsiService.js

/*
 * Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
 *
 * This file is part of fiware-iotagent-lib
 *
 * fiware-iotagent-lib is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 *
 * fiware-iotagent-lib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with fiware-iotagent-lib.
 * If not, see http://www.gnu.org/licenses/.
 *
 * For those usages not covered by the GNU Affero General Public License
 * please contact with::daniel.moranjimenez@telefonica.com
 *
 * Modified by: Federico M. Facca - Martel Innovate
 * Modified by: Daniel Calvo - ATOS Research & Innovation
 */

const async = require('async');
const apply = async.apply;
const statsRegistry = require('../stats/statsRegistry');
const deviceService = require('../devices/deviceService');
const intoTrans = require('../common/domain').intoTrans;
const fillService = require('./../common/domain').fillService;
const errors = require('../../errors');
const config = require('../../commonConfig');
const constants = require('../../constants');
const logger = require('logops');
const ngsiUtils = require('./ngsiUtils');
const _ = require('underscore');
const context = {
    op: 'IoTAgentNGSI.NGSIService'
};

const attributeList = ['trust', 'cbHost', 'ngsiVersion'];
let entityHandler;

/**
 * Loads the correct ngsiService handler based on the current config.
 */
function init() {
    switch (config.ngsiVersion()) {
        case 'ld':
            entityHandler = require('./entities-NGSI-LD');
            break;
        case 'mixed':
            entityHandler = require('./entities-NGSI-mixed');
            break;
        default:
            entityHandler = require('./entities-NGSI-v2');
    }
}

/**
 * Makes an update in the Device's entity in the context broker, with the values given in the 'attributes' array. This
 * array should comply to the NGSI's attribute format.
 *
 * @param {String} entityName       Name of the entity to register.
 * @param {Array} attributes        Attribute array containing the values to update.
 * @param {Object} typeInformation  Configuration information for the device.
 * @param {String} token            User token to identify against the PEP Proxies (optional).
 */
function sendUpdateValue(entityName, attributes, typeInformation, token, callback) {
    deviceService.storeLastMeasure(attributes, typeInformation, function () {
        const newCallback = statsRegistry.withStats('updateEntityRequestsOk', 'updateEntityRequestsError', callback);
        return entityHandler.sendUpdateValue(entityName, attributes, typeInformation, token, newCallback);
    });
}

/**
 * Makes a query to the Device's entity in the context broker, with the list of attributes given by the 'attributes'
 * array.
 *
 * @param {String} entityName       Name of the entity to query.
 * @param {Array} attributes        Attribute array containing the names of the attributes to query.
 * @param {Object} typeInformation  Configuration information for the device.
 * @param {String} token            User token to identify against the PEP Proxies (optional).
 */
function sendQueryValue(entityName, attributes, typeInformation, token, callback) {
    entityHandler.sendQueryValue(entityName, attributes, typeInformation, token, callback);
}

/**
 * Update the trust for a device or a deviceGroup depending on the source of the trust token.
 * Currently is a placeholder, but it is needed in case of Auth services which tokens have
 * expiration.
 *
 * @param {Object} deviceGroup        The deviceGroup where the trust token was stored. Null if stored in actual device.
 * @param {Object} deviceInformation  The device where the trust token was stored. Null if stored in deviceGroup.
 * @param {String} trust              The current trust token.
 * @param {Object} response           The response where the new token is stored.
 * @param {Function} callback         The callback function.
 */

function updateTrust(deviceGroup, deviceInformation, trust, response, callback) {
    if (deviceGroup && response && response.body && !config.getConfig().authentication.permanentToken) {
        const body = JSON.parse(response.body);
        if (body && body.refresh_token) {
            deviceGroup.trust = body.refresh_token;
            /* eslint-disable-next-line no-unused-vars */
            config.getGroupRegistry().update(deviceGroup._id, deviceGroup, function (error, cb) {
                callback(null, response);
            });
        } else {
            callback(null, response);
        }
    } else {
        callback(null, response);
    }
}

/**
 * Launches an operation against the Context Broker, getting the security token in case the authorization sequence is
 * enabled. This method can be invoked with an externally added deviceInformation object to overwrite the information
 * on the configuration (for preregistered devices).
 *
 * @param {Function} operationFunction  Function to execute once the credentials and device information were retrieved.
 * @return {Function}                   The function that gets all the information wrapping the given operation.
 */
function executeWithDeviceInformation(operationFunction) {
    return function (entityName, type, apikey, attributes, deviceInformation, callback) {
        fillService(context, deviceInformation);
        logger.debug(
            context,
            'executeWithDeviceInfo entityName %s type %s apikey %s attributes %j deviceInformation %j',
            entityName,
            type,
            apikey,
            attributes,
            deviceInformation
        );
        const currentType = type ? type : deviceInformation.type;
        config.getGroupRegistry().getTypeSilently(currentType, function (error, deviceGroup) {
            let typeInformation;
            const configDeviceInfo = config.getConfig().types[currentType];
            if (error) {
                logger.debug(context, 'error %j in get group device', error);
            }

            // For anonymous devices use the typeInformation from the provisioned group and/or config directly.
            // For preregistered devices, augment the existing deviceInformation with selected attributes.
            if (!callback) {
                callback = deviceInformation;
                typeInformation = deviceGroup || { ...config.getConfigForTypeInformation(), ...configDeviceInfo };
            } else {
                typeInformation = { ...config.getConfigForTypeInformation(), ...deviceInformation };
                attributeList.forEach((key) => {
                    typeInformation[key] =
                        typeInformation[key] || (deviceGroup || {})[key] || (configDeviceInfo || {})[key];
                });
            }

            if (config.getConfig().authentication && config.getConfig().authentication.enabled) {
                const security = config.getSecurityService();
                if (typeInformation && typeInformation.trust) {
                    async.waterfall(
                        [
                            apply(security.auth, typeInformation.trust),
                            apply(updateTrust, deviceGroup, deviceInformation, typeInformation.trust),
                            apply(security.getToken, typeInformation.trust),
                            apply(operationFunction, entityName, attributes, typeInformation)
                        ],
                        callback
                    );
                } else {
                    callback(new errors.SecurityInformationMissing(typeInformation.type));
                }
            } else {
                operationFunction(entityName, attributes, typeInformation, null, callback);
            }
        });
    };
}

/**
 * Update the result of a command in the Context Broker. The result of the command has two components: the result
 * of the command itself will be represented with the sufix '_info' in the entity while the status is updated in the
 * attribute with the '_status' sufix.
 *
 * @param {String} entityName           Name of the entity holding the command.
 * @param {String} resource             Resource name of the endpoint the device is calling.
 * @param {String} apikey               Apikey the device is using to send the values.
 * @param {String} commandName          Name of the command whose result is being updated.
 * @param {String} commandResult        Result of the command in string format.
 * @param {Object} deviceInformation    Device information, including security and service information. (optional).
 */
function setCommandResult(
    entityName,
    resource,
    apikey,
    commandName,
    commandResult,
    status,
    deviceInformation,
    callback
) {
    config.getGroupRegistry().get(resource, apikey, function (error, deviceGroup) {
        let typeInformation;
        let commandInfo;
        const attributes = [
            {
                name: commandName + constants.COMMAND_STATUS_SUFIX,
                type: constants.COMMAND_STATUS,
                value: status
            },
            {
                name: commandName + constants.COMMAND_RESULT_SUFIX,
                type: constants.COMMAND_RESULT,
                value: commandResult
            }
        ];

        // For anonymous devices use the typeInformation from the provisioned group and/or config directly.
        // For preregistered devices, augment the existing deviceInformation with selected attributes.
        if (!callback) {
            callback = deviceInformation;
            typeInformation = deviceGroup || config.getConfig().types[resource];
        } else {
            typeInformation = deviceInformation;
        }

        // Ensure type, servce and subservice are always set, using fallbacks as necessary.
        typeInformation.type = typeInformation.type || (deviceGroup || {}).type || resource;
        typeInformation.service = typeInformation.service || config.getConfig().service;
        typeInformation.subservice = typeInformation.subservice || config.getConfig().subservice;

        commandInfo = _.where(typeInformation.commands, { name: commandName });

        if (deviceGroup && commandInfo.length !== 1) {
            commandInfo = _.where(deviceGroup.commands, { name: commandName });
        }

        if (commandInfo.length === 1) {
            exports.update(entityName, typeInformation.type, apikey, attributes, typeInformation, callback);
        } else {
            callback(new errors.CommandNotFound(commandName, typeInformation));
        }
    });
}

function addUpdateMiddleware(middleware) {
    ngsiUtils.updateMiddleware.push(middleware);
}

function addQueryMiddleware(middleware) {
    ngsiUtils.queryMiddleware.push(middleware);
}

function resetMiddlewares(callback) {
    ngsiUtils.updateMiddleware = [];
    ngsiUtils.queryMiddleware = [];

    callback();
}

exports.update = intoTrans(context, executeWithDeviceInformation)(sendUpdateValue);
exports.query = intoTrans(context, executeWithDeviceInformation)(sendQueryValue);
exports.addUpdateMiddleware = intoTrans(context, addUpdateMiddleware);
exports.addQueryMiddleware = intoTrans(context, addQueryMiddleware);
exports.resetMiddlewares = intoTrans(context, resetMiddlewares);
exports.setCommandResult = intoTrans(context, setCommandResult);
exports.updateTrust = updateTrust;
exports.init = init;

1	/*
2	* Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
3	*
4	* This file is part of fiware-iotagent-lib
5	*
6	* fiware-iotagent-lib is free software: you can redistribute it and/or
7	* modify it under the terms of the GNU Affero General Public License as
8	* published by the Free Software Foundation, either version 3 of the License,
9	* or (at your option) any later version.
10	*
11	* fiware-iotagent-lib is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14	* See the GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public
17	* License along with fiware-iotagent-lib.
18	* If not, see http://www.gnu.org/licenses/.
19	*
20	* For those usages not covered by the GNU Affero General Public License
21	* please contact with::daniel.moranjimenez@telefonica.com
22	*
23	* Modified by: Federico M. Facca - Martel Innovate
24	* Modified by: Daniel Calvo - ATOS Research & Innovation
25	*/
26
27	const async = require('async');	1✔
28	const apply = async.apply;	1✔
29	const statsRegistry = require('../stats/statsRegistry');	1✔
30	const deviceService = require('../devices/deviceService');	1✔
31	const intoTrans = require('../common/domain').intoTrans;	1✔
32	const fillService = require('./../common/domain').fillService;	1✔
33	const errors = require('../../errors');	1✔
34	const config = require('../../commonConfig');	1✔
35	const constants = require('../../constants');	1✔
36	const logger = require('logops');	1✔
37	const ngsiUtils = require('./ngsiUtils');	1✔
38	const _ = require('underscore');	1✔
39	const context = {	1✔
40	op: 'IoTAgentNGSI.NGSIService'
41	};
42
43	const attributeList = ['trust', 'cbHost', 'ngsiVersion'];	1✔
44	let entityHandler;
45
46	/**
47	* Loads the correct ngsiService handler based on the current config.
48	*/
49	function init() {
50	switch (config.ngsiVersion()) {	803✔
51	case 'ld':
52	entityHandler = require('./entities-NGSI-LD');	225✔
53	break;	225✔
54	case 'mixed':
55	entityHandler = require('./entities-NGSI-mixed');	3✔
56	break;	3✔
57	default:
58	entityHandler = require('./entities-NGSI-v2');	575✔
59	}
60	}
61
62	/**
63	* Makes an update in the Device's entity in the context broker, with the values given in the 'attributes' array. This
64	* array should comply to the NGSI's attribute format.
65	*
66	* @param {String} entityName Name of the entity to register.
67	* @param {Array} attributes Attribute array containing the values to update.
68	* @param {Object} typeInformation Configuration information for the device.
69	* @param {String} token User token to identify against the PEP Proxies (optional).
70	*/
71	function sendUpdateValue(entityName, attributes, typeInformation, token, callback) {
72	deviceService.storeLastMeasure(attributes, typeInformation, function () {	303✔
73	const newCallback = statsRegistry.withStats('updateEntityRequestsOk', 'updateEntityRequestsError', callback);	303✔
74	return entityHandler.sendUpdateValue(entityName, attributes, typeInformation, token, newCallback);	303✔
75	});
76	}
77
78	/**
79	* Makes a query to the Device's entity in the context broker, with the list of attributes given by the 'attributes'
80	* array.
81	*
82	* @param {String} entityName Name of the entity to query.
83	* @param {Array} attributes Attribute array containing the names of the attributes to query.
84	* @param {Object} typeInformation Configuration information for the device.
85	* @param {String} token User token to identify against the PEP Proxies (optional).
86	*/
87	function sendQueryValue(entityName, attributes, typeInformation, token, callback) {
88	entityHandler.sendQueryValue(entityName, attributes, typeInformation, token, callback);	10✔
89	}
90
91	/**
92	* Update the trust for a device or a deviceGroup depending on the source of the trust token.
93	* Currently is a placeholder, but it is needed in case of Auth services which tokens have
94	* expiration.
95	*
96	* @param {Object} deviceGroup The deviceGroup where the trust token was stored. Null if stored in actual device.
97	* @param {Object} deviceInformation The device where the trust token was stored. Null if stored in deviceGroup.
98	* @param {String} trust The current trust token.
99	* @param {Object} response The response where the new token is stored.
100	* @param {Function} callback The callback function.
101	*/
102
103	function updateTrust(deviceGroup, deviceInformation, trust, response, callback) {
104	if (deviceGroup && response && response.body && !config.getConfig().authentication.permanentToken) {	47✔
105	const body = JSON.parse(response.body);	8✔
106	if (body && body.refresh_token) {	8!
107	deviceGroup.trust = body.refresh_token;	8✔
108	/* eslint-disable-next-line no-unused-vars */
109	config.getGroupRegistry().update(deviceGroup._id, deviceGroup, function (error, cb) {	8✔
110	callback(null, response);	8✔
111	});
112	} else {
UNCOV 113	callback(null, response);	×
114	}
115	} else {
116	callback(null, response);	39✔
117	}
118	}
119
120	/**
121	* Launches an operation against the Context Broker, getting the security token in case the authorization sequence is
122	* enabled. This method can be invoked with an externally added deviceInformation object to overwrite the information
123	* on the configuration (for preregistered devices).
124	*
125	* @param {Function} operationFunction Function to execute once the credentials and device information were retrieved.
126	* @return {Function} The function that gets all the information wrapping the given operation.
127	*/
128	function executeWithDeviceInformation(operationFunction) {
129	return function (entityName, type, apikey, attributes, deviceInformation, callback) {	2✔
130	fillService(context, deviceInformation);	320✔
131	logger.debug(	320✔
132	context,
133	'executeWithDeviceInfo entityName %s type %s apikey %s attributes %j deviceInformation %j',
134	entityName,
135	type,
136	apikey,
137	attributes,
138	deviceInformation
139	);
140	const currentType = type ? type : deviceInformation.type;	320!
141	config.getGroupRegistry().getTypeSilently(currentType, function (error, deviceGroup) {	320✔
142	let typeInformation;
143	const configDeviceInfo = config.getConfig().types[currentType];	320✔
144	if (error) {	320✔
145	logger.debug(context, 'error %j in get group device', error);	306✔
146	}
147
148	// For anonymous devices use the typeInformation from the provisioned group and/or config directly.
149	// For preregistered devices, augment the existing deviceInformation with selected attributes.
150	if (!callback) {	320✔
151	callback = deviceInformation;	298✔
152	typeInformation = deviceGroup \|\| { ...config.getConfigForTypeInformation(), ...configDeviceInfo };	298✔
153	} else {
154	typeInformation = { ...config.getConfigForTypeInformation(), ...deviceInformation };	22✔
155	attributeList.forEach((key) => {	22✔
156	typeInformation[key] =	66✔
157	typeInformation[key] \|\| (deviceGroup \|\| {})[key] \|\| (configDeviceInfo \|\| {})[key];	396!
158	});
159	}
160
161	if (config.getConfig().authentication && config.getConfig().authentication.enabled) {	320✔
162	const security = config.getSecurityService();	37✔
163	if (typeInformation && typeInformation.trust) {	37!
164	async.waterfall(	37✔
165	[
166	apply(security.auth, typeInformation.trust),
167	apply(updateTrust, deviceGroup, deviceInformation, typeInformation.trust),
168	apply(security.getToken, typeInformation.trust),
169	apply(operationFunction, entityName, attributes, typeInformation)
170	],
171	callback
172	);
173	} else {
UNCOV 174	callback(new errors.SecurityInformationMissing(typeInformation.type));	×
175	}
176	} else {
177	operationFunction(entityName, attributes, typeInformation, null, callback);	283✔
178	}
179	});
180	};
181	}
182
183	/**
184	* Update the result of a command in the Context Broker. The result of the command has two components: the result
185	* of the command itself will be represented with the sufix '_info' in the entity while the status is updated in the
186	* attribute with the '_status' sufix.
187	*
188	* @param {String} entityName Name of the entity holding the command.
189	* @param {String} resource Resource name of the endpoint the device is calling.
190	* @param {String} apikey Apikey the device is using to send the values.
191	* @param {String} commandName Name of the command whose result is being updated.
192	* @param {String} commandResult Result of the command in string format.
193	* @param {Object} deviceInformation Device information, including security and service information. (optional).
194	*/
195	function setCommandResult(
196	entityName,
197	resource,
198	apikey,
199	commandName,
200	commandResult,
201	status,
202	deviceInformation,
203	callback
204	) {
205	config.getGroupRegistry().get(resource, apikey, function (error, deviceGroup) {	6✔
206	let typeInformation;
207	let commandInfo;
208	const attributes = [	6✔
209	{
210	name: commandName + constants.COMMAND_STATUS_SUFIX,
211	type: constants.COMMAND_STATUS,
212	value: status
213	},
214	{
215	name: commandName + constants.COMMAND_RESULT_SUFIX,
216	type: constants.COMMAND_RESULT,
217	value: commandResult
218	}
219	];
220
221	// For anonymous devices use the typeInformation from the provisioned group and/or config directly.
222	// For preregistered devices, augment the existing deviceInformation with selected attributes.
223	if (!callback) {	6✔
224	callback = deviceInformation;	4✔
225	typeInformation = deviceGroup \|\| config.getConfig().types[resource];	4✔
226	} else {
227	typeInformation = deviceInformation;	2✔
228	}
229
230	// Ensure type, servce and subservice are always set, using fallbacks as necessary.
231	typeInformation.type = typeInformation.type \|\| (deviceGroup \|\| {}).type \|\| resource;	6✔
232	typeInformation.service = typeInformation.service \|\| config.getConfig().service;	6✔
233	typeInformation.subservice = typeInformation.subservice \|\| config.getConfig().subservice;	6✔
234
235	commandInfo = _.where(typeInformation.commands, { name: commandName });	6✔
236
237	if (deviceGroup && commandInfo.length !== 1) {	6!
UNCOV 238	commandInfo = _.where(deviceGroup.commands, { name: commandName });	×
239	}
240
241	if (commandInfo.length === 1) {	6!
242	exports.update(entityName, typeInformation.type, apikey, attributes, typeInformation, callback);	6✔
243	} else {
UNCOV 244	callback(new errors.CommandNotFound(commandName, typeInformation));	×
245	}
246	});
247	}
248
249	function addUpdateMiddleware(middleware) {
250	ngsiUtils.updateMiddleware.push(middleware);	4✔
251	}
252
253	function addQueryMiddleware(middleware) {
254	ngsiUtils.queryMiddleware.push(middleware);	4✔
255	}
256
257	function resetMiddlewares(callback) {
258	ngsiUtils.updateMiddleware = [];	748✔
259	ngsiUtils.queryMiddleware = [];	748✔
260
261	callback();	748✔
262	}
263
264	exports.update = intoTrans(context, executeWithDeviceInformation)(sendUpdateValue);	1✔
265	exports.query = intoTrans(context, executeWithDeviceInformation)(sendQueryValue);	1✔
266	exports.addUpdateMiddleware = intoTrans(context, addUpdateMiddleware);	1✔
267	exports.addQueryMiddleware = intoTrans(context, addQueryMiddleware);	1✔
268	exports.resetMiddlewares = intoTrans(context, resetMiddlewares);	1✔
269	exports.setCommandResult = intoTrans(context, setCommandResult);	1✔
270	exports.updateTrust = updateTrust;	1✔
271	exports.init = init;	1✔

telefonicaid / iotagent-node-lib / 11933245682

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous