gnunet-regex-profiler.c File Reference

Regex profiler for testing distributed regex use. More...

#include <string.h>
#include "platform.h"
#include "gnunet_applications.h"
#include "gnunet_util_lib.h"
#include "regex_internal_lib.h"
#include "gnunet_arm_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_testbed_service.h"

Include dependency graph for gnunet-regex-profiler.c:

Go to the source code of this file.

Data Structures
struct	DLLOperation
	DLL of operations. More...
struct	RegexPeer
	Peer handles. More...

Macros
#define	FIND_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)

Enumerations
enum	State {   STATE_INIT = 0, STATE_SLAVES_STARTING, STATE_PEERS_CREATING, STATE_PEERS_STARTING,   STATE_PEERS_LINKING, STATE_SEARCH_REGEX, STATE_PEERS_DESTROYING, INIT,   CFG_REQUEST_QUEUED, SERVICE_CONNECTED, RC_INIT = 0, RC_LINKED,   RC_PEERS_CREATED, RC_READY, RC_PEERS_SHUTDOWN }
	Available states during profiling. More...

Functions
static void	dht_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
	DHT connect callback. More...
static void *	dht_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	DHT connect adapter. More...
static void	dht_da (void *cls, void *op_result)
	Adapter function called to destroy a connection to the DHT service. More...
static void	stats_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
	Function called by testbed once we are connected to stats service. More...
static void	announce_next_regex (void *cls)
	Start announcing the next regex in the DHT. More...
static void	do_shutdown (void *cls)
	Shutdown nicely. More...
static void	do_abort (void *cls)
	abort task to run on test timed out More...
static void *	stats_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Adapter function called to establish a connection to statistics service. More...
static void	stats_da (void *cls, void *op_result)
	Adapter function called to destroy a connection to statistics service. More...
static int	stats_iterator (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
	Process statistic values. More...
static void	stats_cb (void *cls, int success)
	Stats callback. More...
static void	do_collect_stats (void *cls)
	Task to collect all statistics from all peers, will shutdown the profiler, when done. More...
static void	find_string (void *cls)
	Start searching for the next string in the DHT. More...
static void	regex_found_handler (void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length)
	Method called when we've found a peer that announced a regex that matches our search string. More...
static void	search_timed_out (void *cls)
	Connect by string timeout task. More...
static void	find_timed_out (void *cls)
	Search timed out. More...
static void	daemon_started (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
	Callback called when testbed has started the daemon we asked for. More...
static void	do_announce (void *cls)
	Task to start the daemons on each peer so that the regexes are announced into the DHT. More...
static void	test_master (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers_, struct GNUNET_TESTBED_Peer **testbed_peers, unsigned int links_succeeded, unsigned int links_failed)
	Signature of a main function for a testcase. More...
static void	master_controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
	Function that will be called whenever something in the testbed changes. More...
static int	count_and_separate_strings (char *data, uint64_t data_size, unsigned int str_max)
	Process the text buffer counting the non-empty lines and separating them with NULL characters, for later ease of copy using (as)printf. More...
static int	create_string_array (char *data, uint64_t data_size, char ***strings, unsigned int str_cnt)
	Allocate a string array and fill it with the prefixed strings from a pre-processed, NULL-separated memory region. More...
static int	load_search_strings (const char *filename, char ***strings, unsigned int limit)
	Load search strings from given filename. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	Main function. More...

Variables
static int	in_shutdown
	Set when shutting down to avoid making more queries. More...
static struct RegexPeer *	peers
	The array of peers; we fill this as the peers are given to us by the testbed. More...
static struct GNUNET_TESTBED_HostRegistrationHandle *	reg_handle
	Host registration handle. More...
static struct GNUNET_TESTBED_ControllerProc *	mc_proc
	Handle to the master controller process. More...
static struct GNUNET_TESTBED_Controller *	mc
	Handle to the master controller. More...
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to global configuration. More...
static struct GNUNET_SCHEDULER_Task *	abort_task
	Abort task identifier. More...
static struct GNUNET_SCHEDULER_Task *	register_hosts_task
	Host registration task identifier. More...
static uint64_t	event_mask
	Global event mask for all testbed events. More...
static struct GNUNET_TIME_Absolute	prof_start_time
	The starting time of a profiling step. More...
static struct GNUNET_TIME_Relative	prof_time
	Duration profiling step has taken. More...
static unsigned int	num_peers
	Number of peers to be started by the profiler. More...
static int	result
	Global testing status. More...
enum State	state
	current state of profiling More...
static char *	policy_dir
	Folder where policy files are stored. More...
static char *	hosts_file
	File with hostnames where to execute the test. More...
static char *	strings_file
	File with the strings to look for. More...
static char **	search_strings
	Search strings (num_peers of them). More...
static long long unsigned int	init_parallel_searches
	How many searches are we going to start in parallel. More...
static unsigned int	parallel_searches
	How many searches are running in parallel. More...
static unsigned int	strings_found
	Number of strings found in the published regexes. More...
static unsigned int	next_search
	Index of peer to start next announce/search. More...
static struct GNUNET_SCHEDULER_Task *	search_timeout_task
	Search timeout task identifier. More...
static struct GNUNET_TIME_Relative	search_timeout_time = { 60000 }
	Search timeout in seconds. More...
static struct GNUNET_DISK_FileHandle *	data_file
	File to log statistics to. More...
static char *	data_filename
	Filename to log statistics to. More...
static char *	regex_prefix
	Prefix used for regex announcing. More...
static struct GNUNET_TIME_Relative	reannounce_period_max
	What's the maximum regex reannounce period. More...

Detailed Description

Regex profiler for testing distributed regex use.

Author

Bartlomiej Polot

Maximilian Szengel

Definition in file gnunet-regex-profiler.c.

Macro Definition Documentation

FIND_TIMEOUT

#define FIND_TIMEOUT   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)

Definition at line 39 of file gnunet-regex-profiler.c.

Referenced by find_string().

Enumeration Type Documentation

State

enum State

Available states during profiling.

Enumerator
STATE_INIT	Initial state.
STATE_SLAVES_STARTING	Starting slaves.
STATE_PEERS_CREATING	Creating peers.
STATE_PEERS_STARTING	Starting peers.
STATE_PEERS_LINKING	Linking peers.
STATE_SEARCH_REGEX	Matching strings against announced regexes.
STATE_PEERS_DESTROYING	Destroying peers; we can do this as the controller takes care of stopping a peer if it is running.
INIT	Initial state.
CFG_REQUEST_QUEUED	The configuration request has been sent.
SERVICE_CONNECTED	connected to service
RC_INIT	Initial state.
RC_LINKED	Controllers on given hosts started and linked.
RC_PEERS_CREATED	Peers are created.
RC_READY	The testbed run is ready and the master callback can be called now. At this time the peers are all started and if a topology is provided in the configuration the topology would have been attempted
RC_PEERS_SHUTDOWN	All peers shutdown (stopped and destroyed)

Definition at line 71 of file gnunet-regex-profiler.c.

           {
  STATE_INIT = 0,

  STATE_SLAVES_STARTING,

  STATE_PEERS_CREATING,

  STATE_PEERS_STARTING,

  STATE_PEERS_LINKING,

  STATE_SEARCH_REGEX,

  STATE_PEERS_DESTROYING
};

Function Documentation

dht_connect_cb()

static void dht_connect_cb ( void *  cls, struct GNUNET_TESTBED_Operation *  op, void *  ca_result, const char *  emsg  )

static

DHT connect callback.

Parameters

cls	internal peer id.
op	operation handle.
ca_result	connect adapter result.
emsg	error message.

Called when we are connected to the dht service for the peer in 'cls'. If successfull we connect to the stats service of this peer and then try to match the search string of this peer.

Parameters

cls	internal peer id.
op	operation handle.
ca_result	connect adapter result.
emsg	error message.

Definition at line 1036 of file gnunet-regex-profiler.c.

References RegexPeer::dht_handle, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get(), RegexPeer::op_handle, peer, RegexPeer::prof_start_time, regex_found_handler(), REGEX_INTERNAL_search(), RegexPeer::search_handle, RegexPeer::search_str, and RegexPeer::search_str_matched.

Referenced by find_string().

{
  struct RegexPeer *peer = (struct RegexPeer *)cls;

  if (NULL != emsg || NULL == op || NULL == ca_result)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
      GNUNET_assert(0);
    }

  GNUNET_assert(NULL != peer->dht_handle);
  GNUNET_assert(peer->op_handle == op);
  GNUNET_assert(peer->dht_handle == ca_result);

  peer->search_str_matched = GNUNET_NO;
  peer->search_handle = REGEX_INTERNAL_search(peer->dht_handle,
                                              peer->search_str,
                                              &regex_found_handler, peer,
                                              NULL);
  peer->prof_start_time = GNUNET_TIME_absolute_get();
}

Here is the call graph for this function:

Here is the caller graph for this function:

dht_ca()

static void * dht_ca ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

DHT connect adapter.

Parameters

cls	not used.
cfg	configuration handle.

Returns

Opens a connection to the dht service.

Parameters

cls	Closure (peer).
cfg	Configuration handle.

Returns

Definition at line 1071 of file gnunet-regex-profiler.c.

References DLLOperation::cls, RegexPeer::dht_handle, GNUNET_DHT_connect(), and peer.

Referenced by find_string().

{
  struct RegexPeer *peer = cls;

  peer->dht_handle = GNUNET_DHT_connect(cfg, 32);

  return peer->dht_handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dht_da()

static void dht_da ( void *  cls, void *  op_result  )

static

Adapter function called to destroy a connection to the DHT service.

Adapter function called to destroy a connection to the dht service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter
cls	Closure (peer).
op_result	Service handle returned from the connect adapter.

Definition at line 1088 of file gnunet-regex-profiler.c.

References RegexPeer::dht_handle, GNUNET_assert, GNUNET_DHT_disconnect(), peer, REGEX_INTERNAL_search_cancel(), and RegexPeer::search_handle.

Referenced by find_string().

{
  struct RegexPeer *peer = (struct RegexPeer *)cls;

  GNUNET_assert(peer->dht_handle == op_result);

  if (NULL != peer->search_handle)
    {
      REGEX_INTERNAL_search_cancel(peer->search_handle);
      peer->search_handle = NULL;
    }

  if (NULL != peer->dht_handle)
    {
      GNUNET_DHT_disconnect(peer->dht_handle);
      peer->dht_handle = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

stats_connect_cb()

static void stats_connect_cb ( void *  cls, struct GNUNET_TESTBED_Operation *  op, void *  ca_result, const char *  emsg  )

static

Function called by testbed once we are connected to stats service.

Get the statistics for the services of interest.

Parameters

cls	the 'struct RegexPeer' for which we connected to stats
op	connect operation handle
ca_result	handle to stats service
emsg	error message on failure

Definition at line 643 of file gnunet-regex-profiler.c.

References DLLOperation::cls, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_STATISTICS_get(), RegexPeer::id, peer, stats_cb(), RegexPeer::stats_handle, and stats_iterator().

Referenced by do_collect_stats(), and stats_cb().

{
  struct RegexPeer *peer = cls;

  if (NULL == ca_result || NULL != emsg)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Failed to connect to statistics service on peer %u: %s\n",
                 peer->id, emsg);

      peer->stats_handle = NULL;
      return;
    }

  peer->stats_handle = ca_result;

  if (NULL == GNUNET_STATISTICS_get(peer->stats_handle, NULL, NULL,
                                    &stats_cb,
                                    &stats_iterator, peer))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Could not get statistics of peer %u!\n", peer->id);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

announce_next_regex()

static void announce_next_regex ( void *  cls )

static

Start announcing the next regex in the DHT.

Parameters

cls	Index of the next peer in the peers array.
cls	Closure (unused).

Definition at line 990 of file gnunet-regex-profiler.c.

References RegexPeer::daemon_op, daemon_started(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, in_shutdown, next_search, num_peers, parallel_searches, peer, RegexPeer::peer_handle, search_timed_out(), and strings_found.

Referenced by do_announce(), find_timed_out(), and regex_found_handler().

{
  struct RegexPeer *peer;

  if (GNUNET_YES == in_shutdown)
    return;
  if (next_search >= num_peers)
    {
      if (strings_found != num_peers)
        {
          struct GNUNET_TIME_Relative new_delay;
          if (NULL != search_timeout_task)
            GNUNET_SCHEDULER_cancel(search_timeout_task);
          new_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15);
          search_timeout_task = GNUNET_SCHEDULER_add_delayed(new_delay,
                                                             &search_timed_out,
                                                             NULL);
        }
      return;
    }

  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
  peer = &peers[next_search];
  peer->daemon_op =
    GNUNET_TESTBED_peer_manage_service(NULL,
                                       peer->peer_handle,
                                       "regexprofiler",
                                       &daemon_started,
                                       peer,
                                       1);
  next_search++;
  parallel_searches++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown nicely.

Parameters

cls

NULL

Definition at line 395 of file gnunet-regex-profiler.c.

References GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_file_close(), GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free_non_null, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TESTBED_cancel_registration(), GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_controller_stop(), GNUNET_TESTBED_operation_done(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, RegexPeer::id, num_peers, RegexPeer::op_handle, peer, RegexPeer::prof_start_time, prof_time, RegexPeer::search_str, RegexPeer::search_str_matched, search_strings, and size.

Referenced by do_abort(), and run().

{
  struct RegexPeer *peer;
  unsigned int peer_cnt;
  unsigned int search_str_cnt;
  char output_buffer[512];
  size_t size;

  if (NULL != abort_task)
    {
      GNUNET_SCHEDULER_cancel(abort_task);
      abort_task = NULL;
    }
  if (NULL != register_hosts_task)
    {
      GNUNET_SCHEDULER_cancel(register_hosts_task);
      register_hosts_task = NULL;
    }
  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
    {
      peer = &peers[peer_cnt];

      if (GNUNET_YES != peer->search_str_matched && NULL != data_file)
        {
          prof_time = GNUNET_TIME_absolute_get_duration(peer->prof_start_time);
          size =
            GNUNET_snprintf(output_buffer,
                            sizeof(output_buffer),
                            "%p Search string not found: %s (%d)\n"
                            "%p On peer: %u (%p)\n"
                            "%p After: %s\n",
                            peer, peer->search_str, peer->search_str_matched,
                            peer, peer->id, peer,
                            peer,
                            GNUNET_STRINGS_relative_time_to_string(prof_time,
                                                                   GNUNET_NO));
          if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
        }

      if (NULL != peers[peer_cnt].op_handle)
        GNUNET_TESTBED_operation_done(peers[peer_cnt].op_handle);
    }

  if (NULL != data_file)
    {
      GNUNET_DISK_file_close(data_file);
      data_file = NULL;
    }
  for (search_str_cnt = 0;
       search_str_cnt < num_peers && NULL != search_strings;
       search_str_cnt++)
    {
      GNUNET_free_non_null(search_strings[search_str_cnt]);
    }
  GNUNET_free_non_null(search_strings);
  search_strings = NULL;

  if (NULL != reg_handle)
    {
      GNUNET_TESTBED_cancel_registration(reg_handle);
      reg_handle = NULL;
    }
  if (NULL != mc)
    {
      GNUNET_TESTBED_controller_disconnect(mc);
      mc = NULL;
    }
  if (NULL != mc_proc)
    {
      GNUNET_TESTBED_controller_stop(mc_proc);
      mc_proc = NULL;
    }
  if (NULL != cfg)
    {
      GNUNET_CONFIGURATION_destroy(cfg);
      cfg = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_abort()

static void do_abort ( void *  cls )

static

abort task to run on test timed out

Parameters

cls

NULL

Definition at line 482 of file gnunet-regex-profiler.c.

References do_shutdown(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, and result.

Referenced by run().

{
  unsigned long i = (unsigned long)cls;

  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
             "Aborting from line %lu...\n", i);
  abort_task = NULL;
  result = GNUNET_SYSERR;
  GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stats_ca()

static void* stats_ca ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Adapter function called to establish a connection to statistics service.

Parameters

cls	closure
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns

service handle to return in 'op_result', NULL on error

Definition at line 509 of file gnunet-regex-profiler.c.

References GNUNET_STATISTICS_create().

Referenced by do_collect_stats(), and stats_cb().

{
  return GNUNET_STATISTICS_create("<driver>", cfg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stats_da()

static void stats_da ( void *  cls, void *  op_result  )

static

Adapter function called to destroy a connection to statistics service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 524 of file gnunet-regex-profiler.c.

References DLLOperation::cls, GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_destroy(), peer, and RegexPeer::stats_handle.

Referenced by do_collect_stats(), and stats_cb().

{
  struct RegexPeer *peer = cls;

  GNUNET_assert(op_result == peer->stats_handle);

  GNUNET_STATISTICS_destroy(peer->stats_handle, GNUNET_NO);
  peer->stats_handle = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

stats_iterator()

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

static

Process statistic values.

Write all values to global 'data_file', if present.

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 546 of file gnunet-regex-profiler.c.

References DLLOperation::cls, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_snprintf(), peer, and size.

Referenced by stats_connect_cb().

{
  struct RegexPeer *peer = cls;
  char output_buffer[512];
  size_t size;

  if (NULL == data_file)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "%p -> %s [%s]: %llu\n",
                 peer,
                 subsystem,
                 name,
                 (unsigned long long)value);
      return GNUNET_OK;
    }
  size =
    GNUNET_snprintf(output_buffer,
                    sizeof(output_buffer),
                    "%p [%s] %llu %s\n",
                    peer,
                    subsystem, value, name);
  if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
               "Unable to write to file!\n");

  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

stats_cb()

static void stats_cb ( void *  cls, int  success  )

static

Stats callback.

Finish the stats testbed operation and when all stats have been iterated, shutdown the profiler.

Parameters

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

Definition at line 588 of file gnunet-regex-profiler.c.

References DLLOperation::cls, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_service_connect(), RegexPeer::id, num_peers, RegexPeer::op_handle, peer, RegexPeer::peer_handle, result, stats_ca(), stats_connect_cb(), and stats_da().

Referenced by stats_connect_cb().

{
  static unsigned int peer_cnt;
  struct RegexPeer *peer = cls;

  if (GNUNET_OK != success)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Getting statistics for peer %u failed!\n",
                 peer->id);
      return;
    }

  GNUNET_assert(NULL != peer->op_handle);

  GNUNET_TESTBED_operation_done(peer->op_handle);
  peer->op_handle = NULL;

  peer_cnt++;
  peer = &peers[peer_cnt];

  fprintf(stderr, "s");
  if (peer_cnt == num_peers)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "\nCollecting stats finished. Shutting down.\n");
      GNUNET_SCHEDULER_shutdown();
      result = GNUNET_OK;
    }
  else
    {
      peer->op_handle =
        GNUNET_TESTBED_service_connect(NULL,
                                       peer->peer_handle,
                                       "statistics",
                                       &stats_connect_cb,
                                       peer,
                                       &stats_ca,
                                       &stats_da,
                                       peer);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_collect_stats()

static void do_collect_stats ( void *  cls )

static

Task to collect all statistics from all peers, will shutdown the profiler, when done.

Parameters

cls

NULL

Definition at line 679 of file gnunet-regex-profiler.c.

References DLLOperation::cls, find_string(), GNUNET_assert, GNUNET_TESTBED_service_connect(), RegexPeer::op_handle, peer, RegexPeer::peer_handle, stats_ca(), stats_connect_cb(), and stats_da().

Referenced by regex_found_handler(), and search_timed_out().

{
  struct RegexPeer *peer = &peers[0];

  GNUNET_assert(NULL != peer->peer_handle);

  peer->op_handle =
    GNUNET_TESTBED_service_connect(NULL,
                                   peer->peer_handle,
                                   "statistics",
                                   &stats_connect_cb,
                                   peer,
                                   &stats_ca,
                                   &stats_da,
                                   peer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_string()

static void find_string ( void *  cls )

static

Start searching for the next string in the DHT.

Start searching for a string in the DHT.

Parameters

cls	Index of the next peer in the peers array.

Definition at line 878 of file gnunet-regex-profiler.c.

References DLLOperation::cls, dht_ca(), dht_connect_cb(), dht_da(), find_timed_out(), FIND_TIMEOUT, GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_service_connect(), GNUNET_YES, in_shutdown, num_peers, RegexPeer::op_handle, parallel_searches, RegexPeer::peer_handle, RegexPeer::search_str, and RegexPeer::timeout.

Referenced by daemon_started(), and do_collect_stats().

{
  unsigned int search_peer = (unsigned int)(long)cls;

  if ((search_peer >= num_peers) ||
      (GNUNET_YES == in_shutdown))
    return;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Searching for string \"%s\" on peer %d (%u||)\n",
             peers[search_peer].search_str,
             search_peer,
             parallel_searches);

  peers[search_peer].op_handle =
    GNUNET_TESTBED_service_connect(NULL,
                                   peers[search_peer].peer_handle,
                                   "dht",
                                   &dht_connect_cb,
                                   &peers[search_peer],
                                   &dht_ca,
                                   &dht_da,
                                   &peers[search_peer]);
  GNUNET_assert(NULL != peers[search_peer].op_handle);
  peers[search_peer].timeout
    = GNUNET_SCHEDULER_add_delayed(FIND_TIMEOUT,
                                   &find_timed_out,
                                   &peers[search_peer]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

regex_found_handler()

static void regex_found_handler ( void *  cls, const struct GNUNET_PeerIdentity *  id, const struct GNUNET_PeerIdentity *  get_path, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  put_path, unsigned int  put_path_length  )

static

Method called when we've found a peer that announced a regex that matches our search string.

Now get the statistics.

Parameters

cls	Closure provided in REGEX_INTERNAL_search.
id	Peer providing a regex that matches the string.
get_path	Path of the get request.
get_path_length	Lenght of get_path.
put_path	Path of the put request.
put_path_length	Length of the put_path.

Definition at line 723 of file gnunet-regex-profiler.c.

References announce_next_regex(), DLLOperation::cls, do_collect_stats(), GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TESTBED_operation_done(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, RegexPeer::id, in_shutdown, num_peers, RegexPeer::op_handle, parallel_searches, peer, RegexPeer::prof_start_time, prof_start_time, prof_time, RegexPeer::search_str, RegexPeer::search_str_matched, size, strings_found, and RegexPeer::timeout.

Referenced by dht_connect_cb().

{
  struct RegexPeer *peer = cls;
  char output_buffer[512];
  size_t size;

  if (GNUNET_YES == peer->search_str_matched)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "String %s on peer %u already matched!\n",
                 peer->search_str, peer->id);
      return;
    }

  strings_found++;
  parallel_searches--;

  if (NULL != peer->timeout)
    {
      GNUNET_SCHEDULER_cancel(peer->timeout);
      peer->timeout = NULL;
      if (GNUNET_NO == in_shutdown)
        GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
    }

  if (NULL == id)
    {
      // FIXME not possible right now
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "String matching timed out for string %s on peer %u (%i/%i)\n",
                 peer->search_str, peer->id, strings_found, num_peers);
      peer->search_str_matched = GNUNET_SYSERR;
    }
  else
    {
      prof_time = GNUNET_TIME_absolute_get_duration(peer->prof_start_time);

      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "String %s found on peer %u after %s (%i/%i) (%u||)\n",
                 peer->search_str, peer->id,
                 GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO),
                 strings_found, num_peers, parallel_searches);

      peer->search_str_matched = GNUNET_YES;

      if (NULL != data_file)
        {
          size =
            GNUNET_snprintf(output_buffer,
                            sizeof(output_buffer),
                            "%p Peer: %u\n"
                            "%p Search string: %s\n"
                            "%p Search duration: %s\n\n",
                            peer, peer->id,
                            peer, peer->search_str,
                            peer,
                            GNUNET_STRINGS_relative_time_to_string(prof_time,
                                                                   GNUNET_NO));

          if (size != GNUNET_DISK_file_write(data_file, output_buffer, size))
            GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
        }
    }

  GNUNET_TESTBED_operation_done(peer->op_handle);
  peer->op_handle = NULL;

  if (strings_found == num_peers)
    {
      prof_time = GNUNET_TIME_absolute_get_duration(prof_start_time);
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "All strings successfully matched in %s\n",
                 GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO));

      if (NULL != search_timeout_task)
        {
          GNUNET_SCHEDULER_cancel(search_timeout_task);
          search_timeout_task = NULL;
        }

      GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Collecting stats.\n");
      GNUNET_SCHEDULER_add_now(&do_collect_stats, NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

search_timed_out()

static void search_timed_out ( void *  cls )

static

Connect by string timeout task.

This will cancel the profiler after the specified timeout 'search_timeout'.

Parameters

cls

NULL

Definition at line 821 of file gnunet-regex-profiler.c.

References do_collect_stats(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TESTBED_operation_done(), GNUNET_YES, in_shutdown, num_peers, RegexPeer::op_handle, and strings_found.

Referenced by announce_next_regex(), and test_master().

{
  unsigned int i;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Finding matches to all strings did not succeed after %s.\n",
             GNUNET_STRINGS_relative_time_to_string(search_timeout_time,
                                                    GNUNET_NO));
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Found %i of %i strings\n", strings_found, num_peers);

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Search timed out after %s."
             "Collecting stats and shutting down.\n",
             GNUNET_STRINGS_relative_time_to_string(search_timeout_time,
                                                    GNUNET_NO));

  in_shutdown = GNUNET_YES;
  for (i = 0; i < num_peers; i++)
    {
      if (NULL != peers[i].op_handle)
        {
          GNUNET_TESTBED_operation_done(peers[i].op_handle);
          peers[i].op_handle = NULL;
        }
    }
  GNUNET_SCHEDULER_add_now(&do_collect_stats, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_timed_out()

static void find_timed_out ( void *  cls )

static

Search timed out.

It might still complete in the future, but we should start another one.

Parameters

cls	Index of the next peer in the peers array.

Definition at line 858 of file gnunet-regex-profiler.c.

References announce_next_regex(), DLLOperation::cls, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), RegexPeer::id, in_shutdown, p, RegexPeer::search_str, and RegexPeer::timeout.

Referenced by find_string().

{
  struct RegexPeer *p = cls;

  p->timeout = NULL;
  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
             "Searching for string \"%s\" on peer %d timed out.\n",
             p->search_str,
             p->id);
  if (GNUNET_NO == in_shutdown)
    GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

daemon_started()

static void daemon_started ( void *  cls, struct GNUNET_TESTBED_Operation *  op, const char *  emsg  )

static

Callback called when testbed has started the daemon we asked for.

Parameters

cls	NULL
op	the operation handle
emsg	NULL on success; otherwise an error description

Definition at line 917 of file gnunet-regex-profiler.c.

References RegexPeer::daemon_op, find_string(), GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_operation_done(), GNUNET_TIME_relative_saturating_multiply(), RegexPeer::id, num_peers, peer, reannounce_period_max, RegexPeer::search_str, RegexPeer::search_str_matched, and search_strings.

Referenced by announce_next_regex().

{
  struct RegexPeer *peer = (struct RegexPeer *)cls;
  unsigned long search_peer;
  unsigned int i;

  GNUNET_TESTBED_operation_done(peer->daemon_op);
  peer->daemon_op = NULL;
  if (NULL != emsg)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Failed to start/stop daemon at peer %u: %s\n", peer->id, emsg);
      GNUNET_assert(0);
    }
  else
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Deamon %u started successfully\n", peer->id);
    }

  /* Find a peer to look for a string matching the regex announced */
  search_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                         num_peers);
  for (i = 0; peers[search_peer].search_str != NULL; i++)
    {
      search_peer = (search_peer + 1) % num_peers;
      if (i > num_peers)
        GNUNET_assert(0); /* we ran out of peers, must be a bug */
    }
  peers[search_peer].search_str = search_strings[peer->id];
  peers[search_peer].search_str_matched = GNUNET_NO;
  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_saturating_multiply(
                                 reannounce_period_max,
                                 2),
                               &find_string,
                               (void *)search_peer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_announce()

static void do_announce ( void *  cls )

static

Task to start the daemons on each peer so that the regexes are announced into the DHT.

Parameters

cls	NULL
tc	the task context

Definition at line 966 of file gnunet-regex-profiler.c.

References announce_next_regex(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_YES, in_shutdown, and init_parallel_searches.

Referenced by test_master().

{
  unsigned int i;

  if (GNUNET_YES == in_shutdown)
    return;
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Starting announce.\n");
  for (i = 0; i < init_parallel_searches; i++)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "  scheduling announce %u\n",
                 i);
      (void)GNUNET_SCHEDULER_add_now(&announce_next_regex, NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_master()

static void test_master ( void *  cls, struct GNUNET_TESTBED_RunHandle *  h, unsigned int  num_peers_, struct GNUNET_TESTBED_Peer **  testbed_peers, unsigned int  links_succeeded, unsigned int  links_failed  )

static

Signature of a main function for a testcase.

Parameters

cls	NULL
h	the run handle
num_peers_	number of peers in 'peers'
testbed_peers	handle to peers run in the testbed. NULL upon timeout (see GNUNET_TESTBED_test_run()).
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link connection attempts that failed

Definition at line 1122 of file gnunet-regex-profiler.c.

References do_announce(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, num_peers, RegexPeer::peer_handle, prof_start_time, prof_time, and search_timed_out().

Referenced by run().

{
  unsigned int i;

  GNUNET_assert(num_peers_ == num_peers);

  prof_time = GNUNET_TIME_absolute_get_duration(prof_start_time);
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Testbed started in %s\n",
             GNUNET_STRINGS_relative_time_to_string(prof_time, GNUNET_NO));

  if (NULL != abort_task)
    {
      GNUNET_SCHEDULER_cancel(abort_task);
      abort_task = NULL;
    }

  for (i = 0; i < num_peers; i++)
    {
      peers[i].peer_handle = testbed_peers[i];
    }
  if (GNUNET_NO ==
      GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT", "DISABLE_TRY_CONNECT"))
    {
      struct GNUNET_TIME_Relative settle_time;

      settle_time =
        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
                                      10 * num_peers);
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Waiting for DHT for %s to settle new connections.\n\n",
                 GNUNET_STRINGS_relative_time_to_string(settle_time, GNUNET_NO));
      GNUNET_SCHEDULER_add_delayed(settle_time, &do_announce, NULL);
    }
  else
    {
      GNUNET_SCHEDULER_add_now(&do_announce, NULL);
    }
  search_timeout_task =
    GNUNET_SCHEDULER_add_delayed(search_timeout_time, &search_timed_out, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

master_controller_cb()

static void master_controller_cb ( void *  cls, const struct GNUNET_TESTBED_EventInformation *  event  )

static

Function that will be called whenever something in the testbed changes.

Parameters

cls	closure, NULL
event	information on what is happening

Definition at line 1176 of file gnunet-regex-profiler.c.

References GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_PEER_START, and GNUNET_TESTBED_EventInformation::type.

Referenced by run().

{
  switch (event->type)
    {
    case GNUNET_TESTBED_ET_CONNECT:
      printf(".");
      break;

    case GNUNET_TESTBED_ET_PEER_START:
      printf("#");
      break;

    default:
      break;
    }
  fflush(stdout);
}

Here is the caller graph for this function:

count_and_separate_strings()

static int count_and_separate_strings ( char *  data, uint64_t  data_size, unsigned int  str_max  )

static

Process the text buffer counting the non-empty lines and separating them with NULL characters, for later ease of copy using (as)printf.

Parameters

data	Memory buffer with strings.
data_size	Size of the data buffer in bytes.
str_max	Maximum number of strings to return.

Returns

Positive number of lines found in the buffer, GNUNET_SYSERR otherwise.

Definition at line 1211 of file gnunet-regex-profiler.c.

References buf, and data.

Referenced by load_search_strings().

{
  char *buf;            // Keep track of last string to skip blank lines
  unsigned int offset;
  unsigned int str_cnt;

  buf = data;
  offset = 0;
  str_cnt = 0;
  while ((offset < (data_size - 1)) && (str_cnt < str_max))
    {
      offset++;
      if (((data[offset] == '\n')) &&
          (buf != &data[offset]))
        {
          data[offset] = '\0';
          str_cnt++;
          buf = &data[offset + 1];
        }
      else if ((data[offset] == '\n') ||
               (data[offset] == '\0'))
        buf = &data[offset + 1];
    }
  return str_cnt;
}

Here is the caller graph for this function:

create_string_array()

static int create_string_array ( char *  data, uint64_t  data_size, char ***  strings, unsigned int  str_cnt  )

static

Allocate a string array and fill it with the prefixed strings from a pre-processed, NULL-separated memory region.

Parameters

data	Preprocessed memory with strings
data_size	Size of the data buffer in bytes.
strings	Address of the string array to be created. Must be freed by caller if function end in success.
str_cnt	String count. The data buffer should contain at least this many NULL-separated strings.

Returns

GNUNET_OK in ase of success, GNUNET_SYSERR otherwise. In case of error strings must not be freed.

Definition at line 1254 of file gnunet-regex-profiler.c.

References GNUNET_asprintf(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, len, and regex_prefix.

Referenced by load_search_strings().

{
  uint64_t offset;
  uint64_t len;
  unsigned int i;

  *strings = GNUNET_malloc(sizeof(char *) * str_cnt);
  offset = 0;
  for (i = 0; i < str_cnt; i++)
    {
      len = strlen(&data[offset]);
      if (offset + len >= data_size)
        {
          GNUNET_free(*strings);
          *strings = NULL;
          return GNUNET_SYSERR;
        }
      if (0 == len) // empty line
        {
          offset++;
          i--;
          continue;
        }

      GNUNET_asprintf(&(*strings)[i],
                      "%s%s",
                      regex_prefix,
                      &data[offset]);
      offset += len + 1;
    }
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_search_strings()

static int load_search_strings ( const char *  filename, char ***  strings, unsigned int  limit  )

static

Load search strings from given filename.

One search string per line.

Parameters

filename	filename of the file containing the search strings.
strings	set of strings loaded from file. Caller needs to free this if number returned is greater than zero.
limit	upper limit on the number of strings read from the file

Returns

number of strings found in the file. GNUNET_SYSERR on error.

Definition at line 1299 of file gnunet-regex-profiler.c.

References count_and_separate_strings(), create_string_array(), data, GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, and GNUNET_YES.

Referenced by run().

{
  char *data;
  uint64_t filesize;
  int str_cnt;

  /* Sanity checks */
  if (NULL == filename)
    {
      return GNUNET_SYSERR;
    }
  if (GNUNET_YES != GNUNET_DISK_file_test(filename))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Could not find search strings file %s\n", filename);
      return GNUNET_SYSERR;
    }
  if (GNUNET_OK !=
      GNUNET_DISK_file_size(filename,
                            &filesize,
                            GNUNET_YES,
                            GNUNET_YES))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Search strings file %s cannot be read.\n",
                 filename);
      return GNUNET_SYSERR;
    }
  if (0 == filesize)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Search strings file %s is empty.\n",
                 filename);
      return GNUNET_SYSERR;
    }

  /* Read data into memory */
  data = GNUNET_malloc(filesize + 1);
  if (filesize != GNUNET_DISK_fn_read(filename,
                                      data,
                                      filesize))
    {
      GNUNET_free(data);
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Could not read search strings file %s.\n",
                 filename);
      return GNUNET_SYSERR;
    }

  /* Process buffer and build array */
  str_cnt = count_and_separate_strings(data, filesize, limit);
  if (GNUNET_OK != create_string_array(data, filesize, strings, str_cnt))
    {
      str_cnt = GNUNET_SYSERR;
    }
  GNUNET_free(data);
  return str_cnt;
}

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 *  config  )

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!)
config	configuration

Definition at line 1370 of file gnunet-regex-profiler.c.

References _, data_filename, do_abort(), do_shutdown(), event_mask, GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_DISK_file_open(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_run(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, hosts_file, in_shutdown, init_parallel_searches, load_search_strings(), master_controller_cb(), num_peers, policy_dir, prof_start_time, reannounce_period_max, regex_prefix, search_strings, strings_file, and test_master().

Referenced by main().

{
  unsigned int nsearchstrs;
  unsigned int i;
  struct GNUNET_TIME_Relative abort_time;

  in_shutdown = GNUNET_NO;

  /* Check config */
  if (NULL == config)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("No configuration file given. Exiting\n"));
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  cfg = GNUNET_CONFIGURATION_dup(config);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string(cfg, "REGEXPROFILER",
                                            "REGEX_PREFIX",
                                            &regex_prefix))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
                                "regexprofiler",
                                "regex_prefix");
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number(cfg, "REGEXPROFILER",
                                            "PARALLEL_SEARCHES",
                                            &init_parallel_searches))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Configuration option \"PARALLEL_SEARCHES\" missing."
                 " Using default (%d)\n", 10);
      init_parallel_searches = 10;
    }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time(cfg, "REGEXPROFILER",
                                          "REANNOUNCE_PERIOD_MAX",
                                          &reannounce_period_max))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "reannounce_period_max not given. Using 10 minutes.\n");
      reannounce_period_max =
        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 10);
    }

  /* Check arguments */
  if (NULL == policy_dir)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("No policy directory specified on command line. Exiting.\n"));
      return;
    }
  if (GNUNET_YES != GNUNET_DISK_directory_test(policy_dir, GNUNET_YES))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("Specified policies directory does not exist. Exiting.\n"));
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  if (0 >= (int)(num_peers = GNUNET_DISK_directory_scan(policy_dir, NULL, NULL)))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("No files found in `%s'\n"),
                 policy_dir);
      return;
    }
  GNUNET_CONFIGURATION_set_value_string(cfg, "REGEXPROFILER",
                                        "POLICY_DIR", policy_dir);
  if (GNUNET_YES != GNUNET_DISK_file_test(strings_file))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("No search strings file given. Exiting.\n"));
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  nsearchstrs = load_search_strings(strings_file,
                                    &search_strings,
                                    num_peers);
  if (num_peers != nsearchstrs)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Error loading search strings.\n");
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "File (%s) does not contain enough strings (%u/%u).\n",
                 strings_file, nsearchstrs, num_peers);
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  if ((0 == num_peers) || (NULL == search_strings))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("Error loading search strings. Exiting.\n"));
      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
      return;
    }
  for (i = 0; i < num_peers; i++)
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
               "search string: %s\n",
               search_strings[i]);

  /* Check logfile */
  if ((NULL != data_filename) &&
      (NULL == (data_file =
                  GNUNET_DISK_file_open(data_filename,
                                        GNUNET_DISK_OPEN_READWRITE |
                                        GNUNET_DISK_OPEN_TRUNCATE |
                                        GNUNET_DISK_OPEN_CREATE,
                                        GNUNET_DISK_PERM_USER_READ |
                                        GNUNET_DISK_PERM_USER_WRITE))))
    {
      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
                               "open",
                               data_filename);
      return;
    }

  /* Initialize peers */
  peers = GNUNET_malloc(sizeof(struct RegexPeer) * num_peers);
  for (i = 0; i < num_peers; i++)
    peers[i].id = i;

  GNUNET_CONFIGURATION_set_value_number(cfg,
                                        "TESTBED", "OVERLAY_RANDOM_LINKS",
                                        num_peers * 20);
  GNUNET_CONFIGURATION_set_value_number(cfg,
                                        "DHT", "FORCE_NSE",
                                        (long long unsigned)
                                        (log(num_peers) / log(2.0)));
  event_mask = 0LL;
/* For feedback about the start process activate these and pass master_cb */
  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
//   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
//   event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
  prof_start_time = GNUNET_TIME_absolute_get();
  GNUNET_TESTBED_run(hosts_file,
                     cfg,
                     num_peers,
                     event_mask,
                     &master_controller_cb,
                     NULL,      /* master_controller_cb cls */
                     &test_master,
                     NULL);     /* test_master cls */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time(cfg, "TESTBED",
                                          "SETUP_TIMEOUT",
                                          &abort_time))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "SETUP_TIMEOUT not given. Using 15 minutes.\n");
      abort_time =
        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15);
    }
  abort_time = GNUNET_TIME_relative_add(abort_time, GNUNET_TIME_UNIT_MINUTES);
  abort_task =
    GNUNET_SCHEDULER_add_delayed(abort_time,
                                 &do_abort,
                                 (void*)__LINE__);
  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
             "setup_timeout: %s\n",
             GNUNET_STRINGS_relative_time_to_string(abort_time, GNUNET_YES));
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

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

Main function.

Parameters

argc	argument count
argv	argument values

Returns

0 on success

Definition at line 1549 of file gnunet-regex-profiler.c.

References _, data_filename, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_filename(), GNUNET_GETOPT_option_relative_time(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_SYSERR, hosts_file, policy_dir, result, ret, run(), and strings_file.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_filename('o',
                                  "output-file",
                                  "FILENAME",
                                  gettext_noop("name of the file for writing statistics"),
                                  &data_filename),

    GNUNET_GETOPT_option_relative_time('t',
                                       "matching-timeout",
                                       "TIMEOUT",
                                       gettext_noop("wait TIMEOUT before ending the experiment"),
                                       &search_timeout_time),

    GNUNET_GETOPT_option_filename('p',
                                  "policy-dir",
                                  "DIRECTORY",
                                  gettext_noop("directory with policy files"),
                                  &policy_dir),


    GNUNET_GETOPT_option_filename('s',
                                  "strings-file",
                                  "FILENAME",
                                  gettext_noop("name of file with input strings"),
                                  &strings_file),

    GNUNET_GETOPT_option_filename('H',
                                  "hosts-file",
                                  "FILENAME",
                                  gettext_noop("name of file with hosts' names"),
                                  &hosts_file),

    GNUNET_GETOPT_OPTION_END
  };
  int ret;

  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
    return 2;
  result = GNUNET_SYSERR;
  ret =
    GNUNET_PROGRAM_run(argc, argv,
                       "gnunet-regex-profiler",
                       _("Profiler for regex"),
                       options, &run, NULL);
  if (GNUNET_OK != ret)
    return ret;
  if (GNUNET_OK != result)
    return 1;
  return 0;
}

Here is the call graph for this function:

Variable Documentation

in_shutdown

int in_shutdown

static

Set when shutting down to avoid making more queries.

Definition at line 181 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), do_announce(), find_string(), find_timed_out(), regex_found_handler(), run(), and search_timed_out().

peers

struct RegexPeer* peers

static

The array of peers; we fill this as the peers are given to us by the testbed.

Definition at line 186 of file gnunet-regex-profiler.c.

reg_handle

struct GNUNET_TESTBED_HostRegistrationHandle* reg_handle

static

Host registration handle.

Definition at line 191 of file gnunet-regex-profiler.c.

mc_proc

struct GNUNET_TESTBED_ControllerProc* mc_proc

static

Handle to the master controller process.

Definition at line 196 of file gnunet-regex-profiler.c.

mc

struct GNUNET_TESTBED_Controller* mc

static

Handle to the master controller.

Definition at line 201 of file gnunet-regex-profiler.c.

Referenced by broadcast_mst_cb(), copy_latest(), error_handler(), estimate_latency(), GNUNET_CRYPTO_hmac_raw(), GNUNET_DEFRAGMENT_context_destroy(), GNUNET_DEFRAGMENT_process_fragment(), GNUNET_MYSQL_context_create(), GNUNET_MYSQL_statement_prepare(), GNUNET_TRANSPORT_monitor(), handle_monitor_data(), handle_monitor_end(), merge_addr(), prepare_statement(), and send_ack().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to global configuration.

Definition at line 206 of file gnunet-regex-profiler.c.

abort_task

struct GNUNET_SCHEDULER_Task* abort_task

static

Abort task identifier.

Definition at line 211 of file gnunet-regex-profiler.c.

register_hosts_task

struct GNUNET_SCHEDULER_Task* register_hosts_task

static

Host registration task identifier.

Definition at line 216 of file gnunet-regex-profiler.c.

event_mask

uint64_t event_mask

static

Global event mask for all testbed events.

Definition at line 221 of file gnunet-regex-profiler.c.

Referenced by run().

prof_start_time

struct GNUNET_TIME_Absolute prof_start_time

static

The starting time of a profiling step.

Definition at line 226 of file gnunet-regex-profiler.c.

Referenced by regex_found_handler(), run(), and test_master().

prof_time

struct GNUNET_TIME_Relative prof_time

static

Duration profiling step has taken.

Definition at line 231 of file gnunet-regex-profiler.c.

Referenced by do_shutdown(), regex_found_handler(), and test_master().

num_peers

unsigned int num_peers

static

Number of peers to be started by the profiler.

Definition at line 236 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), daemon_started(), do_shutdown(), find_string(), regex_found_handler(), run(), search_timed_out(), stats_cb(), and test_master().

result

int result

static

Global testing status.

Definition at line 241 of file gnunet-regex-profiler.c.

Referenced by agent_q(), block_plugin_regex_evaluate(), check_reply(), create_internal(), database_shutdown(), decode_private_ecdhe_key(), decode_private_ecdsa_key(), decode_private_eddsa_key(), dns_value_to_string(), do_abort(), do_reconnect(), evaluate_nfa(), expand_dollar(), find_op_by_id(), GAS_handle_reservation_request(), GCC_latency_observed(), get_cont(), GNUNET_BIO_read(), GNUNET_CRYPTO_ecc_ecdh(), GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_CRYPTO_ecdsa_ecdh(), GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_CRYPTO_rsa_private_key_get_public(), GNUNET_FS_directory_scan_get_result(), GNUNET_HOSTLIST_client_start(), GNUNET_MY_extract_result(), GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_exec_statements(), GNUNET_RECLAIM_ATTRIBUTE_list_dup(), GNUNET_RECLAIM_ATTRIBUTE_list_serialize(), GNUNET_STRINGS_parse_ipv4_policy(), GNUNET_STRINGS_parse_ipv6_policy(), GNUNET_xmalloc_unchecked_(), handle_arm_result(), handle_collect_response(), handle_gns_response(), handle_reply(), handle_search_result(), handle_verify_response(), init_cb(), libgnunet_plugin_datacache_sqlite_done(), main(), numeric_reverse(), OIDC_id_token_new(), process_result_message(), recalculate_path_desirability(), reconnect(), REGEX_INTERNAL_eval(), regex_next_edge(), regex_result_iterator(), ril_network_get_social_welfare(), rsa_sign_mpi(), send_cred_response(), send_with_session(), sq_prepare(), sql_exec(), sql_prepare(), state_set_compare(), stats_cb(), stun_msg2str(), time_between(), and write_cpabe().

state

enum State state

current state of profiling

Definition at line 246 of file gnunet-regex-profiler.c.

Referenced by change_state(), check_icmp_remote(), check_icmp_service(), check_tcp_data(), check_tcp_remote(), check_tcp_service(), check_udp_remote(), check_udp_service(), cleanup_s5r(), deserialize_unindex_file(), envi_get_state(), GCT_change_estate(), gen_topo_from_file(), get_redirect_state(), handle_dummy(), handle_icmp_remote(), handle_icmp_service(), handle_tcp_data(), handle_tcp_remote(), handle_tcp_service(), handle_udp_remote(), handle_udp_service(), icmp_from_helper(), intersection_accept(), intersection_evaluate(), iterate_reachables(), notify_session_monitor(), parse_definitions(), print_plugin_event_info(), process_peer_monitoring_cb(), reachability_iterator(), resolve_peer_address(), state_set_append(), tcp_from_helper(), udp_from_helper(), union_accept(), union_evaluate(), and validation_entry_changed().

policy_dir

char* policy_dir

static

Folder where policy files are stored.

Definition at line 251 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

hosts_file

char* hosts_file

static

File with hostnames where to execute the test.

Definition at line 256 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

strings_file

char* strings_file

static

File with the strings to look for.

Definition at line 261 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

search_strings

char** search_strings

static

Search strings (num_peers of them).

Definition at line 266 of file gnunet-regex-profiler.c.

Referenced by daemon_started(), do_shutdown(), and run().

init_parallel_searches

long long unsigned int init_parallel_searches

static

How many searches are we going to start in parallel.

Definition at line 271 of file gnunet-regex-profiler.c.

Referenced by do_announce(), and run().

parallel_searches

unsigned int parallel_searches

static

How many searches are running in parallel.

Definition at line 276 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), find_string(), and regex_found_handler().

strings_found

unsigned int strings_found

static

Number of strings found in the published regexes.

Definition at line 281 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), regex_found_handler(), and search_timed_out().

next_search

unsigned int next_search

static

Index of peer to start next announce/search.

Definition at line 286 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex().

search_timeout_task

struct GNUNET_SCHEDULER_Task* search_timeout_task

static

Search timeout task identifier.

Definition at line 291 of file gnunet-regex-profiler.c.

search_timeout_time

struct GNUNET_TIME_Relative search_timeout_time = { 60000 }

static

Search timeout in seconds.

Definition at line 296 of file gnunet-regex-profiler.c.

data_file

struct GNUNET_DISK_FileHandle* data_file

static

File to log statistics to.

Definition at line 301 of file gnunet-regex-profiler.c.

data_filename

char* data_filename

static

Filename to log statistics to.

Definition at line 306 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

regex_prefix

char* regex_prefix

static

Prefix used for regex announcing.

We need to prefix the search strings with it, in order to find something.

Definition at line 312 of file gnunet-regex-profiler.c.

Referenced by create_string_array(), and run().

reannounce_period_max

struct GNUNET_TIME_Relative reannounce_period_max

static

What's the maximum regex reannounce period.

Definition at line 317 of file gnunet-regex-profiler.c.

Referenced by daemon_started(), and run().