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 static 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 static 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 static 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,
 193                 const struct GNUNET_PEERSTORE_Record *record,
 194                 const char *emsg)
 195 {
 196   struct SensorModel *model = cls;
 197   double *val;
 198   int anomalous;
 199
 200   LOG (GNUNET_ERROR_TYPE_DEBUG,
 201        "Received a sensor value, will feed to sensor model.\n");
 202   if (sizeof (double) != record->value_size)
 203   {
 204     LOG (GNUNET_ERROR_TYPE_ERROR, _("Received an invalid sensor value."));
 205     return GNUNET_YES;
 206   }
 207   val = (double *) (record->value);
 208   anomalous = model_api->feed_model (model->cls, *val);
 209   if (GNUNET_YES == anomalous)
 210   {
 211     model->positive_count++;
 212     model->negative_count = 0;
 213     if (GNUNET_NO == model->anomalous &&
 214         model->positive_count >= confirmation_count)
 215     {
 216       model->anomalous = GNUNET_YES;
 217       LOG (GNUNET_ERROR_TYPE_WARNING,
 218            "Anomaly state started for sensor `%s', value: %f.\n",
 219            model->sensor->name, val);
 220       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 221     }
 222   }
 223   else
 224   {
 225     model->negative_count++;
 226     model->positive_count = 0;
 227     if (GNUNET_YES == model->anomalous &&
 228         model->negative_count >= confirmation_count)
 229     {
 230       model->anomalous = GNUNET_NO;
 231       LOG (GNUNET_ERROR_TYPE_INFO,
 232           "Anomaly state stopped for sensor `%s', value: %f.\n",
 233            model->sensor->name, val);
 234       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 235     }
 236   }
 237   return GNUNET_YES;
 238 }
 239
 240
 241 /**
 242  * Iterator for defined sensors
 243  * Creates sensor model for numeric sensors
 244  *
 245  * @param cls unused
 246  * @param key unused
 247  * @param value a 'struct GNUNET_SENSOR_SensorInfo *' with sensor information
 248  * @return #GNUNET_YES to continue iterations
 249  */
 250 static int
 251 init_sensor_model (void *cls, const struct GNUNET_HashCode *key, void *value)
 252 {
 253   struct GNUNET_SENSOR_SensorInfo *sensor = value;
 254   struct SensorModel *sensor_model;
 255
 256   if (0 != strcmp ("numeric", sensor->expected_datatype))
 257     return GNUNET_YES;
 258   sensor_model = GNUNET_new (struct SensorModel);
 259   sensor_model->sensor = sensor;
 260   sensor_model->wc =
 261       GNUNET_PEERSTORE_watch (peerstore, "sensor", &peerid, sensor->name,
 262                               &sensor_watcher, sensor_model);
 263   sensor_model->anomalous = GNUNET_NO;
 264   sensor_model->positive_count = 0;
 265   sensor_model->negative_count = 0;
 266   sensor_model->cls = model_api->create_model (model_api->cls);
 267   GNUNET_CONTAINER_DLL_insert (models_head, models_tail, sensor_model);
 268   LOG (GNUNET_ERROR_TYPE_DEBUG, "Created sensor model for `%s'.\n",
 269        sensor->name);
 270   return GNUNET_YES;
 271 }
 272
 273
 274 /**
 275  * Start the sensor analysis module
 276  *
 277  * @param c our service configuration
 278  * @param sensors multihashmap of loaded sensors
 279  * @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
 280  */
 281 int
 282 SENSOR_analysis_start (const struct GNUNET_CONFIGURATION_Handle *c,
 283                        struct GNUNET_CONTAINER_MultiHashMap *s)
 284 {
 285   char *model_name;
 286
 287   GNUNET_assert (NULL != s);
 288   cfg = c;
 289   sensors = s;
 290   if (GNUNET_OK !=
 291       GNUNET_CONFIGURATION_get_value_string (cfg, "sensor-analysis", "MODEL",
 292                                              &model_name))
 293   {
 294     LOG (GNUNET_ERROR_TYPE_ERROR,
 295          _("Analysis model not defined in configuration.\n"));
 296     return GNUNET_SYSERR;
 297   }
 298   GNUNET_asprintf (&model_lib_name, "libgnunet_plugin_sensor_model_%s",
 299                    model_name);
 300   model_api = GNUNET_PLUGIN_load (model_lib_name, (void *) cfg);
 301   GNUNET_free (model_name);
 302   if (NULL == model_api)
 303   {
 304     LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not load analysis model `%s'.\n"),
 305          model_lib_name);
 306     return GNUNET_SYSERR;
 307   }
 308   peerstore = GNUNET_PEERSTORE_connect (cfg);
 309   if (NULL == peerstore)
 310   {
 311     LOG (GNUNET_ERROR_TYPE_ERROR,
 312          _("Could not connect to peerstore service.\n"));
 313     SENSOR_analysis_stop ();
 314     return GNUNET_SYSERR;
 315   }
 316   if (GNUNET_OK !=
 317       GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-analysis",
 318                                              "CONFIRMATION_COUNT",
 319                                              &confirmation_count))
 320     confirmation_count = 1;
 321   GNUNET_CRYPTO_get_peer_identity (cfg, &peerid);
 322   GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_model, NULL);
 323   return GNUNET_OK;
 324 }
 325
 326 /* end of gnunet-service-sensor_analysis.c */