GNUnet  0.10.x
gnunet-statistics.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001, 2002, 2004-2007, 2009, 2016 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 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
30 #include "statistics.h"
31 
32 
36 static int ret;
37 
41 static char *subsystem;
42 
46 static char *path_testbed;
47 
51 static char *name;
52 
56 static int persistent;
57 
61 static int watch;
62 
66 static int quiet;
67 
71 static char *csv_separator;
72 
76 static char *remote_host;
77 
81 static unsigned long long remote_port;
82 
86 static unsigned long long set_val;
87 
91 static int set_value;
92 
96 static struct Node {
100  unsigned index_node;
101 
106 
111 
120 } * nodes;
121 
125 static unsigned num_nodes;
126 
130 struct ValueSet {
134  char *subsystem;
135 
139  char *name;
140 
144  uint64_t *values;
145 
150 };
151 
156 
160 static int num_nodes_ready;
161 
166 
177 static struct ValueSet *
179  const char *name,
180  unsigned num_values,
181  int is_persistent)
182 {
183  struct ValueSet *value_set;
184 
185  value_set = GNUNET_new(struct ValueSet);
186  value_set->subsystem = GNUNET_strdup(subsystem);
187  value_set->name = GNUNET_strdup(name);
188  value_set->values = GNUNET_new_array(num_values, uint64_t);
189  value_set->is_persistent = persistent;
190  return value_set;
191 }
192 
205 static int
206 printer(void *cls, const struct GNUNET_HashCode *key, void *value)
207 {
209  const char *now_str;
210  struct ValueSet *value_set = value;
211 
212  if (quiet == GNUNET_NO)
213  {
214  if (GNUNET_YES == watch)
215  {
217  fprintf(stdout,
218  "%24s%s %s%s%12s%s %s%50s%s%s ",
219  now_str,
221  value_set->is_persistent ? "!" : " ",
223  value_set->subsystem,
225  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
226  _(value_set->name),
227  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
228  (0 == strlen(csv_separator) ? ":" : csv_separator));
229  }
230  else
231  {
232  fprintf(stdout,
233  "%s%s%12s%s %s%50s%s%s ",
234  value_set->is_persistent ? "!" : " ",
236  value_set->subsystem,
238  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
239  _(value_set->name),
240  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
241  (0 == strlen(csv_separator) ? ":" : csv_separator));
242  }
243  }
244  for (unsigned i = 0; i < num_nodes; i++)
245  {
246  fprintf(stdout,
247  "%16llu%s",
248  (unsigned long long)value_set->values[i],
249  csv_separator);
250  }
251  fprintf(stdout, "\n");
252  GNUNET_free(value_set->subsystem);
253  GNUNET_free(value_set->name);
254  GNUNET_free(value_set->values);
255  GNUNET_free(value_set);
256  return GNUNET_YES;
257 }
258 
269 static int
270 printer_watch(void *cls,
271  const char *subsystem,
272  const char *name,
273  uint64_t value,
274  int is_persistent)
275 {
277  const char *now_str;
278 
279  if (quiet == GNUNET_NO)
280  {
281  if (GNUNET_YES == watch)
282  {
284  fprintf(stdout,
285  "%24s%s %s%s%12s%s %s%50s%s%s %16llu\n",
286  now_str,
288  is_persistent ? "!" : " ",
290  subsystem,
292  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
293  _(name),
294  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
295  (0 == strlen(csv_separator) ? ":" : csv_separator),
296  (unsigned long long)value);
297  }
298  else
299  {
300  fprintf(stdout,
301  "%s%s%12s%s %s%50s%s%s %16llu\n",
302  is_persistent ? "!" : " ",
304  subsystem,
306  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
307  _(name),
308  (0 == strlen(csv_separator) ? "" : "\""), /* quotes if csv */
309  (0 == strlen(csv_separator) ? ":" : csv_separator),
310  (unsigned long long)value);
311  }
312  }
313  else
314  fprintf(stdout, "%llu\n", (unsigned long long)value);
315 
316  return GNUNET_OK;
317 }
318 
326 static void
327 clean_node(void *cls)
328 {
329  const unsigned index_node = *(unsigned *)cls;
330  struct GNUNET_STATISTICS_Handle *h;
332 
333  if ((NULL != path_testbed) && /* were issued with -t <testbed-path> option */
334  (NULL != nodes[index_node].conf))
335  {
337  nodes[index_node].conf = NULL;
338  }
339 
340  h = nodes[index_node].handle;
341  gh = nodes[index_node].gh;
342 
343  if (NULL != gh)
344  {
346  gh = NULL;
347  }
348  if (GNUNET_YES == watch)
349  {
351  GNUNET_OK ==
353  subsystem,
354  name,
355  &printer_watch,
356  &nodes[index_node].index_node));
357  }
358 
359  if (NULL != h)
360  {
362  h = NULL;
363  }
364 
367  {
370  }
371 }
372 
378 static void
380 {
383 }
384 
393 static void
394 continuation_print(void *cls, int success)
395 {
396  const unsigned index_node = *(unsigned *)cls;
397 
398  nodes[index_node].gh = NULL;
399  if (GNUNET_OK != success)
400  {
401  if (NULL == remote_host)
402  fprintf(stderr, "%s", _("Failed to obtain statistics.\n"));
403  else
404  fprintf(stderr,
405  _("Failed to obtain statistics from host `%s:%llu'\n"),
406  remote_host,
407  remote_port);
408  ret = 1;
409  }
410  if (NULL != nodes[index_node].shutdown_task)
411  {
412  GNUNET_SCHEDULER_cancel(nodes[index_node].shutdown_task);
414  }
415  GNUNET_SCHEDULER_add_now(clean_node, &nodes[index_node].index_node);
416  num_nodes_ready++;
417  if (num_nodes_ready == num_nodes)
418  {
420  }
421 }
422 
430 static void
431 cleanup(void *cls, int success)
432 {
433  for (unsigned i = 0; i < num_nodes; i++)
434  {
435  nodes[i].gh = NULL;
436  }
437  if (GNUNET_OK != success)
438  {
439  if (NULL == remote_host)
440  fprintf(stderr, "%s", _("Failed to obtain statistics.\n"));
441  else
442  fprintf(stderr,
443  _("Failed to obtain statistics from host `%s:%llu'\n"),
444  remote_host,
445  remote_port);
446  ret = 1;
447  }
449 }
450 
463 static int
465  const char *subsystem,
466  const char *name,
467  uint64_t value,
468  int is_persistent)
469 {
470  const unsigned index_node = *(unsigned *)cls;
471  struct GNUNET_HashCode *key;
472  struct GNUNET_HashCode hc;
473  char *subsys_name;
474  unsigned len_subsys_name;
475  struct ValueSet *value_set;
476 
477  len_subsys_name = strlen(subsystem) + 3 + strlen(name) + 1;
478  subsys_name = GNUNET_malloc(len_subsys_name);
479  sprintf(subsys_name, "%s---%s", subsystem, name);
480  key = &hc;
481  GNUNET_CRYPTO_hash(subsys_name, len_subsys_name, key);
482  GNUNET_free(subsys_name);
484  {
485  value_set = GNUNET_CONTAINER_multihashmap_get(values, key);
486  }
487  else
488  {
489  value_set = new_value_set(subsystem, name, num_nodes, is_persistent);
490  }
491  value_set->values[index_node] = value;
494  values,
495  key,
496  value_set,
498  return GNUNET_OK;
499 }
500 
506 static void
507 main_task(void *cls)
508 {
509  unsigned index_node = *(unsigned *)cls;
511 
512  if (set_value)
513  {
514  if (NULL == subsystem)
515  {
516  fprintf(stderr, "%s", _("Missing argument: subsystem \n"));
517  ret = 1;
518  return;
519  }
520  if (NULL == name)
521  {
522  fprintf(stderr, "%s", _("Missing argument: name\n"));
523  ret = 1;
524  return;
525  }
527  if (NULL == nodes[index_node].handle)
528  {
529  ret = 1;
530  return;
531  }
532  GNUNET_STATISTICS_set(nodes[index_node].handle,
533  name,
534  (uint64_t)set_val,
535  persistent);
536  GNUNET_STATISTICS_destroy(nodes[index_node].handle, GNUNET_YES);
537  nodes[index_node].handle = NULL;
538  return;
539  }
540  if (NULL == (nodes[index_node].handle =
541  GNUNET_STATISTICS_create("gnunet-statistics", cfg)))
542  {
543  ret = 1;
544  return;
545  }
546  if (GNUNET_NO == watch)
547  {
548  if (NULL == (nodes[index_node].gh =
549  GNUNET_STATISTICS_get(nodes[index_node].handle,
550  subsystem,
551  name,
553  &collector,
554  &nodes[index_node].index_node)))
555  cleanup(nodes[index_node].handle, GNUNET_SYSERR);
556  }
557  else
558  {
559  if ((NULL == subsystem) || (NULL == name))
560  {
561  printf(_("No subsystem or name given\n"));
563  nodes[index_node].handle = NULL;
564  ret = 1;
565  return;
566  }
567  if (GNUNET_OK != GNUNET_STATISTICS_watch(nodes[index_node].handle,
568  subsystem,
569  name,
570  &printer_watch,
571  &nodes[index_node].index_node))
572  {
573  fprintf(stderr, _("Failed to initialize watch routine\n"));
575  GNUNET_SCHEDULER_add_now(&clean_node, &nodes[index_node].index_node);
576  return;
577  }
578  }
580  GNUNET_SCHEDULER_add_shutdown(&clean_node, &nodes[index_node].index_node);
581 }
582 
594 static int
595 iter_check_config(void *cls, const char *filename)
596 {
597  if (0 == strncmp(GNUNET_STRINGS_get_short_name(filename), "config", 6))
598  {
599  /* Found the config - stop iteration successfully */
602  nodes[num_nodes - 1].index_node = num_nodes - 1;
603  if (GNUNET_OK !=
605  {
606  fprintf(stderr, "Failed loading config `%s'\n", filename);
607  return GNUNET_SYSERR;
608  }
609  return GNUNET_NO;
610  }
611  else
612  {
613  /* Continue iteration */
614  return GNUNET_OK;
615  }
616 }
617 
631 static int
632 iter_testbed_path(void *cls, const char *filename)
633 {
634  unsigned index_node;
635 
636  GNUNET_assert(NULL != filename);
637  if (1 == sscanf(GNUNET_STRINGS_get_short_name(filename), "%u", &index_node))
638  {
639  if (-1 == GNUNET_DISK_directory_scan(filename, iter_check_config, NULL))
640  {
641  /* This is probably no directory for a testbed node
642  * Go on with iteration */
643  return GNUNET_OK;
644  }
645  return GNUNET_OK;
646  }
647  return GNUNET_OK;
648 }
649 
657 static int
659 {
660  int num_dir_entries;
661 
662  num_dir_entries =
663  GNUNET_DISK_directory_scan(path_testbed, iter_testbed_path, NULL);
664  if (-1 == num_dir_entries)
665  {
666  fprintf(stderr, "Failure during scanning directory `%s'\n", path_testbed);
667  return -1;
668  }
669  return 0;
670 }
671 
680 static void
681 run(void *cls,
682  char *const *args,
683  const char *cfgfile,
684  const struct GNUNET_CONFIGURATION_Handle *cfg)
685 {
686  struct GNUNET_CONFIGURATION_Handle *c;
687 
688  c = (struct GNUNET_CONFIGURATION_Handle *)cfg;
690  if (NULL == csv_separator)
691  csv_separator = "";
692  if (NULL != args[0])
693  {
694  if (1 != sscanf(args[0], "%llu", &set_val))
695  {
696  fprintf(stderr, _("Invalid argument `%s'\n"), args[0]);
697  ret = 1;
698  return;
699  }
701  }
702  if (NULL != remote_host)
703  {
704  if (0 == remote_port)
705  {
707  "statistics",
708  "PORT",
709  &remote_port))
710  {
711  fprintf(stderr,
712  _("A port is required to connect to host `%s'\n"),
713  remote_host);
714  return;
715  }
716  }
717  else if (65535 <= remote_port)
718  {
719  fprintf(stderr,
720  _(
721  "A port has to be between 1 and 65535 to connect to host `%s'\n"),
722  remote_host);
723  return;
724  }
725 
726  /* Manipulate configuration */
727  GNUNET_CONFIGURATION_set_value_string(c, "statistics", "UNIXPATH", "");
729  "statistics",
730  "HOSTNAME",
731  remote_host);
733  "statistics",
734  "PORT",
735  remote_port);
736  }
737  if (NULL == path_testbed)
738  {
741  nodes[0].index_node = 0;
742  nodes[0].conf = c;
744  }
745  else
746  {
747  if (GNUNET_YES == watch)
748  {
749  printf(
750  _("Not able to watch testbed nodes (yet - feel free to implement)\n"));
751  ret = 1;
752  return;
753  }
756  {
757  return;
758  }
759  /* For each config/node collect statistics */
760  for (unsigned i = 0; i < num_nodes; i++)
761  {
763  }
764  }
765 }
766 
767 
775 int
776 main(int argc, char *const *argv)
777 {
778  struct GNUNET_GETOPT_CommandLineOption options[] =
780  'n',
781  "name",
782  "NAME",
783  gettext_noop("limit output to statistics for the given NAME"),
784  &name),
785 
787  "persistent",
788  gettext_noop(
789  "make the value being set persistent"),
790  &persistent),
791 
793  "subsystem",
794  "SUBSYSTEM",
795  gettext_noop(
796  "limit output to the given SUBSYSTEM"),
797  &subsystem),
798 
800  "csv-separator",
801  "CSV_SEPARATOR",
802  gettext_noop("use as csv separator"),
803  &csv_separator),
804 
806  't',
807  "testbed",
808  "TESTBED",
809  gettext_noop("path to the folder containing the testbed data"),
810  &path_testbed),
811 
813  "quiet",
814  gettext_noop(
815  "just print the statistics value"),
816  &quiet),
817 
819  "watch",
820  gettext_noop("watch value continuously"),
821  &watch),
822 
824  "remote",
825  "REMOTE",
826  gettext_noop("connect to remote host"),
827  &remote_host),
828 
830  "port",
831  "PORT",
832  gettext_noop("port for remote host"),
833  &remote_port),
834 
836 
837  remote_port = 0;
838  remote_host = NULL;
839  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
840  return 2;
841 
842  ret = (GNUNET_OK ==
843  GNUNET_PROGRAM_run(argc,
844  argv,
845  "gnunet-statistics [options [value]]",
846  gettext_noop(
847  "Print statistics about GNUnet operations."),
848  options,
849  &run,
850  NULL))
851  ? ret
852  : 1;
854  GNUNET_free((void *)argv);
855  return ret;
856 }
857 
858 /* end of gnunet-statistics.c */
char * subsystem
Subsystem of the valueset.
static char * remote_host
Remote host.
static unsigned long long remote_port
Remote host&#39;s port.
static char * subsystem
Set to subsystem that we&#39;re going to get stats for (or NULL for all).
Set of values for a combination of subsystem and name.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
static int collector(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Iterate over statistics values and store them in values.
static struct GNUNET_CONTAINER_MultiHashMap * values
Collection of all values (represented with ValueSet).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1284
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1439
static char * csv_separator
Separator string for csv.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
static int iter_check_config(void *cls, const char *filename)
Iter over content of a node&#39;s directory to check for existence of a config file.
Representation of all (testbed) nodes.
int is_persistent
Persistence of the values.
void GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
Set a configuration value that should be a number.
struct GNUNET_STATISTICS_GetHandle * gh
Handle for pending GET operation.
Linked list of things we still need to do.
#define GNUNET_NO
Definition: gnunet_common.h:78
static unsigned long long set_val
Value to set.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
static char * path_testbed
The path of the testbed data.
static void print_finish(void *cls)
Print and shutdown.
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:909
static unsigned int num_values
int GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL)...
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run by the scheduler.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
Handle for the service.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Internal representation of the hash map.
uint64_t * values
The values.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
static char * name
Set to the specific stat value that we are after (or NULL for all).
int GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
static int ret
Final status code.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void continuation_print(void *cls, int success)
Called once all statistic values are available.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_filename(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a filename (automatically path expanded).
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
static char * value
Value of the record to add/remove.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
int main(int argc, char *const *argv)
The main function to obtain statistics in GNUnet.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static char * filename
struct GNUNET_CONFIGURATION_Handle * conf
Configuration handle for this node.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
A 512-bit hashcode.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
const char * GNUNET_STRINGS_get_short_name(const char *filename)
"man basename" Returns a pointer to a part of filename (allocates nothing)!
Definition: strings.c:776
There must only be one value per key; storing a value should fail if a value under the same key alrea...
static unsigned num_nodes
Number of configurations of all (testbed) nodes.
struct GNUNET_HashCode key
The key used in the DHT.
static int watch
Watch value continuously.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct Node * nodes
static void cleanup(void *cls, int success)
Function called last by the statistics code.
static int set_value
Set operation.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_ulong(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned long long *val)
Allow user to specify an unsigned long long.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
unsigned index_node
Index of the node in this array.
static struct ValueSet * new_value_set(const char *subsystem, const char *name, unsigned num_values, int is_persistent)
Create a new ValueSet.
static int persistent
Make the value that is being set persistent.
static int printer(void *cls, const struct GNUNET_HashCode *key, void *value)
Print the (collected) values.
struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for shutdown task for this node.
int GNUNET_STATISTICS_watch_cancel(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
Stop watching statistics from the peer.
struct GNUNET_STATISTICS_GetHandle * GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
Get statistic from the peer.
configuration data
Definition: configuration.c:83
static int iter_testbed_path(void *cls, const char *filename)
Iterates over filenames in testbed directory.
int GNUNET_STATISTICS_watch(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
Watch statistics from the peer (be notified whenever they change).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
void * cls
Closure for proc and cont.
Entry in list of pending tasks.
Definition: scheduler.c:131
static int num_nodes_ready
Number of nodes that have their values ready.
static void clean_node(void *cls)
Clean all data structures related to given node.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
static int num_nodes_ready_shutdown
Number of nodes that have their values ready.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_STATISTICS_Handle * handle
Statistics handle nodes.
static void main_task(void *cls)
Main task that does the actual work.
static int quiet
Quiet mode.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:741
static int discover_testbed_nodes(const char *path_testbed)
Count the number of nodes running in the testbed.
char * name
Name of the valueset.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_malloc(size)
Wrapper around malloc.
static int printer_watch(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Callback function to process statistic values.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956