tool to obtain statistics More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-statistics.c:

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 subsys, const char new_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 subsys, const char *print_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 subsys, const char *coll_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_discovered)
	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_opt
	Separator string for csv. More...

static const 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 *	subsys,
		const char *	new_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 185 of file gnunet-statistics.c.

{
  struct ValueSet *value_set;
 
  value_set = GNUNET_new (struct ValueSet);
  value_set->subsystem = GNUNET_strdup (subsys);
  value_set->name = GNUNET_strdup (new_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, ValueSet::name, persistent, 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 214 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 *	subsys,
		const char *	print_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 281 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,
               subsys,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (print_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,
               subsys,
               csv_separator,
               (0 == strlen (csv_separator) ? "" : "\""),   /* quotes if csv */
               _ (print_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, quiet, 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 339 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, 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 387 of file gnunet-statistics.c.

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

References csv_separator_opt, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, 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 407 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 450 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 *	subsys,
		const char *	coll_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 484 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 (subsys) + 3 + strlen (coll_name) + 1;
  subsys_name = GNUNET_malloc (len_subsys_name);
  sprintf (subsys_name, "%s---%s", subsys, coll_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 (subsys, coll_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, new_value_set(), num_nodes, 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 528 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(), 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, Node::handle, 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 617 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 (
      GNUNET_OS_project_data_gnunet ());
    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_OS_project_data_gnunet(), 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 656 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_discovered )

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 688 of file gnunet-statistics.c.

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

References GNUNET_DISK_directory_scan(), and iter_testbed_path().

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 716 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 815 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_opt),
    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;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                             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);
  return ret;
}

References csv_separator_opt, gettext_noop, GNUNET_array_grow, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_filename(), GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_ulong(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), 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 35 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 40 of file gnunet-statistics.c.

Referenced by clean_node(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_get(), GNUNET_STATISTICS_watch(), GNUNET_STATISTICS_watch_cancel(), handle_uri(), main(), main_task(), process_stats(), run(), and stats_iterator().

◆ path_testbed

char* path_testbed

static

The path of the testbed data.

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

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

◆ name

char* name

static

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

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

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

◆ persistent

int persistent

static

Make the value that is being set persistent.

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

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

◆ watch

int watch

static

Watch value continuously.

Definition at line 60 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 65 of file gnunet-statistics.c.

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

◆ csv_separator_opt

char* csv_separator_opt

static

Separator string for csv.

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

Referenced by main(), and print_finish().

◆ csv_separator

const char* csv_separator

static

Separator string for csv.

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

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

◆ remote_host

char* remote_host

static

Remote host.

Definition at line 80 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 85 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 90 of file gnunet-statistics.c.

Referenced by main_task(), and run().

◆ set_value

int set_value

static

Set operation.

Definition at line 95 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 130 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 162 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 167 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 172 of file gnunet-statistics.c.

Referenced by clean_node().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ new_value_set()

◆ printer()

◆ printer_watch()

◆ clean_node()

◆ print_finish()

◆ continuation_print()

◆ cleanup()

◆ collector()

◆ main_task()

◆ iter_check_config()

◆ iter_testbed_path()

◆ discover_testbed_nodes()

◆ run()

◆ main()

Variable Documentation

◆ ret

◆ subsystem

◆ path_testbed

◆ name

◆ persistent

◆ watch

◆ quiet

◆ csv_separator_opt

◆ csv_separator

◆ remote_host

◆ remote_port

◆ set_val

◆ set_value

◆ nodes

◆ num_nodes

◆ values

◆ num_nodes_ready

◆ num_nodes_ready_shutdown