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 ValueSet *	new_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 Node *	nodes
static unsigned	num_nodes
	Number of configurations of all (testbed) nodes. More...
static struct GNUNET_CONTAINER_MultiHashMap *	values
	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

subsystem	Subsystem of the valueset.
name	Name of the valueset.
num_values	Number of values in valueset - number of peers.
is_persistent	Persistence status of values.

Returns

Newly allocated ValueSet.

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

{
  struct ValueSet *value_set;
 
  value_set = GNUNET_new (struct ValueSet);
  value_set->subsystem = GNUNET_strdup (subsystem);
  value_set->name = GNUNET_strdup (name);
  value_set->values = GNUNET_new_array (num_values,
                                        uint64_t);
  value_set->is_persistent = persistent;
  return value_set;
}

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

cls	Closure - unused
key	GNUNET_HashCode key of GNUNET_CONTAINER_MultiHashMap iterator - unused
value	Values represented as ValueSet.

Returns

GNUNET_YES - continue iteration.

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

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str;
  struct ValueSet *value_set = value;
 
  if (quiet == GNUNET_NO)
  {
    if (GNUNET_YES == watch)
    {
      now_str = GNUNET_STRINGS_absolute_time_to_string (now);
      fprintf (stdout,
               "%24s%s %s%s%12s%s %s%50s%s%s ",
               now_str,
               csv_separator,
               value_set->is_persistent ? "!" : " ",
               csv_separator,
               value_set->subsystem,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (value_set->name),
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               (0 == strlen (csv_separator) ? ":" : csv_separator));
    }
    else
    {
      fprintf (stdout,
               "%s%s%12s%s %s%50s%s%s ",
               value_set->is_persistent ? "!" : " ",
               csv_separator,
               value_set->subsystem,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (value_set->name),
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               (0 == strlen (csv_separator) ? ":" : csv_separator));
    }
  }
  for (unsigned i = 0; i < num_nodes; i++)
  {
    fprintf (stdout,
             "%16llu%s",
             (unsigned long long) value_set->values[i],
             csv_separator);
  }
  fprintf (stdout, "\n");
  GNUNET_free (value_set->subsystem);
  GNUNET_free (value_set->name);
  GNUNET_free (value_set->values);
  GNUNET_free (value_set);
  return GNUNET_YES;
}

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

cls	closure
subsystem	name of subsystem that created the statistic
name	the name of the datum
value	the current value
is_persistent	GNUNET_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.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  const char *now_str;
 
  if (quiet == GNUNET_NO)
  {
    if (GNUNET_YES == watch)
    {
      now_str = GNUNET_STRINGS_absolute_time_to_string (now);
      fprintf (stdout,
               "%24s%s %s%s%12s%s %s%50s%s%s %16llu\n",
               now_str,
               csv_separator,
               is_persistent ? "!" : " ",
               csv_separator,
               subsystem,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (name),
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               (0 == strlen (csv_separator) ? ":" : csv_separator),
               (unsigned long long) value);
    }
    else
    {
      fprintf (stdout,
               "%s%s%12s%s %s%50s%s%s %16llu\n",
               is_persistent ? "!" : " ",
               csv_separator,
               subsystem,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (name),
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               (0 == strlen (csv_separator) ? ":" : csv_separator),
               (unsigned long long) value);
    }
  }
  else
    fprintf (stdout, "%llu\n", (unsigned long long) value);
 
  return GNUNET_OK;
}

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

cls	the index of the node

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

{
  const unsigned index_node = *(unsigned *) cls;
  struct GNUNET_STATISTICS_Handle *h;
  struct GNUNET_STATISTICS_GetHandle *gh;
 
  if ((NULL != path_testbed) && /* were issued with -t <testbed-path> option */
      (NULL != nodes[index_node].conf))
  {
    GNUNET_CONFIGURATION_destroy (nodes[index_node].conf);
    nodes[index_node].conf = NULL;
  }
 
  h = nodes[index_node].handle;
  gh = nodes[index_node].gh;
 
  if (NULL != gh)
  {
    GNUNET_STATISTICS_get_cancel (gh);
    gh = NULL;
  }
  if (GNUNET_YES == watch)
  {
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_STATISTICS_watch_cancel (h,
                                      subsystem,
                                      name,
                                      &printer_watch,
                                      &nodes[index_node].index_node));
  }
 
  if (NULL != h)
  {
    GNUNET_STATISTICS_destroy (h, GNUNET_NO);
    h = NULL;
  }
 
  num_nodes_ready_shutdown++;
}

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

cls

unused

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

{
  GNUNET_CONTAINER_multihashmap_iterate (values,
                                         &printer,
                                         NULL);
  GNUNET_CONTAINER_multihashmap_destroy (values);
  GNUNET_SCHEDULER_shutdown ();
}

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

cls	Closure - The index of the node.
success	Whether statistics were obtained successfully.

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

{
  const unsigned index_node = *(unsigned *) cls;
 
  nodes[index_node].gh = NULL;
  if (GNUNET_OK != success)
  {
    if (NULL == remote_host)
      fprintf (stderr,
               "%s",
               _ ("Failed to obtain statistics.\n"));
    else
      fprintf (stderr,
               _ ("Failed to obtain statistics from host `%s:%llu'\n"),
               remote_host,
               remote_port);
    ret = 1;
  }
  if (NULL != nodes[index_node].shutdown_task)
  {
    GNUNET_SCHEDULER_cancel (nodes[index_node].shutdown_task);
    nodes[index_node].shutdown_task = NULL;
  }
  GNUNET_SCHEDULER_add_now (&clean_node,
                            &nodes[index_node].index_node);
  num_nodes_ready++;
  if (num_nodes_ready == num_nodes)
  {
    GNUNET_SCHEDULER_add_now (&print_finish,
                              NULL);
  }
}

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

cls	closure
success	GNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

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

{
  for (unsigned i = 0; i < num_nodes; i++)
  {
    nodes[i].gh = NULL;
  }
  if (GNUNET_OK != success)
  {
    if (NULL == remote_host)
      fprintf (stderr, "%s", _ ("Failed to obtain statistics.\n"));
    else
      fprintf (stderr,
               _ ("Failed to obtain statistics from host `%s:%llu'\n"),
               remote_host,
               remote_port);
    ret = 1;
  }
  GNUNET_SCHEDULER_shutdown ();
}

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

cls	Cosure - Node index.
subsystem	Subsystem of the value.
name	Name of the value.
value	Value itself.
is_persistent	Persistence.

Returns

GNUNET_OK - continue.

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

{
  const unsigned index_node = *(unsigned *) cls;
  struct GNUNET_HashCode *key;
  struct GNUNET_HashCode hc;
  char *subsys_name;
  unsigned len_subsys_name;
  struct ValueSet *value_set;
 
  len_subsys_name = strlen (subsystem) + 3 + strlen (name) + 1;
  subsys_name = GNUNET_malloc (len_subsys_name);
  sprintf (subsys_name, "%s---%s", subsystem, name);
  key = &hc;
  GNUNET_CRYPTO_hash (subsys_name, len_subsys_name, key);
  GNUNET_free (subsys_name);
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (values, key))
  {
    value_set = GNUNET_CONTAINER_multihashmap_get (values, key);
  }
  else
  {
    value_set = new_value_set (subsystem, name, num_nodes, is_persistent);
  }
  value_set->values[index_node] = value;
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_put (
                   values,
                   key,
                   value_set,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return GNUNET_OK;
}

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

cls	closure with our configuration

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

{
  unsigned index_node = *(unsigned *) cls;
  const struct GNUNET_CONFIGURATION_Handle *cfg = nodes[index_node].conf;
 
  if (set_value)
  {
    if (NULL == subsystem)
    {
      fprintf (stderr, "%s", _ ("Missing argument: subsystem \n"));
      ret = 1;
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr, "%s", _ ("Missing argument: name\n"));
      ret = 1;
      return;
    }
    nodes[index_node].handle = GNUNET_STATISTICS_create (subsystem, cfg);
    if (NULL == nodes[index_node].handle)
    {
      ret = 1;
      return;
    }
    GNUNET_STATISTICS_set (nodes[index_node].handle,
                           name,
                           (uint64_t) set_val,
                           persistent);
    GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_YES);
    nodes[index_node].handle = NULL;
    return;
  }
  if (NULL == (nodes[index_node].handle =
                 GNUNET_STATISTICS_create ("gnunet-statistics", cfg)))
  {
    ret = 1;
    return;
  }
  if (GNUNET_NO == watch)
  {
    if (NULL == (nodes[index_node].gh =
                   GNUNET_STATISTICS_get (nodes[index_node].handle,
                                          subsystem,
                                          name,
                                          &continuation_print,
                                          &collector,
                                          &nodes[index_node].index_node)))
      cleanup (nodes[index_node].handle, GNUNET_SYSERR);
  }
  else
  {
    if ((NULL == subsystem) || (NULL == name))
    {
      printf (_ ("No subsystem or name given\n"));
      GNUNET_STATISTICS_destroy (nodes[index_node].handle, GNUNET_NO);
      nodes[index_node].handle = NULL;
      ret = 1;
      return;
    }
    if (GNUNET_OK != GNUNET_STATISTICS_watch (nodes[index_node].handle,
                                              subsystem,
                                              name,
                                              &printer_watch,
                                              &nodes[index_node].index_node))
    {
      fprintf (stderr, _ ("Failed to initialize watch routine\n"));
      nodes[index_node].shutdown_task =
        GNUNET_SCHEDULER_add_now (&clean_node, &nodes[index_node].index_node);
      return;
    }
  }
  nodes[index_node].shutdown_task =
    GNUNET_SCHEDULER_add_shutdown (&clean_node, &nodes[index_node].index_node);
}

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

cls	pointer to indicate success
filename	filename inside the directory of the potential node

Returns

to continue iteration or not to

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

{
  if (0 == strncmp (GNUNET_STRINGS_get_short_name (filename), "config", 6))
  {
    /* Found the config - stop iteration successfully */
    GNUNET_array_grow (nodes, num_nodes, num_nodes + 1);
    nodes[num_nodes - 1].conf = GNUNET_CONFIGURATION_create ();
    nodes[num_nodes - 1].index_node = num_nodes - 1;
    if (GNUNET_OK !=
        GNUNET_CONFIGURATION_load (nodes[num_nodes - 1].conf, filename))
    {
      fprintf (stderr, "Failed loading config `%s'\n", filename);
      return GNUNET_SYSERR;
    }
    return GNUNET_NO;
  }
  else
  {
    /* Continue iteration */
    return GNUNET_OK;
  }
}

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

cls	counter of nodes
filename	full path of the file in testbed

Returns

status whether to continue iteration

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

{
  unsigned index_node;
 
  GNUNET_assert (NULL != filename);
  if (1 == sscanf (GNUNET_STRINGS_get_short_name (filename),
                   "%u",
                   &index_node))
  {
    if (-1 == GNUNET_DISK_directory_scan (filename,
                                          iter_check_config,
                                          NULL))
    {
      /* This is probably no directory for a testbed node
       * Go on with iteration */
      return GNUNET_OK;
    }
    return GNUNET_OK;
  }
  return GNUNET_OK;
}

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_testbed

path to the testbed data

Returns

number of running nodes

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

{
  int num_dir_entries;
 
  num_dir_entries =
    GNUNET_DISK_directory_scan (path_testbed,
                                &iter_testbed_path,
                                NULL);
  if (-1 == num_dir_entries)
  {
    fprintf (stderr,
             "Failure during scanning directory `%s'\n",
             path_testbed);
    return -1;
  }
  return 0;
}

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

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

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

{
  struct GNUNET_CONFIGURATION_Handle *c;
 
  c = (struct GNUNET_CONFIGURATION_Handle *) cfg;
  set_value = GNUNET_NO;
  if (NULL == csv_separator)
    csv_separator = "";
  if (NULL != args[0])
  {
    if (1 != sscanf (args[0], "%llu", &set_val))
    {
      fprintf (stderr, _ ("Invalid argument `%s'\n"), args[0]);
      ret = 1;
      return;
    }
    set_value = GNUNET_YES;
  }
  if (NULL != remote_host)
  {
    if (0 == remote_port)
    {
      if (GNUNET_SYSERR ==
          GNUNET_CONFIGURATION_get_value_number (cfg,
                                                 "statistics",
                                                 "PORT",
                                                 &remote_port))
      {
        fprintf (stderr,
                 _ ("A port is required to connect to host `%s'\n"),
                 remote_host);
        return;
      }
    }
    else if (65535 <= remote_port)
    {
      fprintf (stderr,
               _ (
                 "A port has to be between 1 and 65535 to connect to host `%s'\n"),
               remote_host);
      return;
    }
 
    /* Manipulate configuration */
    GNUNET_CONFIGURATION_set_value_string (c,
                                           "statistics",
                                           "UNIXPATH",
                                           "");
    GNUNET_CONFIGURATION_set_value_string (c,
                                           "statistics",
                                           "HOSTNAME",
                                           remote_host);
    GNUNET_CONFIGURATION_set_value_number (c,
                                           "statistics",
                                           "PORT",
                                           remote_port);
  }
  if (NULL == path_testbed)
  {
    values = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
    GNUNET_array_grow (nodes, num_nodes, 1);
    nodes[0].index_node = 0;
    nodes[0].conf = c;
    GNUNET_SCHEDULER_add_now (&main_task, &nodes[0].index_node);
  }
  else
  {
    if (GNUNET_YES == watch)
    {
      printf (
        _ ("Not able to watch testbed nodes (yet - feel free to implement)\n"));
      ret = 1;
      return;
    }
    values = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
    if (-1 == discover_testbed_nodes (path_testbed))
    {
      return;
    }
    /* For each config/node collect statistics */
    for (unsigned i = 0; i < num_nodes; i++)
    {
      GNUNET_SCHEDULER_add_now (&main_task, &nodes[i].index_node);
    }
  }
}

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

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

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

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('n',
                                 "name",
                                 "NAME",
                                 gettext_noop (
                                   "limit output to statistics for the given NAME"),
                                 &name),
    GNUNET_GETOPT_option_flag ('p',
                               "persistent",
                               gettext_noop (
                                 "make the value being set persistent"),
                               &persistent),
    GNUNET_GETOPT_option_string ('s',
                                 "subsystem",
                                 "SUBSYSTEM",
                                 gettext_noop (
                                   "limit output to the given SUBSYSTEM"),
                                 &subsystem),
    GNUNET_GETOPT_option_string ('S',
                                 "csv-separator",
                                 "CSV_SEPARATOR",
                                 gettext_noop ("use as csv separator"),
                                 &csv_separator),
    GNUNET_GETOPT_option_filename ('t',
                                   "testbed",
                                   "TESTBED",
                                   gettext_noop (
                                     "path to the folder containing the testbed data"),
                                   &path_testbed),
    GNUNET_GETOPT_option_flag ('q',
                               "quiet",
                               gettext_noop (
                                 "just print the statistics value"),
                               &quiet),
    GNUNET_GETOPT_option_flag ('w',
                               "watch",
                               gettext_noop ("watch value continuously"),
                               &watch),
    GNUNET_GETOPT_option_string ('r',
                                 "remote",
                                 "REMOTE",
                                 gettext_noop ("connect to remote host"),
                                 &remote_host),
    GNUNET_GETOPT_option_ulong ('o',
                                "port",
                                "PORT",
                                gettext_noop ("port for remote host"),
                                &remote_port),
    GNUNET_GETOPT_OPTION_END
  };
 
  remote_port = 0;
  remote_host = NULL;
  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return 2;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (argc,
                             argv,
                             "gnunet-statistics [options [value]]",
                             gettext_noop (
                               "Print statistics about GNUnet operations."),
                             options,
                             &run,
                             NULL))
        ? ret
        : 1;
  GNUNET_array_grow (nodes,
                     num_nodes,
                     0);
  GNUNET_free (remote_host);
  GNUNET_free_nz ((void *) argv);
  return ret;
}

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

Set to subsystem that we're going to get stats for (or NULL for all).

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

Referenced by clean_node(), collector(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_get(), GNUNET_STATISTICS_watch(), GNUNET_STATISTICS_watch_cancel(), GNUNET_TESTBED_get_statistics(), handle_uri(), iterator_cb(), main(), main_task(), new_value_set(), printer_watch(), process_stats(), run(), stat_iterator(), statistics_cb(), statistics_result(), and stats_iterator().

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

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

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().