src/sensor/gnunet-service-sensor_analysis.c

   1 /*
   2      This file is part of GNUnet.
   3      (C)
   4
   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.
   9
  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.
  14
  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.
  19 */
  20
  21 /**
  22  * @file sensor/gnunet-service-sensor_analysis.c
  23  * @brief sensor service analysis functionality
  24  * @author Omar Tarabai
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "sensor.h"
  29 #include "gnunet_peerstore_service.h"
  30 #include "gnunet_sensor_model_plugin.h"
  31
  32 #define LOG(kind,...) GNUNET_log_from (kind, "sensor-analysis",__VA_ARGS__)
  33
  34 /**
  35  * Carries information about the analysis model
  36  * corresponding to one sensor
  37  */
  38 struct SensorModel
  39 {
  40
  41   /**
  42    * DLL
  43    */
  44   struct SensorModel *prev;
  45
  46   /**
  47    * DLL
  48    */
  49   struct SensorModel *next;
  50
  51   /**
  52    * Pointer to sensor info structure
  53    */
  54   struct GNUNET_SENSOR_SensorInfo *sensor;
  55
  56   /**
  57    * Watcher of sensor values
  58    */
  59   struct GNUNET_PEERSTORE_WatchContext *wc;
  60
  61   /**
  62    * State of sensor. #GNUNET_YES if anomalous, #GNUNET_NO otherwise.
  63    */
  64   int anomalous;
  65
  66   /**
  67    * Number of anomalous readings (positive) received in a row.
  68    */
  69   int positive_count;
  70
  71   /**
  72    * Number of non-anomalous (negative) readings received in a row.
  73    */
  74   int negative_count;
  75
  76   /**
  77    * Closure for model plugin.
  78    * Usually, the instance of the model created for this sensor.
  79    */
  80   void *cls;
  81
  82 };
  83
  84 /**
  85  * Our configuration.
  86  */
  87 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  88
  89 /**
  90  * Hashmap of loaded sensors
  91  */
  92 struct GNUNET_CONTAINER_MultiHashMap *sensors;
  93
  94 /*
  95  * Model library name
  96  */
  97 static char *model_lib_name;
  98
  99 /**
 100  * Model handle
 101  */
 102 static struct GNUNET_SENSOR_ModelFunctions *model_api;
 103
 104 /**
 105  * Handle to peerstore service
 106  */
 107 static struct GNUNET_PEERSTORE_Handle *peerstore;
 108
 109 /**
 110  * Head of DLL of created models
 111  */
 112 static struct SensorModel *models_head;
 113
 114 /**
 115  * Tail of DLL of created models
 116  */
 117 static struct SensorModel *models_tail;
 118
 119 /**
 120  * My peer id
 121  */
 122 struct GNUNET_PeerIdentity peerid;
 123
 124 /**
 125  * How many subsequent values required to flip anomaly label.
 126  * E.g. After 3 subsequent anomaly reports, status change to anomalous.
 127  */
 128 unsigned long long confirmation_count;
 129
 130 /**
 131  * Destroy a created model
 132  */
 133 static void
 134 destroy_sensor_model (struct SensorModel *sensor_model)
 135 {
 136   GNUNET_assert (NULL != sensor_model);
 137   LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying sensor model for `%s'.\n",
 138        sensor_model->sensor->name);
 139   if (NULL != sensor_model->wc)
 140   {
 141     GNUNET_PEERSTORE_watch_cancel (sensor_model->wc);
 142     sensor_model->wc = NULL;
 143   }
 144   if (NULL != sensor_model->cls)
 145   {
 146     model_api->destroy_model (sensor_model->cls);
 147     sensor_model->cls = NULL;
 148   }
 149   GNUNET_free (sensor_model);
 150   sensor_model = NULL;
 151 }
 152
 153
 154 /**
 155  * Stop the sensor analysis module
 156  */
 157 void
 158 SENSOR_analysis_stop ()
 159 {
 160   struct SensorModel *sm;
 161
 162   LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping sensor analysis module.\n");
 163   while (NULL != models_head)
 164   {
 165     sm = models_head;
 166     GNUNET_CONTAINER_DLL_remove (models_head, models_tail, sm);
 167     destroy_sensor_model (sm);
 168   }
 169   if (NULL != peerstore)
 170   {
 171     GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_YES);
 172     peerstore = NULL;
 173   }
 174   if (NULL != model_api)
 175   {
 176     GNUNET_break (NULL == GNUNET_PLUGIN_unload (model_lib_name, model_api));
 177     GNUNET_free (model_lib_name);
 178     model_lib_name = NULL;
 179   }
 180 }
 181
 182
 183 /**
 184  * Sensor value watch callback
 185  *
 186  * @param cls Sensor model struct
 187  * @param record Received record from peerstore, should contain new sensor value
 188  * @param emsg Error message from peerstore if any, NULL if no errors
 189  * @return #GNUNET_YES
 190  */
 191 static int
 192 sensor_watcher (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
 193 {
 194   struct SensorModel *model = cls;
 195   double *val;
 196   int anomalous;
 197
 198   LOG (GNUNET_ERROR_TYPE_DEBUG,
 199        "Received a sensor value, will feed to sensor model.\n");
 200   if (sizeof (double) != record->value_size)
 201   {
 202     LOG (GNUNET_ERROR_TYPE_ERROR, _("Received an invalid sensor value."));
 203     return GNUNET_YES;
 204   }
 205   val = (double *) (record->value);
 206   anomalous = model_api->feed_model (model->cls, *val);
 207   if (GNUNET_YES == anomalous)
 208   {
 209     model->positive_count++;
 210     model->negative_count = 0;
 211     if (GNUNET_NO == model->anomalous &&
 212         model->positive_count >= confirmation_count)
 213     {
 214       model->anomalous = GNUNET_YES;
 215       LOG (GNUNET_ERROR_TYPE_WARNING,
 216            "Anomaly state started for sensor `%s'.\n", model->sensor->name);
 217       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 218     }
 219   }
 220   else
 221   {
 222     model->negative_count++;
 223     model->positive_count = 0;
 224     if (GNUNET_YES == model->anomalous &&
 225         model->negative_count >= confirmation_count)
 226     {
 227       model->anomalous = GNUNET_NO;
 228       LOG (GNUNET_ERROR_TYPE_INFO, "Anomaly state stopped for sensor `%s'.\n",
 229            model->sensor->name);
 230       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 231     }
 232   }
 233   return GNUNET_YES;
 234 }
 235
 236
 237 /**
 238  * Iterator for defined sensors
 239  * Creates sensor model for numeric sensors
 240  *
 241  * @param cls unused
 242  * @param key unused
 243  * @param value a 'struct GNUNET_SENSOR_SensorInfo *' with sensor information
 244  * @return #GNUNET_YES to continue iterations
 245  */
 246 static int
 247 init_sensor_model (void *cls, const struct GNUNET_HashCode *key, void *value)
 248 {
 249   struct GNUNET_SENSOR_SensorInfo *sensor = value;
 250   struct SensorModel *sensor_model;
 251
 252   if (0 != strcmp ("numeric", sensor->expected_datatype))
 253     return GNUNET_YES;
 254   sensor_model = GNUNET_new (struct SensorModel);
 255   sensor_model->sensor = sensor;
 256   sensor_model->wc =
 257       GNUNET_PEERSTORE_watch (peerstore, "sensor", &peerid, sensor->name,
 258                               &sensor_watcher, sensor_model);
 259   sensor_model->anomalous = GNUNET_NO;
 260   sensor_model->positive_count = 0;
 261   sensor_model->negative_count = 0;
 262   sensor_model->cls = model_api->create_model (model_api->cls);
 263   GNUNET_CONTAINER_DLL_insert (models_head, models_tail, sensor_model);
 264   LOG (GNUNET_ERROR_TYPE_DEBUG, "Created sensor model for `%s'.\n",
 265        sensor->name);
 266   return GNUNET_YES;
 267 }
 268
 269
 270 /**
 271  * Start the sensor analysis module
 272  *
 273  * @param c our service configuration
 274  * @param sensors multihashmap of loaded sensors
 275  * @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
 276  */
 277 int
 278 SENSOR_analysis_start (const struct GNUNET_CONFIGURATION_Handle *c,
 279                        struct GNUNET_CONTAINER_MultiHashMap *s)
 280 {
 281   char *model_name;
 282
 283   GNUNET_assert (NULL != s);
 284   cfg = c;
 285   sensors = s;
 286   if (GNUNET_OK !=
 287       GNUNET_CONFIGURATION_get_value_string (cfg, "sensor-analysis", "MODEL",
 288                                              &model_name))
 289   {
 290     LOG (GNUNET_ERROR_TYPE_ERROR,
 291          _("Analysis model not defined in configuration.\n"));
 292     return GNUNET_SYSERR;
 293   }
 294   GNUNET_asprintf (&model_lib_name, "libgnunet_plugin_sensor_model_%s",
 295                    model_name);
 296   model_api = GNUNET_PLUGIN_load (model_lib_name, (void *) cfg);
 297   GNUNET_free (model_name);
 298   if (NULL == model_api)
 299   {
 300     LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not load analysis model `%s'.\n"),
 301          model_lib_name);
 302     return GNUNET_SYSERR;
 303   }
 304   peerstore = GNUNET_PEERSTORE_connect (cfg);
 305   if (NULL == peerstore)
 306   {
 307     LOG (GNUNET_ERROR_TYPE_ERROR,
 308          _("Could not connect to peerstore service.\n"));
 309     SENSOR_analysis_stop ();
 310     return GNUNET_SYSERR;
 311   }
 312   if (GNUNET_OK !=
 313       GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-analysis",
 314                                              "CONFIRMATION_COUNT",
 315                                              &confirmation_count))
 316     confirmation_count = 1;
 317   GNUNET_CRYPTO_get_peer_identity (cfg, &peerid);
 318   GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_model, NULL);
 319   return GNUNET_OK;
 320 }
 321
 322 /* end of gnunet-service-sensor_analysis.c */