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  * Model library name
  91  */
  92 static char *model_lib_name;
  93
  94 /**
  95  * Model handle
  96  */
  97 static struct GNUNET_SENSOR_ModelFunctions *model_api;
  98
  99 /**
 100  * Handle to peerstore service
 101  */
 102 static struct GNUNET_PEERSTORE_Handle *peerstore;
 103
 104 /**
 105  * Head of DLL of created models
 106  */
 107 static struct SensorModel *models_head;
 108
 109 /**
 110  * Tail of DLL of created models
 111  */
 112 static struct SensorModel *models_tail;
 113
 114 /**
 115  * My peer id
 116  */
 117 struct GNUNET_PeerIdentity peerid;
 118
 119 /**
 120  * How many subsequent values required to flip anomaly label.
 121  * E.g. After 3 subsequent anomaly reports, status change to anomalous.
 122  */
 123 unsigned long long confirmation_count;
 124
 125 /**
 126  * Destroy a created model
 127  */
 128 static void
 129 destroy_sensor_model (struct SensorModel *sensor_model)
 130 {
 131   GNUNET_assert (NULL != sensor_model);
 132   LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying sensor model for `%s'.\n",
 133        sensor_model->sensor->name);
 134   if (NULL != sensor_model->wc)
 135   {
 136     GNUNET_PEERSTORE_watch_cancel (sensor_model->wc);
 137     sensor_model->wc = NULL;
 138   }
 139   if (NULL != sensor_model->cls)
 140   {
 141     model_api->destroy_model (sensor_model->cls);
 142     sensor_model->cls = NULL;
 143   }
 144   GNUNET_free (sensor_model);
 145   sensor_model = NULL;
 146 }
 147
 148
 149 /**
 150  * Stop the sensor analysis module
 151  */
 152 void
 153 SENSOR_analysis_stop ()
 154 {
 155   struct SensorModel *sm;
 156
 157   LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping sensor analysis module.\n");
 158   while (NULL != models_head)
 159   {
 160     sm = models_head;
 161     GNUNET_CONTAINER_DLL_remove (models_head, models_tail, sm);
 162     destroy_sensor_model (sm);
 163   }
 164   if (NULL != peerstore)
 165   {
 166     GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_YES);
 167     peerstore = NULL;
 168   }
 169   if (NULL != model_api)
 170   {
 171     GNUNET_break (NULL == GNUNET_PLUGIN_unload (model_lib_name, model_api));
 172     GNUNET_free (model_lib_name);
 173     model_lib_name = NULL;
 174   }
 175 }
 176
 177
 178 /**
 179  * Sensor value watch callback
 180  *
 181  * @param cls Sensor model struct
 182  * @param record Received record from peerstore, should contain new sensor value
 183  * @param emsg Error message from peerstore if any, NULL if no errors
 184  * @return #GNUNET_YES
 185  */
 186 static int
 187 sensor_watcher (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
 188 {
 189   struct SensorModel *model = cls;
 190   double *val;
 191   int anomalous;
 192
 193   LOG (GNUNET_ERROR_TYPE_DEBUG,
 194        "Received a sensor value, will feed to sensor model.\n");
 195   if (sizeof (double) != record->value_size)
 196   {
 197     LOG (GNUNET_ERROR_TYPE_ERROR, _("Received an invalid sensor value."));
 198     return GNUNET_YES;
 199   }
 200   val = (double *) (record->value);
 201   anomalous = model_api->feed_model (model->cls, *val);
 202   if (GNUNET_YES == anomalous)
 203   {
 204     model->positive_count++;
 205     model->negative_count = 0;
 206     if (GNUNET_NO == model->anomalous &&
 207         model->positive_count >= confirmation_count)
 208     {
 209       model->anomalous = GNUNET_YES;
 210       LOG (GNUNET_ERROR_TYPE_WARNING,
 211            "Anomaly state started for sensor `%s'.\n", model->sensor->name);
 212       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 213     }
 214   }
 215   else
 216   {
 217     model->negative_count++;
 218     model->positive_count = 0;
 219     if (GNUNET_YES == model->anomalous &&
 220         model->negative_count >= confirmation_count)
 221     {
 222       model->anomalous = GNUNET_NO;
 223       LOG (GNUNET_ERROR_TYPE_INFO, "Anomaly state stopped for sensor `%s'.\n",
 224            model->sensor->name);
 225       SENSOR_reporting_anomaly_update (model->sensor, model->anomalous);
 226     }
 227   }
 228   return GNUNET_YES;
 229 }
 230
 231
 232 /**
 233  * Iterator for defined sensors
 234  * Creates sensor model for numeric sensors
 235  *
 236  * @param cls unused
 237  * @param key unused
 238  * @param value a 'struct GNUNET_SENSOR_SensorInfo *' with sensor information
 239  * @return #GNUNET_YES to continue iterations
 240  */
 241 static int
 242 init_sensor_model (void *cls, const struct GNUNET_HashCode *key, void *value)
 243 {
 244   struct GNUNET_SENSOR_SensorInfo *sensor = value;
 245   struct SensorModel *sensor_model;
 246
 247   if (0 != strcmp ("numeric", sensor->expected_datatype))
 248     return GNUNET_YES;
 249   sensor_model = GNUNET_new (struct SensorModel);
 250   sensor_model->sensor = sensor;
 251   sensor_model->wc =
 252       GNUNET_PEERSTORE_watch (peerstore, "sensor", &peerid, sensor->name,
 253                               &sensor_watcher, sensor_model);
 254   sensor_model->anomalous = GNUNET_NO;
 255   sensor_model->positive_count = 0;
 256   sensor_model->negative_count = 0;
 257   sensor_model->cls = model_api->create_model (model_api->cls);
 258   GNUNET_CONTAINER_DLL_insert (models_head, models_tail, sensor_model);
 259   LOG (GNUNET_ERROR_TYPE_DEBUG, "Created sensor model for `%s'.\n",
 260        sensor->name);
 261   return GNUNET_YES;
 262 }
 263
 264
 265 /**
 266  * Start the sensor analysis module
 267  *
 268  * @param c our service configuration
 269  * @param sensors multihashmap of loaded sensors
 270  * @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
 271  */
 272 int
 273 SENSOR_analysis_start (const struct GNUNET_CONFIGURATION_Handle *c,
 274                        struct GNUNET_CONTAINER_MultiHashMap *sensors)
 275 {
 276   char *model_name;
 277
 278   GNUNET_assert (NULL != sensors);
 279   cfg = c;
 280   if (GNUNET_OK !=
 281       GNUNET_CONFIGURATION_get_value_string (cfg, "sensor-analysis", "MODEL",
 282                                              &model_name))
 283   {
 284     LOG (GNUNET_ERROR_TYPE_ERROR,
 285          _("Analysis model not defined in configuration.\n"));
 286     return GNUNET_SYSERR;
 287   }
 288   GNUNET_asprintf (&model_lib_name, "libgnunet_plugin_sensor_model_%s",
 289                    model_name);
 290   model_api = GNUNET_PLUGIN_load (model_lib_name, (void *) cfg);
 291   GNUNET_free (model_name);
 292   if (NULL == model_api)
 293   {
 294     LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not load analysis model `%s'.\n"),
 295          model_lib_name);
 296     return GNUNET_SYSERR;
 297   }
 298   peerstore = GNUNET_PEERSTORE_connect (cfg);
 299   if (NULL == peerstore)
 300   {
 301     LOG (GNUNET_ERROR_TYPE_ERROR,
 302          _("Could not connect to peerstore service.\n"));
 303     SENSOR_analysis_stop ();
 304     return GNUNET_SYSERR;
 305   }
 306   if (GNUNET_OK !=
 307       GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-analysis",
 308                                              "CONFIRMATION_COUNT",
 309                                              &confirmation_count))
 310     confirmation_count = 1;
 311   GNUNET_CRYPTO_get_peer_identity (cfg, &peerid);
 312   GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_model, NULL);
 313   return GNUNET_OK;
 314 }
 315
 316 /* end of gnunet-service-sensor_analysis.c */