src/statistics/gnunet-statistics.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file statistics/gnunet-statistics.c
  23  * @brief tool to obtain statistics
  24  * @author Christian Grothoff
  25  * @author Igor Wronsky
  26  */
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_statistics_service.h"
  30 #include "statistics.h"
  31
  32 #define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  33
  34 /**
  35  * Final status code.
  36  */
  37 static int ret;
  38
  39 /**
  40  * Set to subsystem that we're going to get stats for (or NULL for all).
  41  */
  42 static char *subsystem;
  43
  44 /**
  45  * Set to the specific stat value that we are after (or NULL for all).
  46  */
  47 static char *name;
  48
  49 /**
  50  * Make the value that is being set persistent.
  51  */
  52 static int persistent;
  53
  54 /**
  55  * Watch value continuously
  56  */
  57 static int watch;
  58
  59 /**
  60  * Quiet mode
  61  */
  62 static int quiet;
  63
  64 /**
  65  * Remote host
  66  */
  67 static char *remote_host;
  68
  69 /**
  70  * Remote host's port
  71  */
  72 static unsigned long long  remote_port;
  73
  74 /**
  75  * Value to set
  76  */
  77 static unsigned long long set_val;
  78
  79 /**
  80  * Set operation
  81  */
  82 static int set_value;
  83
  84
  85 /**
  86  * Callback function to process statistic values.
  87  *
  88  * @param cls closure
  89  * @param subsystem name of subsystem that created the statistic
  90  * @param name the name of the datum
  91  * @param value the current value
  92  * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
  93  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  94  */
  95 static int
  96 printer (void *cls,
  97          const char *subsystem,
  98          const char *name,
  99          uint64_t value,
 100          int is_persistent)
 101 {
 102   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
 103   const char * now_str;
 104
 105   if (quiet == GNUNET_NO)
 106   {
 107     if (GNUNET_YES == watch)
 108     {
 109       now_str = GNUNET_STRINGS_absolute_time_to_string(now);
 110       FPRINTF (stdout, "%24s %s%12s %50s: %16llu \n",
 111                now_str,
 112                is_persistent ? "!" : " ",
 113                subsystem, _(name), (unsigned long long) value);
 114     }
 115     else
 116     {
 117       FPRINTF (stdout, "%s%12s %50s: %16llu \n",
 118                is_persistent ? "!" : " ",
 119                subsystem, _(name), (unsigned long long) value);
 120     }
 121   }
 122   else
 123     FPRINTF (stdout, "%llu\n", (unsigned long long) value);
 124
 125   return GNUNET_OK;
 126 }
 127
 128
 129 /**
 130  * Function called last by the statistics code.
 131  *
 132  * @param cls closure
 133  * @param success #GNUNET_OK if statistics were
 134  *        successfully obtained, #GNUNET_SYSERR if not.
 135  */
 136 static void
 137 cleanup (void *cls, int success)
 138 {
 139
 140   if (success != GNUNET_OK)
 141   {
 142     if (NULL == remote_host)
 143       FPRINTF (stderr,
 144                "%s",
 145                _("Failed to obtain statistics.\n"));
 146     else
 147       FPRINTF (stderr,
 148                _("Failed to obtain statistics from host `%s:%llu'\n"),
 149                remote_host,
 150                remote_port);
 151     ret = 1;
 152   }
 153   GNUNET_SCHEDULER_shutdown ();
 154 }
 155
 156
 157 /**
 158  * Function run on shutdown to clean up.
 159  *
 160  * @param cls the statistics handle
 161  */
 162 static void
 163 shutdown_task (void *cls)
 164 {
 165   struct GNUNET_STATISTICS_Handle *h = cls;
 166
 167   if (NULL == h)
 168     return;
 169   if ( (GNUNET_YES == watch) &&
 170        (NULL != subsystem) &&
 171        (NULL != name) )
 172     GNUNET_assert (GNUNET_OK ==
 173                    GNUNET_STATISTICS_watch_cancel (h, subsystem, name, &printer, h));
 174   GNUNET_STATISTICS_destroy (h, GNUNET_NO);
 175   h = NULL;
 176 }
 177
 178
 179 /**
 180  * Main task that does the actual work.
 181  *
 182  * @param cls closure with our configuration
 183  */
 184 static void
 185 main_task (void *cls)
 186 {
 187   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 188   struct GNUNET_STATISTICS_Handle *h;
 189
 190   if (set_value)
 191   {
 192     if (NULL == subsystem)
 193     {
 194       FPRINTF (stderr, "%s", _("Missing argument: subsystem \n"));
 195       ret = 1;
 196       return;
 197     }
 198     if (NULL == name)
 199     {
 200       FPRINTF (stderr, "%s", _("Missing argument: name\n"));
 201       ret = 1;
 202       return;
 203     }
 204     h = GNUNET_STATISTICS_create (subsystem, cfg);
 205     if (NULL == h)
 206     {
 207       ret = 1;
 208       return;
 209     }
 210     GNUNET_STATISTICS_set (h, name, (uint64_t) set_val, persistent);
 211     GNUNET_STATISTICS_destroy (h, GNUNET_YES);
 212     h = NULL;
 213     return;
 214   }
 215   if (NULL == (h = GNUNET_STATISTICS_create ("gnunet-statistics", cfg)))
 216   {
 217     ret = 1;
 218     return;
 219   }
 220   if (GNUNET_NO == watch)
 221   {
 222     if (NULL ==
 223       GNUNET_STATISTICS_get (h, subsystem, name, GET_TIMEOUT,
 224                              &cleanup,
 225                              &printer, h))
 226     cleanup (h, GNUNET_SYSERR);
 227   }
 228   else
 229   {
 230     if ((NULL == subsystem) || (NULL == name))
 231     {
 232       printf (_("No subsystem or name given\n"));
 233       GNUNET_STATISTICS_destroy (h, GNUNET_NO);
 234       h = NULL;
 235       ret = 1;
 236       return;
 237     }
 238     if (GNUNET_OK != GNUNET_STATISTICS_watch (h, subsystem, name,
 239                                               &printer, h))
 240     {
 241       fprintf (stderr, _("Failed to initialize watch routine\n"));
 242       GNUNET_SCHEDULER_add_now (&shutdown_task, h);
 243       return;
 244     }
 245   }
 246   GNUNET_SCHEDULER_add_shutdown (&shutdown_task, h);
 247 }
 248
 249
 250 /**
 251  * Function called with th test result to see if the resolver is
 252  * running.
 253  *
 254  * @param cls closure with our configuration
 255  * @param result #GNUNET_YES if the resolver is running
 256  */
 257 static void
 258 resolver_test_task (void *cls,
 259                     int result)
 260 {
 261   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 262
 263   if (GNUNET_YES != result)
 264    {
 265      FPRINTF (stderr,
 266               _("Trying to connect to remote host, but service `%s' is not running\n"),
 267               "resolver");
 268      return;
 269    }
 270   /* connect to a remote host */
 271   if (0 == remote_port)
 272   {
 273     if (GNUNET_SYSERR ==
 274         GNUNET_CONFIGURATION_get_value_number (cfg, "statistics",
 275                                                "PORT",
 276                                                &remote_port))
 277     {
 278       FPRINTF (stderr,
 279                _("A port is required to connect to host `%s'\n"),
 280                remote_host);
 281       return;
 282     }
 283   }
 284   else if (65535 <= remote_port)
 285   {
 286     FPRINTF (stderr,
 287              _("A port has to be between 1 and 65535 to connect to host `%s'\n"),
 288              remote_host);
 289     return;
 290   }
 291
 292   /* Manipulate configuration */
 293   GNUNET_CONFIGURATION_set_value_string (cfg,
 294                                          "statistics", "UNIXPATH", "");
 295   GNUNET_CONFIGURATION_set_value_string (cfg,
 296                                          "statistics", "HOSTNAME", remote_host);
 297   GNUNET_CONFIGURATION_set_value_number (cfg,
 298                                          "statistics", "PORT", remote_port);
 299   GNUNET_SCHEDULER_add_now (&main_task, cfg);
 300 }
 301
 302
 303 /**
 304  * Main function that will be run by the scheduler.
 305  *
 306  * @param cls closure
 307  * @param args remaining command-line arguments
 308  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 309  * @param cfg configuration
 310  */
 311 static void
 312 run (void *cls, char *const *args, const char *cfgfile,
 313      const struct GNUNET_CONFIGURATION_Handle *cfg)
 314 {
 315   set_value = GNUNET_NO;
 316   if (NULL != args[0])
 317   {
 318     if (1 != SSCANF (args[0], "%llu", &set_val))
 319     {
 320       FPRINTF (stderr, _("Invalid argument `%s'\n"), args[0]);
 321       ret = 1;
 322       return;
 323     }
 324     set_value = GNUNET_YES;
 325   }
 326   if (NULL != remote_host)
 327     GNUNET_CLIENT_service_test ("resolver", cfg, GNUNET_TIME_UNIT_SECONDS,
 328                                 &resolver_test_task, (void *) cfg);
 329   else
 330     GNUNET_SCHEDULER_add_now (&main_task, (void *) cfg);
 331 }
 332
 333
 334 /**
 335  * The main function to obtain statistics in GNUnet.
 336  *
 337  * @param argc number of arguments from the command line
 338  * @param argv command line arguments
 339  * @return 0 ok, 1 on error
 340  */
 341 int
 342 main (int argc, char *const *argv)
 343 {
 344   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 345     {'n', "name", "NAME",
 346      gettext_noop ("limit output to statistics for the given NAME"), 1,
 347      &GNUNET_GETOPT_set_string, &name},
 348     {'p', "persistent", NULL,
 349      gettext_noop ("make the value being set persistent"), 0,
 350      &GNUNET_GETOPT_set_one, &persistent},
 351     {'s', "subsystem", "SUBSYSTEM",
 352      gettext_noop ("limit output to the given SUBSYSTEM"), 1,
 353      &GNUNET_GETOPT_set_string, &subsystem},
 354     {'q', "quiet", NULL,
 355      gettext_noop ("just print the statistics value"), 0,
 356      &GNUNET_GETOPT_set_one, &quiet},
 357     {'w', "watch", NULL,
 358      gettext_noop ("watch value continuously"), 0,
 359      &GNUNET_GETOPT_set_one, &watch},
 360      {'r', "remote", NULL,
 361       gettext_noop ("connect to remote host"), 1,
 362       &GNUNET_GETOPT_set_string, &remote_host},
 363     {'o', "port", NULL,
 364      gettext_noop ("port for remote host"), 1,
 365      &GNUNET_GETOPT_set_uint, &remote_port},
 366     GNUNET_GETOPT_OPTION_END
 367   };
 368   remote_port = 0;
 369   remote_host = NULL;
 370   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 371     return 2;
 372
 373   ret = (GNUNET_OK ==
 374          GNUNET_PROGRAM_run (argc, argv, "gnunet-statistics [options [value]]",
 375                              gettext_noop
 376                              ("Print statistics about GNUnet operations."),
 377                              options, &run, NULL)) ? ret : 1;
 378   GNUNET_free_non_null (remote_host);
 379   GNUNET_free ((void*) argv);
 380   return ret;
 381 }
 382
 383 /* end of gnunet-statistics.c */