src/testbed/gnunet-daemon-latency-logger.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2008--2014 GNUnet e.V.
   4
   5       GNUnet is free software: you can redistribute it and/or modify it
   6       under the terms of the GNU Affero General Public License as published
   7       by the Free Software Foundation, either version 3 of the License,
   8       or (at your 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       Affero General Public License for more details.
  14
  15       You should have received a copy of the GNU Affero General Public License
  16       along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file testbed/gnunet-daemon-latency-logger.c
  23  * @brief log latency values from neighbour connections into an SQLite database
  24  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_ats_service.h"
  30 #include <sqlite3.h>
  31
  32
  33 /**
  34  * Logging shorthand
  35  */
  36 #define LOG(type, ...)                           \
  37   GNUNET_log (type, __VA_ARGS__)
  38
  39 /**
  40  * Debug logging shorthand
  41  */
  42 #define DEBUG(...)                              \
  43   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  44
  45 /**
  46  * Log an error message at log-level 'level' that indicates
  47  * a failure of the command 'cmd' on file 'filename'
  48  * with the message given by strerror(errno).
  49  */
  50 #define LOG_SQLITE(db, msg, level, cmd)                                 \
  51   do {                                                                  \
  52     GNUNET_log_from (level, "sqlite", _ ( \
  53                        "`%s' failed at %s:%d with error: %s\n"), \
  54                      cmd, __FILE__, __LINE__, sqlite3_errmsg (db));  \
  55     if (msg != NULL)                                                    \
  56       GNUNET_asprintf (msg, _ ("`%s' failed at %s:%u with error: %s"), cmd, \
  57                        __FILE__, __LINE__, sqlite3_errmsg (db));     \
  58   } while (0)
  59
  60
  61 /**
  62  * Entry type to be used in the map to store old latency values
  63  */
  64 struct Entry
  65 {
  66   /**
  67    *  The peer's identity
  68    */
  69   struct GNUNET_PeerIdentity id;
  70
  71   /**
  72    * The last known value for latency.
  73    * FIXME: type!
  74    */
  75   unsigned int latency;
  76 };
  77
  78
  79 /**
  80  * Handle to the map used to store old latency values for peers
  81  */
  82 static struct GNUNET_CONTAINER_MultiPeerMap *map;
  83
  84 /**
  85  * The SQLite database handle
  86  */
  87 static struct sqlite3 *db;
  88
  89 /**
  90  * Handle to the ATS performance subsystem
  91  */
  92 static struct GNUNET_ATS_PerformanceHandle *ats;
  93
  94 /**
  95  * Prepared statement for inserting values into the database table
  96  */
  97 static struct sqlite3_stmt *stmt_insert;
  98
  99
 100 /**
 101  * @ingroup hashmap
 102  * Iterator over hash map entries.
 103  *
 104  * @param cls closure
 105  * @param key current public key
 106  * @param value value in the hash map
 107  * @return #GNUNET_YES if we should continue to
 108  *         iterate,
 109  *         #GNUNET_NO if not.
 110  */
 111 static int
 112 free_iterator (void *cls,
 113                const struct GNUNET_PeerIdentity *key,
 114                void *value)
 115 {
 116   struct Entry *e = cls;
 117
 118   GNUNET_assert (GNUNET_YES ==
 119                  GNUNET_CONTAINER_multipeermap_remove (map, key, e));
 120   GNUNET_free (e);
 121   return GNUNET_YES;
 122 }
 123
 124
 125 /**
 126  * Shutdown
 127  *
 128  * @param cls NULL
 129  * @return
 130  */
 131 static void
 132 do_shutdown (void *cls)
 133 {
 134   GNUNET_ATS_performance_done (ats);
 135   ats = NULL;
 136   if (NULL != stmt_insert)
 137   {
 138     sqlite3_finalize (stmt_insert);
 139     stmt_insert = NULL;
 140   }
 141   GNUNET_break (SQLITE_OK == sqlite3_close (db));
 142   db = NULL;
 143   if (NULL != map)
 144   {
 145     GNUNET_assert (GNUNET_SYSERR !=
 146                    GNUNET_CONTAINER_multipeermap_iterate (map, free_iterator,
 147                                                           NULL));
 148     GNUNET_CONTAINER_multipeermap_destroy (map);
 149     map = NULL;
 150   }
 151 }
 152
 153
 154 /**
 155  * Signature of a function that is called with QoS information about an address.
 156  *
 157  * @param cls closure
 158  * @param address the address
 159  * @param address_active #GNUNET_YES if this address is actively used
 160  *        to maintain a connection to a peer;
 161  *        #GNUNET_NO if the address is not actively used;
 162  *        #GNUNET_SYSERR if this address is no longer available for ATS
 163  * @param bandwidth_out assigned outbound bandwidth for the connection
 164  * @param bandwidth_in assigned inbound bandwidth for the connection
 165  * @param prop performance data for the address (as far as known)
 166  */
 167 static void
 168 addr_info_cb (void *cls,
 169               const struct GNUNET_HELLO_Address *address,
 170               int address_active,
 171               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 172               struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
 173               const struct GNUNET_ATS_Properties *prop)
 174 {
 175   static const char *query_insert =
 176     "INSERT INTO ats_info("
 177     " id,"
 178     " val,"
 179     " timestamp"
 180     ") VALUES ("
 181     " ?1,"
 182     " ?2,"
 183     " datetime('now')"
 184     ");";
 185   struct Entry *entry;
 186   int latency; /* FIXME: type!? */
 187
 188   if (NULL == address)
 189   {
 190     /* ATS service temporarily disconnected */
 191     return;
 192   }
 193
 194   GNUNET_assert (NULL != db);
 195   if (GNUNET_YES != address_active)
 196     return;
 197   latency = (int) prop->delay.rel_value_us;
 198   entry = NULL;
 199   if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (map,
 200                                                             &address->peer))
 201   {
 202     entry = GNUNET_CONTAINER_multipeermap_get (map, &address->peer);
 203     GNUNET_assert (NULL != entry);
 204     if (latency == entry->latency)
 205       return;
 206   }
 207   if (NULL == stmt_insert)
 208   {
 209     if (SQLITE_OK != sqlite3_prepare_v2 (db, query_insert, -1, &stmt_insert,
 210                                          NULL))
 211     {
 212       LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_prepare_v2");
 213       goto err_shutdown;
 214     }
 215   }
 216   if ((SQLITE_OK != sqlite3_bind_text (stmt_insert, 1,
 217                                        GNUNET_i2s (&address->peer), -1,
 218                                        SQLITE_STATIC)) ||
 219       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 2, latency)))
 220   {
 221     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_bind_text");
 222     goto err_shutdown;
 223   }
 224   if (SQLITE_DONE != sqlite3_step (stmt_insert))
 225   {
 226     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_step");
 227     goto err_shutdown;
 228   }
 229   if (SQLITE_OK != sqlite3_reset (stmt_insert))
 230   {
 231     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_insert");
 232     goto err_shutdown;
 233   }
 234   if (NULL == entry)
 235   {
 236     entry = GNUNET_new (struct Entry);
 237     entry->id = address->peer;
 238     GNUNET_CONTAINER_multipeermap_put (map,
 239                                        &entry->id, entry,
 240                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 241   }
 242   entry->latency = latency;
 243   return;
 244
 245 err_shutdown:
 246   GNUNET_SCHEDULER_shutdown ();
 247 }
 248
 249
 250 /**
 251  * Main function that will be run.
 252  *
 253  * @param cls closure
 254  * @param args remaining command-line arguments
 255  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 256  * @param c configuration
 257  */
 258 static void
 259 run (void *cls, char *const *args, const char *cfgfile,
 260      const struct GNUNET_CONFIGURATION_Handle *c)
 261 {
 262   const char *query_create =
 263     "CREATE TABLE ats_info ("
 264     "id TEXT,"
 265     "val INTEGER,"
 266     "timestamp NUMERIC"
 267     ");";
 268   char *dbfile;
 269
 270   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c, "LATENCY-LOGGER",
 271                                                             "DBFILE",
 272                                                             &dbfile))
 273   {
 274     GNUNET_break (0);
 275     return;
 276   }
 277   if (SQLITE_OK != sqlite3_open (dbfile, &db))
 278   {
 279     if (NULL != db)
 280     {
 281       LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite_open_v2");
 282       GNUNET_break (SQLITE_OK == sqlite3_close (db));
 283     }
 284     else
 285       LOG (GNUNET_ERROR_TYPE_ERROR, "Cannot open sqlite file %s\n", dbfile);
 286     GNUNET_free (dbfile);
 287     return;
 288   }
 289   if (0 != sqlite3_exec (db, query_create, NULL, NULL, NULL))
 290     DEBUG ("SQLite Error: %d.  Perhaps the database `%s' already exits.\n",
 291            sqlite3_errcode (db), dbfile);
 292   DEBUG ("Opened database %s\n", dbfile);
 293   GNUNET_free (dbfile);
 294   dbfile = NULL;
 295   ats = GNUNET_ATS_performance_init (c, &addr_info_cb, NULL);
 296   map = GNUNET_CONTAINER_multipeermap_create (30, GNUNET_YES);
 297   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 298 }
 299
 300
 301 /**
 302  * Execution entry point
 303  */
 304 int
 305 main (int argc, char *const *argv)
 306 {
 307   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 308     GNUNET_GETOPT_OPTION_END
 309   };
 310   int ret;
 311
 312   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 313     return 2;
 314   ret =
 315     (GNUNET_OK ==
 316      GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-latency-logger",
 317                          _ (
 318                            "Daemon to log latency values of connections to neighbours"),
 319                          options, &run, NULL)) ? 0 : 1;
 320   GNUNET_free ((void *) argv);
 321   return ret;
 322 }