src/testbed/testbed_api_statistics.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2008--2013 Christian Grothoff (and other contributing authors)
   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 testbed/testbed_api_statistics.c
  23  * @brief high-level statistics function
  24  * @author Christian Grothoff
  25  * @author Sree Harsha Totakura
  26  */
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_testbed_service.h"
  30
  31 #include "testbed_api_operations.h"
  32
  33
  34 /**
  35  * Generic logging shorthand
  36  */
  37 #define LOG(kind,...)                           \
  38   GNUNET_log_from (kind, "testbed-api-statistics", __VA_ARGS__)
  39
  40 /**
  41  * Debug logging shorthand
  42  */
  43 #define LOG_DEBUG(...)                          \
  44   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  45
  46
  47 /**
  48  * Context information for use in GNUNET_TESTBED_get_statistics()
  49  */
  50 struct GetStatsContext
  51 {
  52   /**
  53    * The main operation we generate while creating this context
  54    */
  55   struct GNUNET_TESTBED_Operation *main_op;
  56
  57   /**
  58    * The service connect operations we create to open connection to the
  59    * statistics service of each given peer
  60    */
  61   struct  GNUNET_TESTBED_Operation **ops;
  62
  63   /**
  64    * The array of peers whose statistics services are to be accessed
  65    */
  66   struct GNUNET_TESTBED_Peer **peers;
  67
  68   /**
  69    * The subsystem of peers for which statistics are requested
  70    */
  71   char *subsystem;
  72
  73   /**
  74    * The particular statistics value of interest
  75    */
  76   char *name;
  77
  78   /**
  79    * The iterator to call with statistics information
  80    */
  81   GNUNET_TESTBED_StatisticsIterator proc;
  82
  83   /**
  84    * The callback to call when we are done iterating through all peers'
  85    * statistics services
  86    */
  87   GNUNET_TESTBED_OperationCompletionCallback cont;
  88
  89   /**
  90    * The closure for the above callbacks
  91    */
  92   void *cb_cls;
  93
  94   /**
  95    * The task for calling the continuation callback
  96    */
  97   GNUNET_SCHEDULER_TaskIdentifier call_completion_task_id;
  98
  99   /**
 100    * The number of peers present in the peers array.  This number also
 101    * represents the number of service connect operations in the ops array
 102    */
 103   unsigned int num_peers;
 104
 105   /**
 106    * How many peers' statistics have we iterated through
 107    */
 108   unsigned int num_completed;
 109
 110 };
 111
 112
 113 /**
 114  * Context information with respect to a particular peer
 115  */
 116 struct PeerGetStatsContext
 117 {
 118   /**
 119    * The GetStatsContext which is associated with this context
 120    */
 121   struct GetStatsContext *sc;
 122
 123   /**
 124    * The handle from GNUNET_STATISTICS_get()
 125    */
 126   struct GNUNET_STATISTICS_GetHandle *get_handle;
 127
 128   /**
 129    * Task to mark the statistics service connect operation as done
 130    */
 131   GNUNET_SCHEDULER_TaskIdentifier op_done_task_id;
 132
 133   /**
 134    * The index of this peer in the peers array of GetStatsContext
 135    */
 136   unsigned int peer_index;
 137 };
 138
 139
 140 /**
 141  * A no-wait operation queue
 142  */
 143 static struct OperationQueue *no_wait_queue;
 144
 145
 146 /**
 147  * Call statistics operation completion.  We call it in a separate task because
 148  * the iteration_completion_cb() cannot destroy statistics handle which will be
 149  * the case if the user calles GNUNET_TESTBED_operation_done() on the
 150  * get_statistics operation.
 151  *
 152  * @param cls the GetStatsContext
 153  * @param tc the scheduler task context
 154  */
 155 static void
 156 call_completion_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 157 {
 158   struct GetStatsContext *sc = cls;
 159
 160   GNUNET_assert (sc->call_completion_task_id != GNUNET_SCHEDULER_NO_TASK);
 161   sc->call_completion_task_id = GNUNET_SCHEDULER_NO_TASK;
 162   LOG_DEBUG ("Calling get_statistics() continuation callback\n");
 163   sc->cont (sc->cb_cls, sc->main_op, NULL);
 164 }
 165
 166
 167 /**
 168  * Task to mark statistics service connect operation as done.  We call it here
 169  * as we cannot destroy the statistics handle in iteration_completion_cb()
 170  *
 171  * @param cls the PeerGetStatsContext
 172  * @param tc the scheduler task context
 173  */
 174 static void
 175 op_done_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 176 {
 177   struct PeerGetStatsContext *peer_sc = cls;
 178   struct GetStatsContext *sc;
 179   struct GNUNET_TESTBED_Operation **op;
 180
 181   sc = peer_sc->sc;
 182   peer_sc->op_done_task_id = GNUNET_SCHEDULER_NO_TASK;
 183   op = &sc->ops[peer_sc->peer_index];
 184   GNUNET_assert (NULL != *op);
 185   GNUNET_TESTBED_operation_done (*op);
 186   *op = NULL;
 187 }
 188
 189
 190 /**
 191  * Continuation called by the "get_all" and "get" functions.
 192  *
 193  * @param cls the PeerGetStatsContext
 194  * @param success GNUNET_OK if statistics were
 195  *        successfully obtained, GNUNET_SYSERR if not.
 196  */
 197 static void
 198 iteration_completion_cb (void *cls, int success)
 199 {
 200   struct PeerGetStatsContext *peer_sc = cls;
 201   struct GetStatsContext *sc;
 202
 203   GNUNET_break (GNUNET_OK == success);
 204   sc = peer_sc->sc;
 205   peer_sc->get_handle = NULL;
 206   sc->num_completed++;
 207   peer_sc->op_done_task_id = GNUNET_SCHEDULER_add_now (&op_done_task, peer_sc);
 208   if (sc->num_completed == sc->num_peers)
 209   {
 210     LOG_DEBUG ("Scheduling to call iteration completion callback\n");
 211     sc->call_completion_task_id =
 212         GNUNET_SCHEDULER_add_now (&call_completion_task, sc);
 213   }
 214 }
 215
 216
 217 /**
 218  * Callback function to process statistic values.
 219  *
 220  * @param cls the PeerGetStatsContext
 221  * @param subsystem name of subsystem that created the statistic
 222  * @param name the name of the datum
 223  * @param value the current value
 224  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
 225  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
 226  */
 227 static int
 228 iterator_cb (void *cls, const char *subsystem,
 229              const char *name, uint64_t value,
 230              int is_persistent)
 231 {
 232   struct PeerGetStatsContext *peer_sc = cls;
 233   struct GetStatsContext *sc;
 234   struct GNUNET_TESTBED_Peer *peer;
 235   int ret;
 236
 237   sc = peer_sc->sc;
 238   peer = sc->peers[peer_sc->peer_index];
 239   LOG_DEBUG ("Peer %u: [%s,%s] -> %lu\n", peer_sc->peer_index,
 240              subsystem, name, (unsigned long) value);
 241   ret = sc->proc (sc->cb_cls, peer,
 242                   subsystem, name, value, is_persistent);
 243   if (GNUNET_SYSERR == ret)
 244     LOG_DEBUG ("Aborting iteration for peer %u\n", peer_sc->peer_index);
 245   return ret;
 246 }
 247
 248
 249 /**
 250  * Called after opening a connection to the statistics service of a peer
 251  *
 252  * @param cls the PeerGetStatsContext
 253  * @param op the operation that has been finished
 254  * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
 255  * @param emsg error message in case the operation has failed; will be NULL if
 256  *          operation has executed successfully.
 257  */
 258 static void
 259 service_connect_comp (void *cls,
 260                       struct GNUNET_TESTBED_Operation *op,
 261                       void *ca_result,
 262                       const char *emsg)
 263 {
 264   struct PeerGetStatsContext *peer_sc = cls;
 265   struct GNUNET_STATISTICS_Handle *h = ca_result;
 266
 267   LOG_DEBUG ("Retrieving statistics of peer %u\n", peer_sc->peer_index);
 268   peer_sc->get_handle =
 269       GNUNET_STATISTICS_get (h, peer_sc->sc->subsystem, peer_sc->sc->name,
 270                              GNUNET_TIME_UNIT_FOREVER_REL,
 271                              &iteration_completion_cb,
 272                              iterator_cb, peer_sc);
 273 }
 274
 275
 276 /**
 277  * Adapter function called to establish a connection to the statistics service
 278  * of a peer.
 279  *
 280  * @param cls the PeerGetStatsContext
 281  * @param cfg configuration of the peer to connect to; will be available until
 282  *          GNUNET_TESTBED_operation_done() is called on the operation returned
 283  *          from GNUNET_TESTBED_service_connect()
 284  * @return service handle to return in 'op_result', NULL on error
 285  */
 286 static void *
 287 statistics_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 288 {
 289   struct PeerGetStatsContext *peer_sc = cls;
 290
 291   LOG_DEBUG ("Connecting to statistics service of peer %u\n",
 292              peer_sc->peer_index);
 293   return GNUNET_STATISTICS_create ("<testbed-api>", cfg);
 294 }
 295
 296
 297 /**
 298  * Adapter function called to destroy statistics connection
 299  *
 300  * @param cls the PeerGetStatsContext
 301  * @param op_result service handle returned from the connect adapter
 302  */
 303 static void
 304 statistics_da (void *cls, void *op_result)
 305 {
 306   struct PeerGetStatsContext *peer_sc = cls;
 307   struct GNUNET_STATISTICS_Handle *sh = op_result;
 308
 309   if (NULL != peer_sc->get_handle)
 310   {
 311     GNUNET_STATISTICS_get_cancel (peer_sc->get_handle);
 312     peer_sc->get_handle = NULL;
 313   }
 314   GNUNET_STATISTICS_destroy (sh, GNUNET_NO);
 315   if (GNUNET_SCHEDULER_NO_TASK != peer_sc->op_done_task_id)
 316     GNUNET_SCHEDULER_cancel (peer_sc->op_done_task_id);
 317   GNUNET_free (peer_sc);
 318 }
 319
 320
 321 /**
 322  * Function called when get_statistics operation is ready
 323  *
 324  * @param cls the GetStatsContext
 325  */
 326 static void
 327 opstart_get_stats (void *cls)
 328 {
 329   struct GetStatsContext *sc = cls;
 330   struct PeerGetStatsContext *peer_sc;
 331   unsigned int peer;
 332
 333   LOG_DEBUG ("Starting get_statistics operation\n");
 334   sc->ops = GNUNET_malloc (sc->num_peers *
 335                            sizeof (struct GNUNET_TESTBED_Operation *));
 336   for (peer = 0; peer < sc->num_peers; peer++)
 337   {
 338     if (NULL == sc->peers[peer])
 339     {
 340       GNUNET_break (0);
 341       continue;
 342     }
 343     peer_sc = GNUNET_malloc (sizeof (struct PeerGetStatsContext));
 344     peer_sc->sc = sc;
 345     peer_sc->peer_index = peer;
 346     sc->ops[peer] =
 347         GNUNET_TESTBED_service_connect (sc, sc->peers[peer], "statistics",
 348                                         &service_connect_comp,
 349                                         peer_sc,
 350                                         &statistics_ca,
 351                                         &statistics_da,
 352                                         peer_sc);
 353   }
 354 }
 355
 356
 357 /**
 358  * Function called when get_statistics operation is cancelled or marked as done
 359  *
 360  * @param cls the GetStatsContext
 361  */
 362 static void
 363 oprelease_get_stats (void *cls)
 364 {
 365   struct GetStatsContext *sc = cls;
 366   unsigned int peer;
 367
 368   LOG_DEBUG ("Cleaning up get_statistics operation\n");
 369   if (GNUNET_SCHEDULER_NO_TASK != sc->call_completion_task_id)
 370     GNUNET_SCHEDULER_cancel (sc->call_completion_task_id);
 371   if (NULL != sc->ops)
 372   {
 373     for (peer = 0; peer < sc->num_peers; peer++)
 374     {
 375       if (NULL != sc->ops[peer])
 376       {
 377         GNUNET_TESTBED_operation_done (sc->ops[peer]);
 378         sc->ops[peer] = NULL;
 379       }
 380     }
 381     GNUNET_free (sc->ops);
 382   }
 383   GNUNET_free_non_null (sc->subsystem);
 384   GNUNET_free_non_null (sc->name);
 385   GNUNET_free (sc);
 386   if (GNUNET_YES ==
 387       GNUNET_TESTBED_operation_queue_destroy_empty_ (no_wait_queue))
 388     no_wait_queue = NULL;
 389 }
 390
 391
 392 /**
 393  * Convenience method that iterates over all (running) peers
 394  * and retrieves all statistics from each peer.
 395  *
 396  * @param num_peers number of peers to iterate over
 397  * @param peers array of peers to iterate over
 398  * @param subsystem limit to the specified subsystem, NULL for all subsystems
 399  * @param name name of the statistic value, NULL for all values
 400  * @param proc processing function for each statistic retrieved
 401  * @param cont continuation to call once call is completed(?)
 402  * @param cls closure to pass to proc and cont
 403  * @return operation handle to cancel the operation
 404  */
 405 struct GNUNET_TESTBED_Operation *
 406 GNUNET_TESTBED_get_statistics (unsigned int num_peers,
 407                                struct GNUNET_TESTBED_Peer **peers,
 408                                const char *subsystem, const char *name,
 409                                GNUNET_TESTBED_StatisticsIterator proc,
 410                                GNUNET_TESTBED_OperationCompletionCallback cont,
 411                                void *cls)
 412 {
 413   struct GetStatsContext *sc;
 414
 415   GNUNET_assert (NULL != proc);
 416   GNUNET_assert (NULL != cont);
 417   if (NULL == no_wait_queue)
 418     no_wait_queue = GNUNET_TESTBED_operation_queue_create_
 419         (OPERATION_QUEUE_TYPE_FIXED, UINT_MAX);
 420   sc = GNUNET_malloc (sizeof (struct GetStatsContext));
 421   sc->peers = peers;
 422   sc->subsystem = (NULL == subsystem) ? NULL : GNUNET_strdup (subsystem);
 423   sc->name = (NULL == name) ? NULL : GNUNET_strdup (name);
 424   sc->proc = proc;
 425   sc->cont = cont;
 426   sc->cb_cls = cls;
 427   sc->num_peers = num_peers;
 428   sc->main_op =
 429       GNUNET_TESTBED_operation_create_ (sc, &opstart_get_stats,
 430                                         &oprelease_get_stats);
 431   GNUNET_TESTBED_operation_queue_insert_ (no_wait_queue, sc->main_op);
 432   GNUNET_TESTBED_operation_begin_wait_ (sc->main_op);
 433   return sc->main_op;
 434 }
 435
 436
 437 /* end of testbed_api_statistics.c */