GNUnet  0.11.x
Data Structures | Functions | Variables
gnunet-statistics.c File Reference

tool to obtain statistics More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "statistics.h"
Include dependency graph for gnunet-statistics.c:

Go to the source code of this file.

Data Structures

struct  Node
 Representation of all (testbed) nodes. More...
 
struct  ValueSet
 Set of values for a combination of subsystem and name. More...
 

Functions

static struct ValueSetnew_value_set (const char *subsystem, const char *name, unsigned num_values, int is_persistent)
 Create a new ValueSet. More...
 
static int printer (void *cls, const struct GNUNET_HashCode *key, void *value)
 Print the (collected) values. More...
 
static int printer_watch (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
 Callback function to process statistic values. More...
 
static void clean_node (void *cls)
 Clean all data structures related to given node. More...
 
static void print_finish (void *cls)
 Print and shutdown. More...
 
static void continuation_print (void *cls, int success)
 Called once all statistic values are available. More...
 
static void cleanup (void *cls, int success)
 Function called last by the statistics code. More...
 
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. More...
 
static void main_task (void *cls)
 Main task that does the actual work. More...
 
static int iter_check_config (void *cls, const char *filename)
 Iter over content of a node's directory to check for existence of a config file. More...
 
static int iter_testbed_path (void *cls, const char *filename)
 Iterates over filenames in testbed directory. More...
 
static int discover_testbed_nodes (const char *path_testbed)
 Count the number of nodes running in the testbed. More...
 
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. More...
 
int main (int argc, char *const *argv)
 The main function to obtain statistics in GNUnet. More...
 

Variables

static int ret
 Final status code. More...
 
static char * subsystem
 Set to subsystem that we're going to get stats for (or NULL for all). More...
 
static char * path_testbed
 The path of the testbed data. More...
 
static char * name
 Set to the specific stat value that we are after (or NULL for all). More...
 
static int persistent
 Make the value that is being set persistent. More...
 
static int watch
 Watch value continuously. More...
 
static int quiet
 Quiet mode. More...
 
static char * csv_separator
 Separator string for csv. More...
 
static char * remote_host
 Remote host. More...
 
static unsigned long long remote_port
 Remote host's port. More...
 
static unsigned long long set_val
 Value to set. More...
 
static int set_value
 Set operation. More...
 
static struct Nodenodes
 
static unsigned num_nodes
 Number of configurations of all (testbed) nodes. More...
 
static struct GNUNET_CONTAINER_MultiHashMapvalues
 Collection of all values (represented with ValueSet). More...
 
static int num_nodes_ready
 Number of nodes that have their values ready. More...
 
static int num_nodes_ready_shutdown
 Number of nodes that have their values ready. More...
 

Detailed Description

tool to obtain statistics

Author
Christian Grothoff
Igor Wronsky

Definition in file gnunet-statistics.c.

Function Documentation

◆ new_value_set()

static struct ValueSet* new_value_set ( const char *  subsystem,
const char *  name,
unsigned  num_values,
int  is_persistent 
)
static

Create a new ValueSet.

Parameters
subsystemSubsystem of the valueset.
nameName of the valueset.
num_valuesNumber of values in valueset - number of peers.
is_persistentPersistence status of values.
Returns
Newly allocated ValueSet.

Definition at line 181 of file gnunet-statistics.c.

185 {
186  struct ValueSet *value_set;
187 
188  value_set = GNUNET_new (struct ValueSet);
189  value_set->subsystem = GNUNET_strdup (subsystem);
190  value_set->name = GNUNET_strdup (name);
191  value_set->values = GNUNET_new_array (num_values,
192  uint64_t);
193  value_set->is_persistent = persistent;
194  return value_set;
195 }
static unsigned int num_values
static int persistent
Make the value that is being set persistent.
static char * name
Set to the specific stat value that we are after (or NULL for all).
static char * subsystem
Set to subsystem that we're going to get stats for (or NULL for all).
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Set of values for a combination of subsystem and name.
char * name
Name of the valueset.
int is_persistent
Persistence of the values.
char * subsystem
Subsystem of the valueset.
uint64_t * values
The values.

References GNUNET_new, GNUNET_new_array, GNUNET_strdup, ValueSet::is_persistent, name, ValueSet::name, num_values, persistent, subsystem, ValueSet::subsystem, and ValueSet::values.

Referenced by collector().

Here is the caller graph for this function:

◆ printer()

static int printer ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Print the (collected) values.

Implements #GNUNET_CONTAINER_HashMapIterator.

Parameters
clsClosure - unused
keyGNUNET_HashCode key of GNUNET_CONTAINER_MultiHashMap iterator - unused
valueValues represented as ValueSet.
Returns
GNUNET_YES - continue iteration.

Definition at line 210 of file gnunet-statistics.c.

213 {
215  const char *now_str;
216  struct ValueSet *value_set = value;
217 
218  if (quiet == GNUNET_NO)
219  {
220  if (GNUNET_YES == watch)
221  {
223  fprintf (stdout,
224  "%24s%s %s%s%12s%s %s%50s%s%s ",
225  now_str,
227  value_set->is_persistent ? "!" : " ",
229  value_set->subsystem,
231  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
232  _ (value_set->name),
233  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
234  (0 == strlen (csv_separator) ? ":" : csv_separator));
235  }
236  else
237  {
238  fprintf (stdout,
239  "%s%s%12s%s %s%50s%s%s ",
240  value_set->is_persistent ? "!" : " ",
242  value_set->subsystem,
244  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
245  _ (value_set->name),
246  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
247  (0 == strlen (csv_separator) ? ":" : csv_separator));
248  }
249  }
250  for (unsigned i = 0; i < num_nodes; i++)
251  {
252  fprintf (stdout,
253  "%16llu%s",
254  (unsigned long long) value_set->values[i],
255  csv_separator);
256  }
257  fprintf (stdout, "\n");
258  GNUNET_free (value_set->subsystem);
259  GNUNET_free (value_set->name);
260  GNUNET_free (value_set->values);
261  GNUNET_free (value_set);
262  return GNUNET_YES;
263 }
static char * value
Value of the record to add/remove.
static int quiet
Quiet mode.
static char * csv_separator
Separator string for csv.
static int watch
Watch value continuously.
static unsigned num_nodes
Number of configurations of all (testbed) nodes.
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:604
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Time for absolute times used by GNUnet, in microseconds.

References _, csv_separator, GNUNET_free, GNUNET_NO, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, ValueSet::is_persistent, ValueSet::name, num_nodes, quiet, ValueSet::subsystem, value, ValueSet::values, and watch.

Referenced by print_finish().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ printer_watch()

static int printer_watch ( void *  cls,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)
static

Callback function to process statistic values.

Parameters
clsclosure
subsystemname of subsystem that created the statistic
namethe name of the datum
valuethe current value
is_persistentGNUNET_YES if the value is persistent, GNUNET_NO if not
Returns
GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 277 of file gnunet-statistics.c.

282 {
284  const char *now_str;
285 
286  if (quiet == GNUNET_NO)
287  {
288  if (GNUNET_YES == watch)
289  {
291  fprintf (stdout,
292  "%24s%s %s%s%12s%s %s%50s%s%s %16llu\n",
293  now_str,
295  is_persistent ? "!" : " ",
297  subsystem,
299  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
300  _ (name),
301  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
302  (0 == strlen (csv_separator) ? ":" : csv_separator),
303  (unsigned long long) value);
304  }
305  else
306  {
307  fprintf (stdout,
308  "%s%s%12s%s %s%50s%s%s %16llu\n",
309  is_persistent ? "!" : " ",
311  subsystem,
313  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
314  _ (name),
315  (0 == strlen (csv_separator) ? "" : "\""), /* quotes if csv */
316  (0 == strlen (csv_separator) ? ":" : csv_separator),
317  (unsigned long long) value);
318  }
319  }
320  else
321  fprintf (stdout, "%llu\n", (unsigned long long) value);
322 
323  return GNUNET_OK;
324 }
@ GNUNET_OK
Definition: gnunet_common.h:95

References _, csv_separator, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, name, quiet, subsystem, value, and watch.

Referenced by clean_node(), and main_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ clean_node()

static void clean_node ( void *  cls)
static

Clean all data structures related to given node.

Also clears global structures if we are the last node to clean.

Parameters
clsthe index of the node

Definition at line 335 of file gnunet-statistics.c.

336 {
337  const unsigned index_node = *(unsigned *) cls;
338  struct GNUNET_STATISTICS_Handle *h;
340 
341  if ((NULL != path_testbed) && /* were issued with -t <testbed-path> option */
342  (NULL != nodes[index_node].conf))
343  {
344  GNUNET_CONFIGURATION_destroy (nodes[index_node].conf);
345  nodes[index_node].conf = NULL;
346  }
347 
348  h = nodes[index_node].handle;
349  gh = nodes[index_node].gh;
350 
351  if (NULL != gh)
352  {
354  gh = NULL;
355  }
356  if (GNUNET_YES == watch)
357  {
358  GNUNET_assert (
359  GNUNET_OK ==
361  subsystem,
362  name,
363  &printer_watch,
364  &nodes[index_node].index_node));
365  }
366 
367  if (NULL != h)
368  {
370  h = NULL;
371  }
372 
374 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
static char * path_testbed
The path of the testbed data.
static struct Node * nodes
static int printer_watch(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Callback function to process statistic values.
static int num_nodes_ready_shutdown
Number of nodes that have their values ready.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
Linked list of things we still need to do.
Handle for the service.
struct GNUNET_STATISTICS_GetHandle * gh
Handle for pending GET operation.
struct GNUNET_STATISTICS_Handle * handle
Statistics handle nodes.
struct GNUNET_CONFIGURATION_Handle * conf
Configuration handle for this node.

References Node::conf, gh, Node::gh, GNUNET_assert, GNUNET_CONFIGURATION_destroy(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_get_cancel(), GNUNET_STATISTICS_watch_cancel(), GNUNET_YES, h, Node::handle, name, nodes, num_nodes_ready_shutdown, path_testbed, printer_watch(), subsystem, and watch.

Referenced by continuation_print(), and main_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_finish()

static void print_finish ( void *  cls)
static

Print and shutdown.

Parameters
clsunused

Definition at line 383 of file gnunet-statistics.c.

384 {
386  &printer,
387  NULL);
390 }
static struct GNUNET_CONTAINER_MultiHashMap * values
Collection of all values (represented with ValueSet).
static int printer(void *cls, const struct GNUNET_HashCode *key, void *value)
Print the (collected) values.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531

References GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_SCHEDULER_shutdown(), printer(), and values.

Referenced by continuation_print().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ continuation_print()

static void continuation_print ( void *  cls,
int  success 
)
static

Called once all statistic values are available.

Implements GNUNET_STATISTICS_Callback

Parameters
clsClosure - The index of the node.
successWhether statistics were obtained successfully.

Definition at line 402 of file gnunet-statistics.c.

404 {
405  const unsigned index_node = *(unsigned *) cls;
406 
407  nodes[index_node].gh = NULL;
408  if (GNUNET_OK != success)
409  {
410  if (NULL == remote_host)
411  fprintf (stderr,
412  "%s",
413  _ ("Failed to obtain statistics.\n"));
414  else
415  fprintf (stderr,
416  _ ("Failed to obtain statistics from host `%s:%llu'\n"),
417  remote_host,
418  remote_port);
419  ret = 1;
420  }
421  if (NULL != nodes[index_node].shutdown_task)
422  {
424  nodes[index_node].shutdown_task = NULL;
425  }
427  &nodes[index_node].index_node);
428  num_nodes_ready++;
429  if (num_nodes_ready == num_nodes)
430  {
432  NULL);
433  }
434 }
struct GNUNET_SCHEDULER_Task * shutdown_task
static void print_finish(void *cls)
Print and shutdown.
static int ret
Final status code.
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.
static char * remote_host
Remote host.
static unsigned long long remote_port
Remote host's port.
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:1296
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for shutdown task for this node.

References _, clean_node(), GNUNET_STATISTICS_GetHandle::cls, Node::gh, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), nodes, num_nodes, num_nodes_ready, print_finish(), remote_host, remote_port, ret, shutdown_task, and Node::shutdown_task.

Referenced by main_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup()

static void cleanup ( void *  cls,
int  success 
)
static

Function called last by the statistics code.

Parameters
clsclosure
successGNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

Definition at line 445 of file gnunet-statistics.c.

447 {
448  for (unsigned i = 0; i < num_nodes; i++)
449  {
450  nodes[i].gh = NULL;
451  }
452  if (GNUNET_OK != success)
453  {
454  if (NULL == remote_host)
455  fprintf (stderr, "%s", _ ("Failed to obtain statistics.\n"));
456  else
457  fprintf (stderr,
458  _ ("Failed to obtain statistics from host `%s:%llu'\n"),
459  remote_host,
460  remote_port);
461  ret = 1;
462  }
464 }

References _, Node::gh, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), nodes, num_nodes, remote_host, remote_port, and ret.

Referenced by main_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ collector()

static int collector ( void *  cls,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)
static

Iterate over statistics values and store them in values.

They will be printed once all are available.

Parameters
clsCosure - Node index.
subsystemSubsystem of the value.
nameName of the value.
valueValue itself.
is_persistentPersistence.
Returns
GNUNET_OK - continue.

Definition at line 479 of file gnunet-statistics.c.

484 {
485  const unsigned index_node = *(unsigned *) cls;
486  struct GNUNET_HashCode *key;
487  struct GNUNET_HashCode hc;
488  char *subsys_name;
489  unsigned len_subsys_name;
490  struct ValueSet *value_set;
491 
492  len_subsys_name = strlen (subsystem) + 3 + strlen (name) + 1;
493  subsys_name = GNUNET_malloc (len_subsys_name);
494  sprintf (subsys_name, "%s---%s", subsystem, name);
495  key = &hc;
496  GNUNET_CRYPTO_hash (subsys_name, len_subsys_name, key);
497  GNUNET_free (subsys_name);
499  {
501  }
502  else
503  {
505  }
506  value_set->values[index_node] = value;
509  values,
510  key,
511  value_set,
513  return GNUNET_OK;
514 }
struct GNUNET_HashCode key
The key used in the DHT.
static struct ValueSet * new_value_set(const char *subsystem, const char *name, unsigned num_values, int is_persistent)
Create a new ValueSet.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
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).
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.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_malloc(size)
Wrapper around malloc.
A 512-bit hashcode.

References GNUNET_STATISTICS_GetHandle::cls, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_YES, ValueSet::is_persistent, key, name, new_value_set(), num_nodes, subsystem, value, ValueSet::values, and values.

Referenced by main_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ main_task()

static void main_task ( void *  cls)
static

Main task that does the actual work.

Parameters
clsclosure with our configuration

Definition at line 523 of file gnunet-statistics.c.

524 {
525  unsigned index_node = *(unsigned *) cls;
526  const struct GNUNET_CONFIGURATION_Handle *cfg = nodes[index_node].conf;
527 
528  if (set_value)
529  {
530  if (NULL == subsystem)
531  {
532  fprintf (stderr, "%s", _ ("Missing argument: subsystem \n"));
533  ret = 1;
534  return;
535  }
536  if (NULL == name)
537  {
538  fprintf (stderr, "%s", _ ("Missing argument: name\n"));
539  ret = 1;
540  return;
541  }
543  if (NULL == nodes[index_node].handle)
544  {
545  ret = 1;
546  return;
547  }
548  GNUNET_STATISTICS_set (nodes[index_node].handle,
549  name,
550  (uint64_t) set_val,
551  persistent);
553  nodes[index_node].handle = NULL;
554  return;
555  }
556  if (NULL == (nodes[index_node].handle =
557  GNUNET_STATISTICS_create ("gnunet-statistics", cfg)))
558  {
559  ret = 1;
560  return;
561  }
562  if (GNUNET_NO == watch)
563  {
564  if (NULL == (nodes[index_node].gh =
565  GNUNET_STATISTICS_get (nodes[index_node].handle,
566  subsystem,
567  name,
569  &collector,
570  &nodes[index_node].index_node)))
571  cleanup (nodes[index_node].handle, GNUNET_SYSERR);
572  }
573  else
574  {
575  if ((NULL == subsystem) || (NULL == name))
576  {
577  printf (_ ("No subsystem or name given\n"));
579  nodes[index_node].handle = NULL;
580  ret = 1;
581  return;
582  }
583  if (GNUNET_OK != GNUNET_STATISTICS_watch (nodes[index_node].handle,
584  subsystem,
585  name,
586  &printer_watch,
587  &nodes[index_node].index_node))
588  {
589  fprintf (stderr, _ ("Failed to initialize watch routine\n"));
590  nodes[index_node].shutdown_task =
591  GNUNET_SCHEDULER_add_now (&clean_node, &nodes[index_node].index_node);
592  return;
593  }
594  }
595  nodes[index_node].shutdown_task =
596  GNUNET_SCHEDULER_add_shutdown (&clean_node, &nodes[index_node].index_node);
597 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static unsigned long long set_val
Value to set.
static int set_value
Set operation.
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 void continuation_print(void *cls, int success)
Called once all statistic values are available.
static void cleanup(void *cls, int success)
Function called last by the statistics code.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
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,...
Definition: scheduler.c:1331
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
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_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.

References _, cfg, clean_node(), cleanup(), collector(), Node::conf, continuation_print(), gh, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_get(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_watch(), GNUNET_SYSERR, GNUNET_YES, handle, Node::handle, name, nodes, persistent, printer_watch(), ret, set_val, set_value, Node::shutdown_task, subsystem, and watch.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ iter_check_config()

static int iter_check_config ( void *  cls,
const char *  filename 
)
static

Iter over content of a node's directory to check for existence of a config file.

Implements GNUNET_FileNameCallback

Parameters
clspointer to indicate success
filenamefilename inside the directory of the potential node
Returns
to continue iteration or not to

Definition at line 612 of file gnunet-statistics.c.

614 {
615  if (0 == strncmp (GNUNET_STRINGS_get_short_name (filename), "config", 6))
616  {
617  /* Found the config - stop iteration successfully */
620  nodes[num_nodes - 1].index_node = num_nodes - 1;
621  if (GNUNET_OK !=
623  {
624  fprintf (stderr, "Failed loading config `%s'\n", filename);
625  return GNUNET_SYSERR;
626  }
627  return GNUNET_NO;
628  }
629  else
630  {
631  /* Continue iteration */
632  return GNUNET_OK;
633  }
634 }
static char * filename
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
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:626
unsigned index_node
Index of the node in this array.

References Node::conf, filename, GNUNET_array_grow, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_load(), GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_get_short_name(), GNUNET_SYSERR, Node::index_node, nodes, and num_nodes.

Referenced by iter_testbed_path().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ iter_testbed_path()

static int iter_testbed_path ( void *  cls,
const char *  filename 
)
static

Iterates over filenames in testbed directory.

Implements GNUNET_FileNameCallback

Checks if the file is a directory for a testbed node and counts the nodes.

Parameters
clscounter of nodes
filenamefull path of the file in testbed
Returns
status whether to continue iteration

Definition at line 650 of file gnunet-statistics.c.

652 {
653  unsigned index_node;
654 
655  GNUNET_assert (NULL != filename);
656  if (1 == sscanf (GNUNET_STRINGS_get_short_name (filename),
657  "%u",
658  &index_node))
659  {
662  NULL))
663  {
664  /* This is probably no directory for a testbed node
665  * Go on with iteration */
666  return GNUNET_OK;
667  }
668  return GNUNET_OK;
669  }
670  return GNUNET_OK;
671 }
static int iter_check_config(void *cls, const char *filename)
Iter over content of a node's directory to check for existence of a config file.
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814

References filename, GNUNET_assert, GNUNET_DISK_directory_scan(), GNUNET_OK, GNUNET_STRINGS_get_short_name(), and iter_check_config().

Referenced by discover_testbed_nodes().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ discover_testbed_nodes()

static int discover_testbed_nodes ( const char *  path_testbed)
static

Count the number of nodes running in the testbed.

Parameters
path_testbedpath to the testbed data
Returns
number of running nodes

Definition at line 682 of file gnunet-statistics.c.

683 {
684  int num_dir_entries;
685 
686  num_dir_entries =
689  NULL);
690  if (-1 == num_dir_entries)
691  {
692  fprintf (stderr,
693  "Failure during scanning directory `%s'\n",
694  path_testbed);
695  return -1;
696  }
697  return 0;
698 }
static int iter_testbed_path(void *cls, const char *filename)
Iterates over filenames in testbed directory.

References GNUNET_DISK_directory_scan(), iter_testbed_path(), and path_testbed.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
char *const *  args,
const char *  cfgfile,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Main function that will be run by the scheduler.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 710 of file gnunet-statistics.c.

714 {
715  struct GNUNET_CONFIGURATION_Handle *c;
716 
717  c = (struct GNUNET_CONFIGURATION_Handle *) cfg;
719  if (NULL == csv_separator)
720  csv_separator = "";
721  if (NULL != args[0])
722  {
723  if (1 != sscanf (args[0], "%llu", &set_val))
724  {
725  fprintf (stderr, _ ("Invalid argument `%s'\n"), args[0]);
726  ret = 1;
727  return;
728  }
730  }
731  if (NULL != remote_host)
732  {
733  if (0 == remote_port)
734  {
735  if (GNUNET_SYSERR ==
737  "statistics",
738  "PORT",
739  &remote_port))
740  {
741  fprintf (stderr,
742  _ ("A port is required to connect to host `%s'\n"),
743  remote_host);
744  return;
745  }
746  }
747  else if (65535 <= remote_port)
748  {
749  fprintf (stderr,
750  _ (
751  "A port has to be between 1 and 65535 to connect to host `%s'\n"),
752  remote_host);
753  return;
754  }
755 
756  /* Manipulate configuration */
758  "statistics",
759  "UNIXPATH",
760  "");
762  "statistics",
763  "HOSTNAME",
764  remote_host);
766  "statistics",
767  "PORT",
768  remote_port);
769  }
770  if (NULL == path_testbed)
771  {
774  nodes[0].index_node = 0;
775  nodes[0].conf = c;
776  GNUNET_SCHEDULER_add_now (&main_task, &nodes[0].index_node);
777  }
778  else
779  {
780  if (GNUNET_YES == watch)
781  {
782  printf (
783  _ ("Not able to watch testbed nodes (yet - feel free to implement)\n"));
784  ret = 1;
785  return;
786  }
789  {
790  return;
791  }
792  /* For each config/node collect statistics */
793  for (unsigned i = 0; i < num_nodes; i++)
794  {
795  GNUNET_SCHEDULER_add_now (&main_task, &nodes[i].index_node);
796  }
797  }
798 }
static int discover_testbed_nodes(const char *path_testbed)
Count the number of nodes running in the testbed.
static void main_task(void *cls)
Main task that does the actual work.
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.
enum GNUNET_GenericReturnValue 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.
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_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.

References _, consensus-simulation::args, cfg, Node::conf, csv_separator, discover_testbed_nodes(), GNUNET_array_grow, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_YES, Node::index_node, main_task(), nodes, num_nodes, path_testbed, remote_host, remote_port, ret, set_val, set_value, values, and watch.

Referenced by main().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char *const *  argv 
)

The main function to obtain statistics in GNUnet.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 809 of file gnunet-statistics.c.

810 {
813  "name",
814  "NAME",
815  gettext_noop (
816  "limit output to statistics for the given NAME"),
817  &name),
819  "persistent",
820  gettext_noop (
821  "make the value being set persistent"),
822  &persistent),
824  "subsystem",
825  "SUBSYSTEM",
826  gettext_noop (
827  "limit output to the given SUBSYSTEM"),
828  &subsystem),
830  "csv-separator",
831  "CSV_SEPARATOR",
832  gettext_noop ("use as csv separator"),
833  &csv_separator),
835  "testbed",
836  "TESTBED",
837  gettext_noop (
838  "path to the folder containing the testbed data"),
839  &path_testbed),
841  "quiet",
842  gettext_noop (
843  "just print the statistics value"),
844  &quiet),
846  "watch",
847  gettext_noop ("watch value continuously"),
848  &watch),
850  "remote",
851  "REMOTE",
852  gettext_noop ("connect to remote host"),
853  &remote_host),
855  "port",
856  "PORT",
857  gettext_noop ("port for remote host"),
858  &remote_port),
860  };
861 
862  remote_port = 0;
863  remote_host = NULL;
864  if (GNUNET_OK !=
865  GNUNET_STRINGS_get_utf8_args (argc, argv,
866  &argc, &argv))
867  return 2;
868 
869  ret = (GNUNET_OK ==
870  GNUNET_PROGRAM_run (argc,
871  argv,
872  "gnunet-statistics [options [value]]",
873  gettext_noop (
874  "Print statistics about GNUnet operations."),
875  options,
876  &run,
877  NULL))
878  ? ret
879  : 1;
881  num_nodes,
882  0);
884  GNUNET_free_nz ((void *) argv);
885  return ret;
886 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
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.
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).
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.
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.
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.
#define GNUNET_free_nz(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue 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,...
Definition: program.c:364
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
Definition of a command line option.

References csv_separator, gettext_noop, GNUNET_array_grow, GNUNET_free, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_filename(), GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_ulong(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), name, nodes, num_nodes, options, path_testbed, persistent, quiet, remote_host, remote_port, ret, run(), subsystem, and watch.

Here is the call graph for this function:

Variable Documentation

◆ ret

int ret
static

Final status code.

Definition at line 36 of file gnunet-statistics.c.

Referenced by cleanup(), continuation_print(), main(), main_task(), and run().

◆ subsystem

char* subsystem
static

◆ path_testbed

char* path_testbed
static

The path of the testbed data.

Definition at line 46 of file gnunet-statistics.c.

Referenced by clean_node(), discover_testbed_nodes(), main(), and run().

◆ name

char* name
static

Set to the specific stat value that we are after (or NULL for all).

Definition at line 51 of file gnunet-statistics.c.

Referenced by clean_node(), collector(), main(), main_task(), new_value_set(), and printer_watch().

◆ persistent

int persistent
static

Make the value that is being set persistent.

Definition at line 56 of file gnunet-statistics.c.

Referenced by main(), main_task(), and new_value_set().

◆ watch

int watch
static

Watch value continuously.

Definition at line 61 of file gnunet-statistics.c.

Referenced by clean_node(), main(), main_task(), printer(), printer_watch(), run(), and schedule_watch_request().

◆ quiet

int quiet
static

Quiet mode.

Definition at line 66 of file gnunet-statistics.c.

Referenced by main(), printer(), and printer_watch().

◆ csv_separator

char* csv_separator
static

Separator string for csv.

Definition at line 71 of file gnunet-statistics.c.

Referenced by main(), printer(), printer_watch(), and run().

◆ remote_host

char* remote_host
static

Remote host.

Definition at line 76 of file gnunet-statistics.c.

Referenced by cleanup(), continuation_print(), main(), and run().

◆ remote_port

unsigned long long remote_port
static

Remote host's port.

Definition at line 81 of file gnunet-statistics.c.

Referenced by add_services(), cleanup(), continuation_print(), main(), and run().

◆ set_val

unsigned long long set_val
static

Value to set.

Definition at line 86 of file gnunet-statistics.c.

Referenced by main_task(), and run().

◆ set_value

int set_value
static

Set operation.

Definition at line 91 of file gnunet-statistics.c.

Referenced by main_task(), and run().

◆ nodes

struct Node * nodes
static

◆ num_nodes

unsigned num_nodes
static

Number of configurations of all (testbed) nodes.

Definition at line 126 of file gnunet-statistics.c.

Referenced by cleanup(), collector(), continuation_print(), iter_check_config(), main(), printer(), and run().

◆ values

struct GNUNET_CONTAINER_MultiHashMap* values
static

Collection of all values (represented with ValueSet).

Definition at line 158 of file gnunet-statistics.c.

Referenced by collector(), heap_plugin_get_closest(), print_finish(), and run().

◆ num_nodes_ready

int num_nodes_ready
static

Number of nodes that have their values ready.

Definition at line 163 of file gnunet-statistics.c.

Referenced by continuation_print().

◆ num_nodes_ready_shutdown

int num_nodes_ready_shutdown
static

Number of nodes that have their values ready.

Definition at line 168 of file gnunet-statistics.c.

Referenced by clean_node().