11915483619

Committed 19 Nov 2024 02:45PM UTC coverage: 80.093% (-0.1%) from 80.208%

Build # 11915483619

Build Type

Pull #1670

github

Committed by

web-flow

Commit Message

Merge aaffe7bd6 into 518d322ef

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

Run Details

1946 of 2594 branches covered (75.02%)

Branch coverage included in aggregate %.

15 of 24 new or added lines in 4 files covered. (62.5%)

27 existing lines in 2 files now uncovered.

3715 of 4474 relevant lines covered (83.04%)

283.22 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) {
    const newCallback = statsRegistry.withStats('updateEntityRequestsOk', 'updateEntityRequestsError', callback);
    const updateCallback = entityHandler.sendUpdateValue(entityName, attributes, typeInformation, token, newCallback);
    deviceService.storeLastMeasure(attributes, typeInformation, updateCallback);
}

/**
 * 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	const newCallback = statsRegistry.withStats('updateEntityRequestsOk', 'updateEntityRequestsError', callback);	303✔
73	const updateCallback = entityHandler.sendUpdateValue(entityName, attributes, typeInformation, token, newCallback);	303✔
74	deviceService.storeLastMeasure(attributes, typeInformation, updateCallback);	303✔
75	}
76
77	/**
78	* Makes a query to the Device's entity in the context broker, with the list of attributes given by the 'attributes'
79	* array.
80	*
81	* @param {String} entityName Name of the entity to query.
82	* @param {Array} attributes Attribute array containing the names of the attributes to query.
83	* @param {Object} typeInformation Configuration information for the device.
84	* @param {String} token User token to identify against the PEP Proxies (optional).
85	*/
86	function sendQueryValue(entityName, attributes, typeInformation, token, callback) {
87	entityHandler.sendQueryValue(entityName, attributes, typeInformation, token, callback);	10✔
88	}
89
90	/**
91	* Update the trust for a device or a deviceGroup depending on the source of the trust token.
92	* Currently is a placeholder, but it is needed in case of Auth services which tokens have
93	* expiration.
94	*
95	* @param {Object} deviceGroup The deviceGroup where the trust token was stored. Null if stored in actual device.
96	* @param {Object} deviceInformation The device where the trust token was stored. Null if stored in deviceGroup.
97	* @param {String} trust The current trust token.
98	* @param {Object} response The response where the new token is stored.
99	* @param {Function} callback The callback function.
100	*/
101
102	function updateTrust(deviceGroup, deviceInformation, trust, response, callback) {
103	if (deviceGroup && response && response.body && !config.getConfig().authentication.permanentToken) {	47✔
104	const body = JSON.parse(response.body);	8✔
105	if (body && body.refresh_token) {	8!
106	deviceGroup.trust = body.refresh_token;	8✔
107	/* eslint-disable-next-line no-unused-vars */
108	config.getGroupRegistry().update(deviceGroup._id, deviceGroup, function (error, cb) {	8✔
109	callback(null, response);	8✔
110	});
111	} else {
UNCOV 112	callback(null, response);	×
113	}
114	} else {
115	callback(null, response);	39✔
116	}
117	}
118
119	/**
120	* Launches an operation against the Context Broker, getting the security token in case the authorization sequence is
121	* enabled. This method can be invoked with an externally added deviceInformation object to overwrite the information
122	* on the configuration (for preregistered devices).
123	*
124	* @param {Function} operationFunction Function to execute once the credentials and device information were retrieved.
125	* @return {Function} The function that gets all the information wrapping the given operation.
126	*/
127	function executeWithDeviceInformation(operationFunction) {
128	return function (entityName, type, apikey, attributes, deviceInformation, callback) {	2✔
129	fillService(context, deviceInformation);	320✔
130	logger.debug(	320✔
131	context,
132	'executeWithDeviceInfo entityName %s type %s apikey %s attributes %j deviceInformation %j',
133	entityName,
134	type,
135	apikey,
136	attributes,
137	deviceInformation
138	);
139	const currentType = type ? type : deviceInformation.type;	320!
140	config.getGroupRegistry().getTypeSilently(currentType, function (error, deviceGroup) {	320✔
141	let typeInformation;
142	const configDeviceInfo = config.getConfig().types[currentType];	320✔
143	if (error) {	320✔
144	logger.debug(context, 'error %j in get group device', error);	306✔
145	}
146
147	// For anonymous devices use the typeInformation from the provisioned group and/or config directly.
148	// For preregistered devices, augment the existing deviceInformation with selected attributes.
149	if (!callback) {	320✔
150	callback = deviceInformation;	298✔
151	typeInformation = deviceGroup \|\| { ...config.getConfigForTypeInformation(), ...configDeviceInfo };	298✔
152	} else {
153	typeInformation = { ...config.getConfigForTypeInformation(), ...deviceInformation };	22✔
154	attributeList.forEach((key) => {	22✔
155	typeInformation[key] =	66✔
156	typeInformation[key] \|\| (deviceGroup \|\| {})[key] \|\| (configDeviceInfo \|\| {})[key];	396!
157	});
158	}
159
160	if (config.getConfig().authentication && config.getConfig().authentication.enabled) {	320✔
161	const security = config.getSecurityService();	37✔
162	if (typeInformation && typeInformation.trust) {	37!
163	async.waterfall(	37✔
164	[
165	apply(security.auth, typeInformation.trust),
166	apply(updateTrust, deviceGroup, deviceInformation, typeInformation.trust),
167	apply(security.getToken, typeInformation.trust),
168	apply(operationFunction, entityName, attributes, typeInformation)
169	],
170	callback
171	);
172	} else {
UNCOV 173	callback(new errors.SecurityInformationMissing(typeInformation.type));	×
174	}
175	} else {
176	operationFunction(entityName, attributes, typeInformation, null, callback);	283✔
177	}
178	});
179	};
180	}
181
182	/**
183	* Update the result of a command in the Context Broker. The result of the command has two components: the result
184	* of the command itself will be represented with the sufix '_info' in the entity while the status is updated in the
185	* attribute with the '_status' sufix.
186	*
187	* @param {String} entityName Name of the entity holding the command.
188	* @param {String} resource Resource name of the endpoint the device is calling.
189	* @param {String} apikey Apikey the device is using to send the values.
190	* @param {String} commandName Name of the command whose result is being updated.
191	* @param {String} commandResult Result of the command in string format.
192	* @param {Object} deviceInformation Device information, including security and service information. (optional).
193	*/
194	function setCommandResult(
195	entityName,
196	resource,
197	apikey,
198	commandName,
199	commandResult,
200	status,
201	deviceInformation,
202	callback
203	) {
204	config.getGroupRegistry().get(resource, apikey, function (error, deviceGroup) {	6✔
205	let typeInformation;
206	let commandInfo;
207	const attributes = [	6✔
208	{
209	name: commandName + constants.COMMAND_STATUS_SUFIX,
210	type: constants.COMMAND_STATUS,
211	value: status
212	},
213	{
214	name: commandName + constants.COMMAND_RESULT_SUFIX,
215	type: constants.COMMAND_RESULT,
216	value: commandResult
217	}
218	];
219
220	// For anonymous devices use the typeInformation from the provisioned group and/or config directly.
221	// For preregistered devices, augment the existing deviceInformation with selected attributes.
222	if (!callback) {	6✔
223	callback = deviceInformation;	4✔
224	typeInformation = deviceGroup \|\| config.getConfig().types[resource];	4✔
225	} else {
226	typeInformation = deviceInformation;	2✔
227	}
228
229	// Ensure type, servce and subservice are always set, using fallbacks as necessary.
230	typeInformation.type = typeInformation.type \|\| (deviceGroup \|\| {}).type \|\| resource;	6✔
231	typeInformation.service = typeInformation.service \|\| config.getConfig().service;	6✔
232	typeInformation.subservice = typeInformation.subservice \|\| config.getConfig().subservice;	6✔
233
234	commandInfo = _.where(typeInformation.commands, { name: commandName });	6✔
235
236	if (deviceGroup && commandInfo.length !== 1) {	6!
UNCOV 237	commandInfo = _.where(deviceGroup.commands, { name: commandName });	×
238	}
239
240	if (commandInfo.length === 1) {	6!
241	exports.update(entityName, typeInformation.type, apikey, attributes, typeInformation, callback);	6✔
242	} else {
243	callback(new errors.CommandNotFound(commandName, typeInformation));	×
244	}
245	});
246	}
247
248	function addUpdateMiddleware(middleware) {
249	ngsiUtils.updateMiddleware.push(middleware);	4✔
250	}
251
252	function addQueryMiddleware(middleware) {
253	ngsiUtils.queryMiddleware.push(middleware);	4✔
254	}
255
256	function resetMiddlewares(callback) {
257	ngsiUtils.updateMiddleware = [];	748✔
258	ngsiUtils.queryMiddleware = [];	748✔
259
260	callback();	748✔
261	}
262
263	exports.update = intoTrans(context, executeWithDeviceInformation)(sendUpdateValue);	1✔
264	exports.query = intoTrans(context, executeWithDeviceInformation)(sendQueryValue);	1✔
265	exports.addUpdateMiddleware = intoTrans(context, addUpdateMiddleware);	1✔
266	exports.addQueryMiddleware = intoTrans(context, addQueryMiddleware);	1✔
267	exports.resetMiddlewares = intoTrans(context, resetMiddlewares);	1✔
268	exports.setCommandResult = intoTrans(context, setCommandResult);	1✔
269	exports.updateTrust = updateTrust;	1✔
270	exports.init = init;	1✔

telefonicaid / iotagent-node-lib / 11915483619

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