2 This file is part of GNUnet.
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file sensor/gnunet-service-sensor.c
23 * @brief sensor service implementation
24 * @author Omar Tarabai
28 #include "gnunet_util_lib.h"
32 * Minimum sensor execution interval (in seconds)
34 #define MIN_INTERVAL 30
37 * Structure containing sensor definition
48 * Path to definition file
53 * First part of version number
55 uint16_t version_major;
58 * Second part of version number
60 uint16_t version_minor;
68 * Sensor currently enabled
73 * Category under which the sensor falls (e.g. tcp, datastore)
78 * When does the sensor become active
80 struct GNUNET_TIME_Absolute *start_time;
83 * When does the sensor expire
85 struct GNUNET_TIME_Absolute *end_time;
88 * Time interval to collect sensor information (e.g. every 1 min)
90 struct GNUNET_TIME_Relative interval;
93 * Lifetime of an information sample after which it is deleted from storage
95 struct GNUNET_TIME_Relative lifetime;
98 * A set of required peer capabilities for the sensor to collect meaningful information (e.g. ipv6)
103 * Either "gnunet-statistics" or external "process"
108 * Name of the GNUnet service that is the source for the gnunet-statistics entry
110 char *gnunet_stat_service;
113 * Name of the gnunet-statistics entry
115 char *gnunet_stat_name;
118 * Handle to statistics get request (OR GNUNET_SCHEDULER_NO_TASK)
120 struct GNUNET_STATISTICS_GetHandle *gnunet_stat_get_handle;
123 * Name of the external process to be executed
128 * Arguments to be passed to the external process
133 * The output datatype to be expected
135 char *expected_datatype;
138 * Peer-identity of peer running collection point
140 struct GNUNET_PeerIdentity *collection_point;
143 * Time interval to send sensor information to collection point (e.g. every 30 mins)
145 struct GNUNET_TIME_Relative *collection_interval;
148 * Flag specifying if value is to be communicated to the p2p network
153 * Time interval to communicate value to the p2p network
155 struct GNUNET_TIME_Relative *p2p_interval;
158 * Execution task (OR GNUNET_SCHEDULER_NO_TASK)
160 GNUNET_SCHEDULER_TaskIdentifier execution_task;
163 * Is the sensor being executed
172 static const struct GNUNET_CONFIGURATION_Handle *cfg;
175 * Hashmap of loaded sensor definitions
177 struct GNUNET_CONTAINER_MultiHashMap *sensors;
180 * Supported sources of sensor information
182 static const char *sources[] = { "gnunet-statistics", "process", NULL };
185 * Supported datatypes of sensor information
187 static const char *datatypes[] = { "uint64", "double", "string", NULL };
190 * Handle to statistics service
192 struct GNUNET_STATISTICS_Handle *statistics;
194 //TODO: logging macro that includes sensor info
197 * Remove sensor execution from scheduler
200 * @param key hash of sensor name, key to hashmap
201 * @param value a 'struct SensorInfo *'
202 * @return #GNUNET_YES if we should continue to
206 int unschedule_sensor(void *cls,
207 const struct GNUNET_HashCode *key, void *value)
209 struct SensorInfo *sensorinfo = value;
211 if(NULL != sensorinfo->gnunet_stat_get_handle)
213 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Canceling a statistics get request for sensor `%s'\n", sensorinfo->name);
214 GNUNET_STATISTICS_get_cancel(sensorinfo->gnunet_stat_get_handle);
216 if(GNUNET_SCHEDULER_NO_TASK != sensorinfo->execution_task)
218 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unscheduling sensor `%s'\n", sensorinfo->name);
219 GNUNET_SCHEDULER_cancel(sensorinfo->execution_task);
225 * Task run during shutdown.
231 shutdown_task (void *cls,
232 const struct GNUNET_SCHEDULER_TaskContext *tc)
234 GNUNET_CONTAINER_multihashmap_iterate(sensors, &unschedule_sensor, NULL);
235 if(NULL != statistics)
236 GNUNET_STATISTICS_destroy(statistics, GNUNET_YES);
237 GNUNET_SCHEDULER_shutdown();
242 * A client disconnected. Remove all of its data structure entries.
244 * @param cls closure, NULL
245 * @param client identification of the client
248 handle_client_disconnect (void *cls,
249 struct GNUNET_SERVER_Client
255 * Parses a version number string into major and minor
257 * @param version full version string
258 * @param major pointer to parsed major value
259 * @param minor pointer to parsed minor value
260 * @return #GNUNET_OK if parsing went ok, #GNUNET_SYSERROR in case of error
263 version_parse(char *version, uint16_t *major, uint16_t *minor)
268 for(; isdigit(*version); version++)
271 majorval += *version - '0';
274 return GNUNET_SYSERR;
276 for(; isdigit(*version); version++)
279 minorval += *version - '0';
282 return GNUNET_SYSERR;
290 * Load sensor definition from configuration
292 * @param cfg configuration handle
293 * @param sectionname configuration section containing definition
295 static struct SensorInfo *
296 load_sensor_from_cfg(struct GNUNET_CONFIGURATION_Handle *cfg, const char *sectionname)
298 struct SensorInfo *sensor;
302 unsigned long long time_sec;
304 sensor = GNUNET_new(struct SensorInfo);
306 sensor->name = GNUNET_strdup(sectionname);
308 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "VERSION", &version_str))
310 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor version\n"));
314 if(GNUNET_OK != version_parse(version_str, &(sensor->version_major), &(sensor->version_minor)))
316 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Invalid sensor version number, format should be major.minor\n"));
318 GNUNET_free(version_str);
321 GNUNET_free(version_str);
323 GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "DESCRIPTION", &sensor->description);
325 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "CATEGORY", &sensor->category) ||
326 NULL == sensor->category)
328 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor category\n"));
333 if(GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname, "ENABLED"))
334 sensor->enabled = GNUNET_NO;
336 sensor->enabled = GNUNET_YES;
338 sensor->start_time = NULL;
339 if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "START_TIME", &starttime_str))
341 GNUNET_STRINGS_fancy_time_to_absolute(starttime_str, sensor->start_time);
342 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Start time loaded: `%s'. Parsed: %d\n", starttime_str, (NULL != sensor->start_time));
343 GNUNET_free(starttime_str);
346 sensor->end_time = NULL;
347 if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "END_TIME", &endtime_str))
349 GNUNET_STRINGS_fancy_time_to_absolute(endtime_str, sensor->end_time);
350 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "End time loaded: `%s'. Parsed: %d\n", endtime_str, (NULL != sensor->end_time));
351 GNUNET_free(endtime_str);
354 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "INTERVAL", &time_sec))
356 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor run interval\n"));
360 if(time_sec < MIN_INTERVAL)
362 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Sensor run interval too low (%" PRIu64 " < %d)\n"),
363 time_sec, MIN_INTERVAL);
367 sensor->interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
368 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Interval loaded: %" PRIu64 "\n", sensor->interval.rel_value_us);
370 if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "LIFETIME", &time_sec))
372 sensor->lifetime = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
373 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Lifetime loaded: %" PRIu64 "\n", sensor->lifetime.rel_value_us);
376 sensor->lifetime = GNUNET_TIME_UNIT_FOREVER_REL;
379 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "SOURCE", sources, &sensor->source))
381 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor source\n"));
385 if(sources[0] == sensor->source) //gnunet-statistics
387 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_SERVICE", &sensor->gnunet_stat_service) ||
388 GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_NAME", &sensor->gnunet_stat_name))
390 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor gnunet-statistics source information\n"));
394 sensor->gnunet_stat_get_handle = NULL;
396 else if(sources[1] == sensor->source) //process
398 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_PROCESS", &sensor->ext_process))
400 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor process name\n"));
404 GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_ARGS", &sensor->ext_args);
407 if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "EXPECTED_DATATYPE", datatypes, &sensor->expected_datatype))
409 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor expected datatype\n"));
413 if(sources[0] == sensor->source && datatypes[0] != sensor->expected_datatype)
415 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Invalid expected datatype, gnunet-statistics returns uint64 values\n"));
419 //TODO: reporting mechanism
421 sensor->execution_task = GNUNET_SCHEDULER_NO_TASK;
423 sensor->running = GNUNET_NO;
429 * Load sensor definition from file
431 * @param filename full path to file containing sensor definition
433 static struct SensorInfo *
434 load_sensor_from_file(const char *filename)
436 struct GNUNET_CONFIGURATION_Handle *sensorcfg;
437 const char *filebasename;
438 struct SensorInfo *sensor;
441 if(GNUNET_YES != GNUNET_DISK_file_test(filename))
443 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Failed to access sensor file: %s\n"), filename);
446 //load file as configuration
447 sensorcfg = GNUNET_CONFIGURATION_create();
448 if(GNUNET_SYSERR == GNUNET_CONFIGURATION_parse(sensorcfg, filename))
450 GNUNET_CONFIGURATION_destroy(sensorcfg);
451 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Failed to load sensor definition: %s\n"), filename);
454 //configuration section should be the same as filename
455 filebasename = GNUNET_STRINGS_get_short_name(filename);
456 sensor = load_sensor_from_cfg(sensorcfg, filebasename);
457 sensor->def_file = GNUNET_strdup(filename);
459 GNUNET_CONFIGURATION_destroy(sensorcfg);
465 * Compares version numbers of two sensors
467 * @param s1 first sensor
468 * @param s2 second sensor
469 * @return 1: s1 > s2, 0: s1 == s2, -1: s1 < s2
472 sensor_version_compare(struct SensorInfo *s1, struct SensorInfo *s2)
474 if(s1->version_major == s2->version_major)
475 return (s1->version_minor < s2->version_minor) ? -1 : (s1->version_minor > s2->version_minor);
477 return (s1->version_major < s2->version_major) ? -1 : (s1->version_major > s2->version_major);
481 * Adds a new sensor to given hashmap.
482 * If the same name exist, compares versions and update if old.
484 * @param sensor Sensor structure to add
485 * @param map Hashmap to add to
486 * @return #GNUNET_YES if added, #GNUNET_NO if not added which is not necessarily an error
489 add_sensor_to_hashmap(struct SensorInfo *sensor, struct GNUNET_CONTAINER_MultiHashMap *map)
491 struct GNUNET_HashCode key;
492 struct SensorInfo *existing;
494 GNUNET_CRYPTO_hash(sensor->name, strlen(sensor->name), &key);
495 existing = GNUNET_CONTAINER_multihashmap_get(map, &key);
496 if(NULL != existing) //sensor with same name already exists
498 if(sensor_version_compare(existing, sensor) >= 0) //same or newer version already exist
500 GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Sensor `%s' already exists with same or newer version\n"), sensor->name);
505 GNUNET_CONTAINER_multihashmap_remove(map, &key, existing); //remove the old version
506 GNUNET_free(existing);
507 GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Upgrading sensor `%s' to a newer version\n"), sensor->name);
510 if(GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put(map, &key, sensor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
512 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error adding new sensor `%s' to global hashmap, this should not happen\n"), sensor->name);
520 * Iterating over files in sensors directory
523 * @param filename complete filename (absolute path)
524 * @return #GNUNET_OK to continue to iterate,
525 * #GNUNET_NO to stop iteration with no error,
526 * #GNUNET_SYSERR to abort iteration with error!
529 reload_sensors_dir_cb(void *cls, const char *filename)
531 struct SensorInfo *sensor;
533 sensor = load_sensor_from_file(filename);
536 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Error loading sensor from file: %s\n"), filename);
539 if(GNUNET_YES == add_sensor_to_hashmap(sensor, sensors))
540 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, _("Sensor `%s' added to global hashmap\n"), sensor->name);
542 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, ("Could not add sensor `%s' to global hashmap\n"), sensor->name);
548 * Get path to the directory containing the sensor definition files
550 * @return sensor files directory
558 datadir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
559 GNUNET_asprintf(&sensordir, "%ssensors%s",
560 datadir, DIR_SEPARATOR_STR);
566 * Reads sensor definitions from data files
575 sensordir = get_sensor_dir();
576 GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Reloading sensor definitions from directory `%s'\n"), sensordir);
577 GNUNET_assert(GNUNET_YES == GNUNET_DISK_directory_test(sensordir, GNUNET_YES));
579 //read all files in sensors directory
580 filesfound = GNUNET_DISK_directory_scan(sensordir, &reload_sensors_dir_cb, NULL);
581 GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Loaded %d/%d sensors from directory `%s'\n"),
582 GNUNET_CONTAINER_multihashmap_size(sensors), filesfound, sensordir);
586 * Creates a structure with basic sensor info to be sent to a client
588 * @param sensor sensor information
589 * @return message ready to be sent to client
591 static struct SensorInfoMessage *
592 create_sensor_info_msg(struct SensorInfo *sensor)
594 struct SensorInfoMessage *msg;
600 name_len = strlen(sensor->name);
601 if(NULL == sensor->description)
604 desc_len = strlen(sensor->description);
606 len += sizeof(struct SensorInfoMessage);
609 msg = GNUNET_malloc(len);
610 msg->header.size = htons(len);
611 msg->header.type = htons(GNUNET_MESSAGE_TYPE_SENSOR_INFO);
612 msg->name_len = htons(name_len);
613 msg->description_len = htons(desc_len);
614 msg->version_major = htons(sensor->version_major);
615 msg->version_minor = htons(sensor->version_minor);
616 str_ptr = (char*) &msg[1];
617 memcpy(str_ptr, sensor->name, name_len);
618 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending sensor name (%d): %.*s\n",
619 name_len, name_len, str_ptr);
621 memcpy(str_ptr, sensor->description, desc_len);
622 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending sensor description (%d): %.*s\n",
623 desc_len, desc_len, str_ptr);
629 * Handle GET SENSOR message.
632 * @param client identification of the client
633 * @param message the actual message
636 handle_get_sensor (void *cls, struct GNUNET_SERVER_Client *client,
637 const struct GNUNET_MessageHeader *message)
639 struct GNUNET_SERVER_TransmitContext *tc;
641 size_t sensorname_len;
642 struct GNUNET_HashCode key;
643 struct SensorInfo *sensorinfo;
644 struct SensorInfoMessage *msg;
646 sensorname = (char *)&message[1];
647 sensorname_len = ntohs(message->size) - sizeof(struct GNUNET_MessageHeader);
648 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "`%s' message received for sensor (%d) `%.*s'\n",
649 "GET SENSOR", sensorname_len, sensorname_len, sensorname);
650 tc = GNUNET_SERVER_transmit_context_create (client);
651 GNUNET_CRYPTO_hash(sensorname, sensorname_len, &key);
652 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created key hash for requested sensor\n");
653 sensorinfo = (struct SensorInfo *)GNUNET_CONTAINER_multihashmap_get(sensors, &key);
654 if(NULL != sensorinfo)
656 msg = create_sensor_info_msg(sensorinfo);
657 GNUNET_SERVER_transmit_context_append_message(tc, (struct GNUNET_MessageHeader *)msg);
661 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Requested sensor `%.*s' was not found\n",
662 sensorname_len, sensorname);
663 GNUNET_SERVER_transmit_context_append_data(tc, NULL, 0, GNUNET_MESSAGE_TYPE_SENSOR_END);
664 GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
668 * Iterator for sensors and adds them to transmit context
670 * @param cls a 'struct GNUNET_SERVER_TransmitContext *'
671 * @param key hash of sensor name, key to hashmap
672 * @param value a 'struct SensorInfo *'
674 int add_sensor_to_tc(void *cls,
675 const struct GNUNET_HashCode *key, void *value)
677 struct GNUNET_SERVER_TransmitContext *tc = cls;
678 struct SensorInfo *sensorinfo = value;
679 struct SensorInfoMessage *msg;
681 msg = create_sensor_info_msg(sensorinfo);
682 GNUNET_SERVER_transmit_context_append_message(tc, (struct GNUNET_MessageHeader *)msg);
690 * Handle GET ALL SENSORS message.
693 * @param client identification of the client
694 * @param message the actual message
697 handle_get_all_sensors (void *cls, struct GNUNET_SERVER_Client *client,
698 const struct GNUNET_MessageHeader *message)
700 struct GNUNET_SERVER_TransmitContext *tc;
702 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "`%s' message received.\n",
704 tc = GNUNET_SERVER_transmit_context_create (client);
705 GNUNET_CONTAINER_multihashmap_iterate(sensors, &add_sensor_to_tc, tc);
706 GNUNET_SERVER_transmit_context_append_data(tc, NULL, 0, GNUNET_MESSAGE_TYPE_SENSOR_END);
707 GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
711 * Do a series of checks to determine if sensor should execute
713 * @return #GNUNET_YES / #GNUNET_NO
716 should_run_sensor(struct SensorInfo *sensorinfo)
718 //FIXME: some checks should disable the sensor (e.g. expired)
719 struct GNUNET_TIME_Absolute now;
721 if(GNUNET_NO == sensorinfo->enabled)
723 GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Sensor `%s' is disabled, will not run\n", sensorinfo->name);
726 now = GNUNET_TIME_absolute_get();
727 if(NULL != sensorinfo->start_time
728 && now.abs_value_us < sensorinfo->start_time->abs_value_us)
730 GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Start time for sensor `%s' not reached yet, will not run\n", sensorinfo->name);
733 if(NULL != sensorinfo->end_time
734 && now.abs_value_us >= sensorinfo->end_time->abs_value_us)
736 GNUNET_log(GNUNET_ERROR_TYPE_INFO, "End time for sensor `%s' passed, will not run\n", sensorinfo->name);
743 * Callback function to process statistic values
745 * @param cls 'struct SensorInfo *'
746 * @param subsystem name of subsystem that created the statistic
747 * @param name the name of the datum
748 * @param value the current value
749 * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
750 * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
752 int sensor_statistics_iterator (void *cls,
753 const char *subsystem,
758 struct SensorInfo *sensorinfo = cls;
760 GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received a value for sensor `%s': %" PRIu64 "\n", sensorinfo->name, value);
765 * Continuation called after sensor gets all gnunet statistics values
767 * @param cls 'struct SensorInfo *'
768 * @param success #GNUNET_OK if statistics were
769 * successfully obtained, #GNUNET_SYSERR if not.
771 void end_sensor_run_stat (void *cls, int success)
773 struct SensorInfo *sensorinfo = cls;
775 sensorinfo->gnunet_stat_get_handle = NULL;
776 sensorinfo->running = GNUNET_NO;
780 * Actual execution of a sensor
782 * @param cls 'struct SensorInfo'
786 sensor_run (void *cls,
787 const struct GNUNET_SCHEDULER_TaskContext * tc)
789 struct SensorInfo *sensorinfo = cls;
792 sensorinfo->execution_task = GNUNET_SCHEDULER_add_delayed(sensorinfo->interval, &sensor_run, sensorinfo);
793 if(GNUNET_YES == sensorinfo->running) //FIXME: should we try to kill?
795 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sensor `%s' running for too long, will try again next interval\n", sensorinfo->name);
798 if(GNUNET_NO == should_run_sensor(sensorinfo))
800 sensorinfo->running = GNUNET_YES;
801 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting the execution of sensor `%s'\n", sensorinfo->name);
802 if(sources[0] == sensorinfo->source) //gnunet-statistics
804 if(NULL == statistics)
806 statistics = GNUNET_STATISTICS_create("sensor", cfg);
808 sensorinfo->gnunet_stat_get_handle = GNUNET_STATISTICS_get(statistics,
809 sensorinfo->gnunet_stat_service,
810 sensorinfo->gnunet_stat_name,
811 sensorinfo->interval, //try to get values only for the interval of the sensor
812 &end_sensor_run_stat,
813 &sensor_statistics_iterator,
816 else if(sources[1] == sensorinfo->source)
818 //check if the process exists in $PATH
820 GNUNET_OS_check_helper_binary(sensorinfo->ext_process, GNUNET_NO, NULL); //search in $PATH
821 if(GNUNET_SYSERR == check_result)
823 //search in sensor directory
826 if(GNUNET_SYSERR == check_result)
828 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sensor `%s' process `%s' problem: binary doesn't exist or not executable\n",
830 sensorinfo->ext_process);
831 //FIXME: disable sensor here?
832 sensorinfo->running = GNUNET_NO;
835 else if(GNUNET_NO == check_result)
839 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Process started for sensor `%s'\n", sensorinfo->name);
843 sensorinfo->running = GNUNET_NO;
844 GNUNET_break(0); //shouldn't happen
849 * Starts the execution of a sensor
852 * @param key hash of sensor name, key to hashmap (unused)
853 * @param value a 'struct SensorInfo *'
854 * @return #GNUNET_YES if we should continue to
858 int schedule_sensor(void *cls,
859 const struct GNUNET_HashCode *key, void *value)
861 struct SensorInfo *sensorinfo = value;
863 if(GNUNET_NO == should_run_sensor(sensorinfo))
865 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling sensor `%s' to run after %" PRIu64 " microseconds\n",
866 sensorinfo->name, sensorinfo->interval.rel_value_us);
867 if(GNUNET_SCHEDULER_NO_TASK != sensorinfo->execution_task)
869 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sensor `%s' execution task already set, this should not happen\n", sensorinfo->name);
872 sensorinfo->execution_task = GNUNET_SCHEDULER_add_delayed(sensorinfo->interval, &sensor_run, sensorinfo);
877 * Starts the execution of all enabled sensors
881 schedule_all_sensors()
883 GNUNET_CONTAINER_multihashmap_iterate(sensors, &schedule_sensor, NULL);
887 * Process statistics requests.
890 * @param server the initialized server
891 * @param c configuration to use
895 struct GNUNET_SERVER_Handle *server,
896 const struct GNUNET_CONFIGURATION_Handle *c)
898 static const struct GNUNET_SERVER_MessageHandler handlers[] = {
899 {&handle_get_sensor, NULL, GNUNET_MESSAGE_TYPE_SENSOR_GET,
901 {&handle_get_all_sensors, NULL, GNUNET_MESSAGE_TYPE_SENSOR_GETALL,
902 sizeof (struct GNUNET_MessageHeader)},
907 sensors = GNUNET_CONTAINER_multihashmap_create(10, GNUNET_NO);
909 schedule_all_sensors();
910 GNUNET_SERVER_add_handlers (server, handlers);
911 GNUNET_SERVER_disconnect_notify (server,
912 &handle_client_disconnect,
914 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
921 * The main function for the sensor service.
923 * @param argc number of arguments from the command line
924 * @param argv command line arguments
925 * @return 0 ok, 1 on error
928 main (int argc, char *const *argv)
931 GNUNET_SERVICE_run (argc,
934 GNUNET_SERVICE_OPTION_NONE,
935 &run, NULL)) ? 0 : 1;
938 /* end of gnunet-service-sensor.c */