From e68aa2bf46213e33bf1bc07a335df8aeb5ac01c3 Mon Sep 17 00:00:00 2001 From: Omar Tarabai Date: Thu, 3 Jul 2014 14:06:02 +0000 Subject: moved common sensor functionality to a util lib --- src/sensor/sensor_util_lib.c | 424 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 424 insertions(+) create mode 100644 src/sensor/sensor_util_lib.c (limited to 'src/sensor/sensor_util_lib.c') diff --git a/src/sensor/sensor_util_lib.c b/src/sensor/sensor_util_lib.c new file mode 100644 index 000000000..90befe6af --- /dev/null +++ b/src/sensor/sensor_util_lib.c @@ -0,0 +1,424 @@ +/* + This file is part of GNUnet. + (C) + + GNUnet is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3, or (at your + option) any later version. + + GNUnet 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 + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNUnet; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +/** + * @file sensor/sensor_util_lib.c + * @brief senor utilities + * @author Omar Tarabai + */ +#include +#include "platform.h" +#include "gnunet_util_lib.h" +#include "gnunet_sensor_util_lib.h" + +#define LOG(kind,...) GNUNET_log_from (kind, "sensor-util",__VA_ARGS__) + +/** + * Minimum sensor execution interval (in seconds) + */ +#define MIN_INTERVAL 30 + +/** + * Supported sources of sensor information + */ +static const char *sources[] = { "gnunet-statistics", "process", NULL }; + +/** + * Supported datatypes of sensor information + */ +static const char *datatypes[] = { "numeric", "string", NULL }; + +/** + * Parses a version number string into major and minor + * + * @param version full version string + * @param major pointer to parsed major value + * @param minor pointer to parsed minor value + * @return #GNUNET_OK if parsing went ok, #GNUNET_SYSERROR in case of error + */ +static int +version_parse(char *version, uint16_t *major, uint16_t *minor) +{ + int majorval = 0; + int minorval = 0; + + for(; isdigit(*version); version++) + { + majorval *= 10; + majorval += *version - '0'; + } + if(*version != '.') + return GNUNET_SYSERR; + version++; + for(; isdigit(*version); version++) + { + minorval *= 10; + minorval += *version - '0'; + } + if(*version != 0) + return GNUNET_SYSERR; + *major = majorval; + *minor = minorval; + + return GNUNET_OK; +} + +/** + * Load sensor definition from configuration + * + * @param cfg configuration handle + * @param sectionname configuration section containing definition + */ +static struct SensorInfo * +load_sensor_from_cfg(struct GNUNET_CONFIGURATION_Handle *cfg, const char *sectionname) +{ + struct SensorInfo *sensor; + char *version_str; + char *starttime_str; + char *endtime_str; + unsigned long long time_sec; + char *dummy; + struct GNUNET_CRYPTO_EddsaPublicKey public_key; + + sensor = GNUNET_new(struct SensorInfo); + //name + sensor->name = GNUNET_strdup(sectionname); + //version + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "VERSION", &version_str)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor version\n")); + GNUNET_free(sensor); + return NULL; + } + if(GNUNET_OK != version_parse(version_str, &(sensor->version_major), &(sensor->version_minor))) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid sensor version number, format should be major.minor\n")); + GNUNET_free(sensor); + GNUNET_free(version_str); + return NULL; + } + GNUNET_free(version_str); + //description + GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "DESCRIPTION", &sensor->description); + //category + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "CATEGORY", &sensor->category) || + NULL == sensor->category) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor category\n")); + GNUNET_free(sensor); + return NULL; + } + //enabled + if(GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname, "ENABLED")) + sensor->enabled = GNUNET_NO; + else + sensor->enabled = GNUNET_YES; + //start time + sensor->start_time = NULL; + if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "START_TIME", &starttime_str)) + { + GNUNET_STRINGS_fancy_time_to_absolute(starttime_str, sensor->start_time); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Start time loaded: `%s'. Parsed: %d\n", starttime_str, (NULL != sensor->start_time)); + GNUNET_free(starttime_str); + } + //end time + sensor->end_time = NULL; + if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "END_TIME", &endtime_str)) + { + GNUNET_STRINGS_fancy_time_to_absolute(endtime_str, sensor->end_time); + LOG (GNUNET_ERROR_TYPE_DEBUG, "End time loaded: `%s'. Parsed: %d\n", endtime_str, (NULL != sensor->end_time)); + GNUNET_free(endtime_str); + } + //interval + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "INTERVAL", &time_sec)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor run interval\n")); + GNUNET_free(sensor); + return NULL; + } + if(time_sec < MIN_INTERVAL) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Sensor run interval too low (%" PRIu64 " < %d)\n"), + time_sec, MIN_INTERVAL); + GNUNET_free(sensor); + return NULL; + } + sensor->interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec); + //lifetime + if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "LIFETIME", &time_sec)) + { + sensor->lifetime = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec); + if (sensor->lifetime.rel_value_us < sensor->interval.rel_value_us) + LOG (GNUNET_ERROR_TYPE_WARNING, + "Lifetime of sensor data is preferred to be higher than interval for sensor `%s'.\n", + sensor->name); + } + else + sensor->lifetime = sensor->interval; + //capabilities TODO + //source + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "SOURCE", sources, (const char **)&sensor->source)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor source\n")); + GNUNET_free(sensor); + return NULL; + } + if(sources[0] == sensor->source) //gnunet-statistics + { + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_SERVICE", &sensor->gnunet_stat_service) || + GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_NAME", &sensor->gnunet_stat_name)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor gnunet-statistics source information\n")); + GNUNET_free(sensor); + return NULL; + } + sensor->gnunet_stat_get_handle = NULL; + } + else if(sources[1] == sensor->source) //process + { + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_PROCESS", &sensor->ext_process)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor process name\n")); + GNUNET_free(sensor); + return NULL; + } + GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_ARGS", &sensor->ext_args); + } + //expected datatype + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "EXPECTED_DATATYPE", datatypes, (const char **)&sensor->expected_datatype)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor expected datatype\n")); + GNUNET_free(sensor); + return NULL; + } + if(sources[0] == sensor->source && datatypes[0] != sensor->expected_datatype) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid expected datatype, gnunet-statistics returns uint64 values\n")); + GNUNET_free(sensor); + return NULL; + } + //reporting mechanism + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "COLLECTION_POINT", &dummy)) + { + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "COLLECTION_INTERVAL", &time_sec)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor collection interval\n")); + } + else + { + sensor->collection_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec); + if (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string(dummy, strlen(dummy), &public_key)) + { + sensor->collection_point = GNUNET_new(struct GNUNET_PeerIdentity); + sensor->collection_point->public_key = public_key; + } + } + } + sensor->p2p_report = GNUNET_NO; + if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname, "P2P_REPORT")) + { + if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "P2P_INTERVAL", &time_sec)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor p2p reporting interval\n")); + } + else + { + sensor->p2p_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec); + sensor->p2p_report = GNUNET_YES; + } + } + //execution task + sensor->execution_task = GNUNET_SCHEDULER_NO_TASK; + //running + sensor->running = GNUNET_NO; + + return sensor; +} + +/** + * Load sensor definition from file + * + * @param filename full path to file containing sensor definition + */ +static struct SensorInfo * +load_sensor_from_file(const char *filename) +{ + struct GNUNET_CONFIGURATION_Handle *sensorcfg; + const char *filebasename; + struct SensorInfo *sensor; + + //test file + if(GNUNET_YES != GNUNET_DISK_file_test(filename)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to access sensor file: %s\n"), filename); + return NULL; + } + //load file as configuration + sensorcfg = GNUNET_CONFIGURATION_create(); + if(GNUNET_SYSERR == GNUNET_CONFIGURATION_parse(sensorcfg, filename)) + { + GNUNET_CONFIGURATION_destroy(sensorcfg); + LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to load sensor definition: %s\n"), filename); + return NULL; + } + //configuration section should be the same as filename + filebasename = GNUNET_STRINGS_get_short_name(filename); + sensor = load_sensor_from_cfg(sensorcfg, filebasename); + if(NULL == sensor) + { + GNUNET_CONFIGURATION_destroy(sensorcfg); + return NULL; + } + sensor->def_file = GNUNET_strdup(filename); + sensor->cfg = sensorcfg; + + return sensor; +} + +/** + * Compares version numbers of two sensors + * + * @param s1 first sensor + * @param s2 second sensor + * @return 1: s1 > s2, 0: s1 == s2, -1: s1 < s2 + */ +static int +sensor_version_compare(struct SensorInfo *s1, struct SensorInfo *s2) +{ + if(s1->version_major == s2->version_major) + return (s1->version_minor < s2->version_minor) ? -1 : (s1->version_minor > s2->version_minor); + else + return (s1->version_major < s2->version_major) ? -1 : (s1->version_major > s2->version_major); +} + +/** + * Adds a new sensor to given hashmap. + * If the same name exist, compares versions and update if old. + * + * @param sensor Sensor structure to add + * @param map Hashmap to add to + * @return #GNUNET_YES if added, #GNUNET_NO if not added which is not necessarily an error + */ +static int +add_sensor_to_hashmap(struct SensorInfo *sensor, struct GNUNET_CONTAINER_MultiHashMap *map) +{ + struct GNUNET_HashCode key; + struct SensorInfo *existing; + + GNUNET_CRYPTO_hash(sensor->name, strlen(sensor->name), &key); + existing = GNUNET_CONTAINER_multihashmap_get(map, &key); + if(NULL != existing) //sensor with same name already exists + { + if(sensor_version_compare(existing, sensor) >= 0) //same or newer version already exist + { + LOG (GNUNET_ERROR_TYPE_INFO, _("Sensor `%s' already exists with same or newer version\n"), sensor->name); + return GNUNET_NO; + } + else + { + GNUNET_CONTAINER_multihashmap_remove(map, &key, existing); //remove the old version + GNUNET_free(existing); + LOG (GNUNET_ERROR_TYPE_INFO, "Upgrading sensor `%s' to a newer version\n", sensor->name); + } + } + if(GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put(map, &key, sensor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) + { + LOG (GNUNET_ERROR_TYPE_ERROR, _("Error adding new sensor `%s' to global hashmap, this should not happen\n"), sensor->name); + return GNUNET_NO; + } + + return GNUNET_YES; +} + +/** + * Iterating over files in sensors directory + * + * @param cls closure + * @param filename complete filename (absolute path) + * @return #GNUNET_OK to continue to iterate + */ +static int +reload_sensors_dir_cb(void *cls, const char *filename) +{ + struct GNUNET_CONTAINER_MultiHashMap *sensors = cls; + struct SensorInfo *sensor; + + if(GNUNET_YES != GNUNET_DISK_file_test(filename)) + return GNUNET_OK; + sensor = load_sensor_from_file(filename); + if(NULL == sensor) + { + LOG (GNUNET_ERROR_TYPE_ERROR, + _("Error loading sensor from file: %s\n"), filename); + return GNUNET_OK; + } + if(GNUNET_YES == add_sensor_to_hashmap(sensor, sensors)) + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Sensor `%s' added to global hashmap\n", sensor->name); + else + LOG (GNUNET_ERROR_TYPE_WARNING, + "Could not add sensor `%s' to global hashmap\n", sensor->name); + + return GNUNET_OK; +} + +/* + * Get path to the directory containing the sensor definition files + * + * @return sensor files directory + */ +char * +GNUNET_SENSOR_get_sensor_dir () +{ + char* datadir; + char* sensordir; + + datadir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR); + GNUNET_asprintf(&sensordir, "%ssensors%s", + datadir, DIR_SEPARATOR_STR); + GNUNET_free(datadir); + + return sensordir; +} + +/** + * Reads sensor definitions from local data files + * + * @return a multihashmap of loaded sensors + */ +struct GNUNET_CONTAINER_MultiHashMap * +GNUNET_SENSOR_load_all_sensors () +{ + char* sensordir; + struct GNUNET_CONTAINER_MultiHashMap *sensors; + + sensors = GNUNET_CONTAINER_multihashmap_create(10, GNUNET_NO); + sensordir = GNUNET_SENSOR_get_sensor_dir (); + LOG (GNUNET_ERROR_TYPE_INFO, + "Loading sensor definitions from directory `%s'\n", sensordir); + GNUNET_assert(GNUNET_YES == GNUNET_DISK_directory_test(sensordir, GNUNET_YES)); + + //read all files in sensors directory + GNUNET_DISK_directory_scan(sensordir, &reload_sensors_dir_cb, sensors); + LOG (GNUNET_ERROR_TYPE_INFO, "Loaded %d sensors from directory `%s'\n", + GNUNET_CONTAINER_multihashmap_size(sensors), sensordir); + GNUNET_free(sensordir); + return sensors; +} -- cgit v1.2.3