testing_api_cmd_netjail_start_cmds_helper.c File Reference

Command to start the netjail peers. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "testing_api_barrier.h"
#include "testing_api_loop.h"
#include "testing_cmds.h"
#include "testing_api_topology.h"

Include dependency graph for testing_api_cmd_netjail_start_cmds_helper.c:

Go to the source code of this file.

Data Structures
struct	NetJailState
	Struct to hold information for callbacks. More...
struct	TestingSystemCount
	Struct containing the number of the netjail node and the NetJailState which will be handed to callbacks specific to a test environment. More...

Macros
#define	LOG(kind, ...)   GNUNET_log (kind, __VA_ARGS__)
	Generic logging shortcut. More...

Functions
static void	clear_msg (void *cls, enum GNUNET_GenericReturnValue result)
	Continuation function from GNUNET_HELPER_send() More...
static void	handle_helper_barrier_reached (void *cls, const struct GNUNET_TESTING_CommandBarrierReached *rm)
static void	handle_helper_local_finished (void *cls, const struct GNUNET_TESTING_CommandLocalFinished *lf)
static enum GNUNET_GenericReturnValue	helper_mst (void *cls, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer. More...
static void	exp_cb (void *cls)
	Callback called if there was an exception during execution of the helper. More...
static enum GNUNET_GenericReturnValue	add_barrier (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static bool	send_start_messages (struct NetJailState *ns, struct GNUNET_HELPER_Handle *helper)
static bool	start_helper (struct NetJailState *ns, unsigned int script_num)
	Function which start a single helper process. More...
static void	do_timeout (void *cls)
	Function run when the cmd terminates (good or bad) with timeout. More...
static void	netjail_exec_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
	This function starts a helper process for each node. More...
static void	netjail_exec_cleanup (void *cls)
	Code to clean up resource this cmd used. More...
static enum GNUNET_GenericReturnValue	netjail_exec_traits (void *cls, const void **ret, const char *trait, unsigned int index)
	This function prepares an array with traits. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_netjail_start_helpers (const char *label, const char *topology_cmd_label, struct GNUNET_TIME_Relative timeout)
	Create command. More...

Detailed Description

Command to start the netjail peers.

Author

t3sserakt

Definition in file testing_api_cmd_netjail_start_cmds_helper.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log (kind, __VA_ARGS__)

Generic logging shortcut.

Definition at line 37 of file testing_api_cmd_netjail_start_cmds_helper.c.

Function Documentation

clear_msg()

static void clear_msg ( void *  cls, enum GNUNET_GenericReturnValue  result  )

static

Continuation function from GNUNET_HELPER_send()

Parameters

cls	closure
result	GNUNET_OK on success, GNUNET_NO if helper process died GNUNET_SYSERR during GNUNET_HELPER_stop

Definition at line 154 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct TestingSystemCount *tbc = cls;
  struct NetJailState *ns = tbc->ns;
 
  GNUNET_assert (NULL != tbc->shandle);
  tbc->shandle = NULL;
  GNUNET_CONTAINER_DLL_remove (ns->tbc_head,
                               ns->tbc_tail,
                               tbc);
  GNUNET_free (tbc);
  if ( (! ns->failed) &&
       (GNUNET_OK != result) )
  {
    ns->failed = true;
    GNUNET_TESTING_FAIL (ns->is);
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OK, GNUNET_TESTING_FAIL, ns, TestingSystemCount::ns, result, and TestingSystemCount::shandle.

Referenced by send_start_messages().

Here is the caller graph for this function:

handle_helper_barrier_reached()

static void handle_helper_barrier_reached ( void *  cls, const struct GNUNET_TESTING_CommandBarrierReached *  rm  )

static

Definition at line 176 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_Barrier *barrier;
 
  barrier = GNUNET_TESTING_get_barrier2_ (ns->is,
                                          &rm->barrier_key);
  if (NULL == barrier)
  {
    if (! ns->failed)
    {
      ns->failed = true;
      GNUNET_TESTING_async_fail (&ns->ac);
    }
    return;
  }
  if (barrier->inherited)
  {
    /* pass on to parent */
    GNUNET_TESTING_loop_notify_parent_ (ns->is,
                                        &rm->header);
  }
  else
  {
    barrier->reached++;
    if (barrier->reached == barrier->expected_reaches)
    {
      struct GNUNET_TESTING_CommandBarrierSatisfied cbs = {
        .header.size
          = htons (sizeof (cbs)),
        .header.type
          = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE),
        .barrier_key
          = rm->barrier_key
      };
 
      GNUNET_assert (! barrier->satisfied);
      barrier->satisfied = true;
      /* unblock children */
      GNUNET_TESTING_loop_notify_children_ (ns->is,
                                            &cbs.header);
      /* unblock self */
      for (unsigned int i = 0; i<barrier->cnt_waiting; i++)
        GNUNET_TESTING_async_finish (barrier->waiting[i]);
      GNUNET_array_grow (barrier->waiting,
                         barrier->cnt_waiting,
                         0);
    }
  }
}

References GNUNET_TESTING_CommandBarrierReached::barrier_key, GNUNET_TESTING_Barrier::cnt_waiting, GNUNET_TESTING_Barrier::expected_reaches, GNUNET_array_grow, GNUNET_assert, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE, GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), GNUNET_TESTING_get_barrier2_(), GNUNET_TESTING_loop_notify_children_(), GNUNET_TESTING_loop_notify_parent_(), GNUNET_TESTING_CommandBarrierReached::header, GNUNET_TESTING_CommandBarrierSatisfied::header, GNUNET_TESTING_Barrier::inherited, ns, GNUNET_TESTING_Barrier::reached, GNUNET_TESTING_Barrier::satisfied, GNUNET_MessageHeader::size, and GNUNET_TESTING_Barrier::waiting.

Here is the call graph for this function:

handle_helper_local_finished()

static void handle_helper_local_finished ( void *  cls, const struct GNUNET_TESTING_CommandLocalFinished *  lf  )

static

Definition at line 231 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  ns->n_finished++;
  if ( (! ns->failed) &&
       (GNUNET_OK != ntohl (lf->rv)) )
  {
    ns->failed = true;
    GNUNET_TESTING_async_fail (&ns->ac);
    return;
  }
  if (ns->n_finished == ns->n_helpers)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
    GNUNET_TESTING_async_finish (&ns->ac);
  }
}

References GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), lf(), and ns.

Here is the call graph for this function:

helper_mst()

static enum GNUNET_GenericReturnValue helper_mst ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call GNUNET_SERVER_mst_destroy in callback

Parameters

cls	closure
message	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 265 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (
      helper_barrier_reached,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED,
      struct GNUNET_TESTING_CommandBarrierReached,
      ns),
    GNUNET_MQ_hd_fixed_size (
      helper_local_finished,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED,
      struct GNUNET_TESTING_CommandLocalFinished,
      ns),
    GNUNET_MQ_handler_end ()
  };
  enum GNUNET_GenericReturnValue ret;
 
  ret = GNUNET_MQ_handle_message (handlers,
                                  message);
  if (GNUNET_OK != ret)
  {
    GNUNET_break (0);
    if (! ns->failed)
    {
      ns->failed = true;
      GNUNET_TESTING_async_fail (&ns->ac);
    }
  }
  return ret;
}

References GNUNET_break, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED, GNUNET_MQ_handle_message(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_OK, GNUNET_TESTING_async_fail(), handlers, ns, and ret.

Referenced by start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

exp_cb()

static void exp_cb ( void *  cls )

static

Callback called if there was an exception during execution of the helper.

Definition at line 303 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Called exp_cb.\n");
  if (NULL != ns->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
  }
  if (! ns->failed)
    GNUNET_TESTING_async_fail (&ns->ac);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_fail(), and ns.

Referenced by GNUNET_HELPER_start(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

add_barrier()

static enum GNUNET_GenericReturnValue add_barrier ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 320 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct GNUNET_ShortHashCode **bar_posp = cls;
  struct GNUNET_ShortHashCode *bar_pos = *bar_posp;
 
  *bar_pos = *key;
  *bar_posp = bar_pos + 1;
  return GNUNET_OK;
}

References GNUNET_OK, and key.

Referenced by send_start_messages().

Here is the caller graph for this function:

send_start_messages()

static bool send_start_messages ( struct NetJailState *  ns, struct GNUNET_HELPER_Handle *  helper  )

static

Returns

true on success

Definition at line 337 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct GNUNET_TESTING_CommandHelperInit *msg;
  struct TestingSystemCount *tbc;
  struct GNUNET_ShortHashCode *bar;
  struct GNUNET_ShortHashCode *bar_pos;
  unsigned int num_barriers = GNUNET_TESTING_barrier_count_ (ns->is);
  size_t topo_length;
  size_t msg_len;
 
  topo_length = strlen (ns->topology_data) + 1;
  GNUNET_assert (topo_length < SIZE_MAX - sizeof (*msg));
  GNUNET_assert (SIZE_MAX / sizeof (struct GNUNET_ShortHashCode) >
                 num_barriers);
  GNUNET_assert (sizeof (*msg) + topo_length <
                 SIZE_MAX
                 - num_barriers * sizeof (struct GNUNET_ShortHashCode));
  msg_len = sizeof (*msg) + topo_length
            + num_barriers * sizeof (struct GNUNET_ShortHashCode);
  if (msg_len > UINT16_MAX)
  {
    /* ask a wizard to enhance the protocol;
       start with gzip topology_data? multiple
       init messages for barriers + topo data,
       etc.*/
    GNUNET_break (0);
    return false;
  }
  msg = GNUNET_malloc (msg_len);
  msg->header.size = htons ((uint16_t) msg_len);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT);
  msg->barrier_count = htonl (num_barriers);
  bar = (struct GNUNET_ShortHashCode *) &msg[1];
  bar_pos = bar;
  GNUNET_TESTING_barrier_iterate_ (ns->is,
                                   &add_barrier,
                                   &bar_pos);
  GNUNET_assert (bar_pos == &bar[num_barriers]);
  memcpy (&bar[num_barriers],
          ns->topology_data,
          topo_length);
  tbc = GNUNET_new (struct TestingSystemCount);
  tbc->ns = ns;
  tbc->shandle = GNUNET_HELPER_send (
    helper,
    &msg->header,
    GNUNET_NO,
    &clear_msg,
    tbc);
  GNUNET_free (msg);
  if (NULL == tbc->shandle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Send handle is NULL!\n");
    GNUNET_free (tbc);
    return false;
  }
  GNUNET_CONTAINER_DLL_insert (ns->tbc_head,
                               ns->tbc_tail,
                               tbc);
  return true;
}

References add_barrier(), clear_msg(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELPER_send(), GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT, GNUNET_new, GNUNET_NO, GNUNET_TESTING_barrier_count_(), GNUNET_TESTING_barrier_iterate_(), msg, ns, TestingSystemCount::ns, TestingSystemCount::shandle, GNUNET_MessageHeader::size, SIZE_MAX, and GNUNET_MessageHeader::type.

Referenced by start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

start_helper()

static bool start_helper ( struct NetJailState *  ns, unsigned int  script_num  )

static

Function which start a single helper process.

Returns

true on success

Definition at line 407 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  char *gnunet_cmds_helper
    = GNUNET_OS_get_libexec_binary_path (HELPER_CMDS_BINARY);
  char node_id[32];
  char *data_dir;
  char *script_name;
  struct GNUNET_HELPER_Handle *helper;
 
  data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
  GNUNET_asprintf (&script_name,
                   "%s%s",
                   data_dir,
                   NETJAIL_EXEC_SCRIPT);
  GNUNET_snprintf (node_id,
                   sizeof (node_id),
                   "if%06x-%06x\n",
                   (unsigned int) getpid (),
                   script_num);
  {
    char *const script_argv[] = {
      script_name,
      node_id,
      gnunet_cmds_helper,
      node_id,
      NULL
    };
    helper = GNUNET_HELPER_start (
                                  GNUNET_YES,                             /* with control pipe */
                                  script_argv[0],
                                  script_argv,
                                  &helper_mst,
                                  &exp_cb,
                                  ns);
  }
  GNUNET_free (gnunet_cmds_helper);
  if (NULL == helper)
  {
    GNUNET_break (0);
    return false;
  }
  GNUNET_array_append (ns->helpers,
                       ns->n_helpers,
                       helper);
  GNUNET_TESTING_add_netjail_helper_ (ns->is,
                                      helper);
  GNUNET_free (data_dir);
  GNUNET_free (script_name);
  return send_start_messages (ns,
                              helper);
}

References exp_cb(), GNUNET_array_append, GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_HELPER_start(), GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_snprintf(), GNUNET_TESTING_add_netjail_helper_(), GNUNET_YES, HELPER_CMDS_BINARY, helper_mst(), NETJAIL_EXEC_SCRIPT, ns, and send_start_messages().

Referenced by netjail_exec_run().

Here is the call graph for this function:

Here is the caller graph for this function:

do_timeout()

static void do_timeout ( void *  cls )

static

Function run when the cmd terminates (good or bad) with timeout.

Parameters

cls	the interpreter state

Definition at line 467 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  ns->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Terminating cmd due to global timeout\n");
  GNUNET_TESTING_async_finish (&ns->ac);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_TESTING_async_finish(), and ns.

Referenced by netjail_exec_run().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_run()

static void netjail_exec_run ( void *  cls, struct GNUNET_TESTING_Interpreter *  is  )

static

This function starts a helper process for each node.

Parameters

cls	closure.
cmd	CMD being run.
is	interpreter state.

Definition at line 486 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_NetjailTopology *topology;
  bool failed = false;
  const struct GNUNET_TESTING_Command *topo_cmd;
 
  ns->is = is;
  topo_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                        ns->topology_cmd_label);
  if (NULL == topo_cmd)
    GNUNET_TESTING_FAIL (is);
  if (GNUNET_OK !=
      GNUNET_TESTING_get_trait_topology_string (topo_cmd,
                                                &ns->topology_data))
    GNUNET_TESTING_FAIL (is);
  topology
    = GNUNET_TESTING_get_topo_from_string_ (ns->topology_data);
  for (unsigned int i = 1; i <= topology->total; i++)
  {
    if (! start_helper (ns,
                        i))
    {
      failed = true;
      break;
    }
  }
  GNUNET_TESTING_free_topology (topology);
  if (failed)
  {
    ns->failed = true;
    GNUNET_TESTING_FAIL (is);
  }
  ns->timeout_task
    = GNUNET_SCHEDULER_add_delayed (ns->timeout,
                                    &do_timeout,
                                    ns);
}

References do_timeout(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTING_FAIL, GNUNET_TESTING_free_topology(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TESTING_interpreter_lookup_command(), is, ns, start_helper(), and GNUNET_TESTING_NetjailTopology::total.

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_cleanup()

static void netjail_exec_cleanup ( void *  cls )

static

Code to clean up resource this cmd used.

Parameters

cls

closure

Definition at line 533 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  if (NULL != ns->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
  }
  for (unsigned int i = 0; i<ns->n_helpers; i++)
    GNUNET_HELPER_stop (ns->helpers[i],
                        GNUNET_YES);
  GNUNET_free (ns);
}

References GNUNET_free, GNUNET_HELPER_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, and ns.

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_traits()

static enum GNUNET_GenericReturnValue netjail_exec_traits ( void *  cls, const void **  ret, const char *  trait, unsigned int  index  )

static

This function prepares an array with traits.

Definition at line 553 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_Trait traits[] = {
    GNUNET_TESTING_trait_end ()
  };
 
  (void) ns;
  return GNUNET_TESTING_get_trait (traits,
                                   ret,
                                   trait,
                                   index);
}

References GNUNET_TESTING_get_trait(), GNUNET_TESTING_trait_end(), GNUNET_TESTING_Trait::index, ns, ret, and traits().

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_netjail_start_helpers()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_netjail_start_helpers	(	const char *	label,
		const char *	topology_cmd_label,
		struct GNUNET_TIME_Relative	timeout
	)

Create command.

Parameters

label	Name for the command.
topology_data	topology data
timeout	Before this timeout is reached this cmd MUST finish.

Returns

command.

Definition at line 580 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns;
 
  ns = GNUNET_new (struct NetJailState);
  ns->topology_cmd_label = topology_cmd_label;
  ns->timeout = timeout;
  return GNUNET_TESTING_command_new_ac (ns,
                                        label,
                                        &netjail_exec_run,
                                        &netjail_exec_cleanup,
                                        &netjail_exec_traits,
                                        &ns->ac);
}

References GNUNET_new, GNUNET_TESTING_command_new_ac(), netjail_exec_cleanup(), netjail_exec_run(), netjail_exec_traits(), ns, timeout, and NetJailState::topology_cmd_label.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: