GNUnet  0.19.3
testing_api_cmd_netjail_start_cmds_helper.c File Reference
Include dependency graph for testing_api_cmd_netjail_start_cmds_helper.c:

Go to the source code of this file.

Data Structures

struct  HelperMessage
 Struct to store messages send/received by the helper into a DLL. More...
 
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 NETJAIL_EXEC_SCRIPT   "netjail_exec.sh"
 
#define TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
 
#define LOG(kind, ...)   GNUNET_log (kind, __VA_ARGS__)
 Generic logging shortcut. More...
 

Functions

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...
 
static void clear_msg (void *cls, int result)
 Continuation function from GNUNET_HELPER_send() More...
 
static void send_message_to_locals (unsigned int i, unsigned int j, struct NetJailState *ns, struct GNUNET_MessageHeader *header)
 
static void send_all_local_tests_prepared (unsigned int i, unsigned int j, struct NetJailState *ns)
 
static void send_all_peers_started (unsigned int i, unsigned int j, struct NetJailState *ns)
 
void barrier_attached (struct NetJailState *ns, const struct GNUNET_MessageHeader *message)
 
void barrier_reached (struct NetJailState *ns, const struct GNUNET_MessageHeader *message)
 
static int 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 struct GNUNET_TESTING_CommandHelperInitcreate_helper_init_msg_ (const char *plugin_name)
 Function to initialize a init message for the helper. More...
 
static void start_helper (struct NetJailState *ns, unsigned int m, unsigned int n)
 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...
 
struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_netjail_start_cmds_helper (const char *label, struct GNUNET_TESTING_NetjailTopology *topology, unsigned int *read_file, char *topology_data, struct GNUNET_TIME_Relative timeout)
 Create command. More...
 

Macro Definition Documentation

◆ NETJAIL_EXEC_SCRIPT

#define NETJAIL_EXEC_SCRIPT   "netjail_exec.sh"

Definition at line 34 of file testing_api_cmd_netjail_start_cmds_helper.c.

◆ TIMEOUT

◆ LOG

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

Generic logging shortcut.

Definition at line 41 of file testing_api_cmd_netjail_start_cmds_helper.c.

Function Documentation

◆ netjail_exec_cleanup()

static void netjail_exec_cleanup ( void *  cls)
static

Code to clean up resource this cmd used.

Parameters
clsclosure

Definition at line 217 of file testing_api_cmd_netjail_start_cmds_helper.c.

218 {
219  struct NetJailState *ns = cls;
220  GNUNET_free (ns);
221 }
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
#define GNUNET_free(ptr)
Wrapper around free.
Struct to hold information for callbacks.

References GNUNET_free, and ns.

◆ 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 217 of file testing_api_cmd_netjail_start_cmds_helper.c.

233 {
234  struct NetJailState *ns = cls;
235  const struct GNUNET_HELPER_Handle **helper = ns->helper;
236 
237 
238  struct GNUNET_TESTING_Trait traits[] = {
241  };
242 
243  return GNUNET_TESTING_get_trait (traits,
244  ret,
245  trait,
246  index);
247 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct GNUNET_TESTING_Trait GNUNET_TESTING_make_trait_helper_handles(const struct GNUNET_HELPER_Handle **value)
struct GNUNET_TESTING_Trait GNUNET_TESTING_trait_end(void)
"end" trait.
enum GNUNET_GenericReturnValue GNUNET_TESTING_get_trait(const struct GNUNET_TESTING_Trait *traits, const void **ret, const char *trait, unsigned int index)
Extract a trait.
The handle to a helper process.
Definition: helper.c:78
A struct GNUNET_TESTING_Trait can be used to exchange data between cmds.
unsigned int index
Index number associated with the trait.

◆ clear_msg()

static void clear_msg ( void *  cls,
int  result 
)
static

Continuation function from GNUNET_HELPER_send()

Parameters
clsclosure
resultGNUNET_OK on success, GNUNET_NO if helper process died GNUNET_SYSERR during GNUNET_HELPER_stop

Definition at line 259 of file testing_api_cmd_netjail_start_cmds_helper.c.

260 {
261  struct TestingSystemCount *tbc = cls;
262 
263  GNUNET_assert (NULL != tbc->shandle);
264  // GNUNET_free (tbc->shandle);
265  GNUNET_free (tbc->plugin);
266  tbc->shandle = NULL;
267  GNUNET_free (tbc);
268 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Struct containing the number of the netjail node and the NetJailState which will be handed to callbac...
struct GNUNET_HELPER_SendHandle * shandle
The send handle for the helper.
struct TestcasePlugin * plugin
The plugin correlated to this netjail node.

References GNUNET_assert, GNUNET_free, TestingSystemCount::plugin, and TestingSystemCount::shandle.

Referenced by send_message_to_locals(), and start_helper().

Here is the caller graph for this function:

◆ send_message_to_locals()

static void send_message_to_locals ( unsigned int  i,
unsigned int  j,
struct NetJailState ns,
struct GNUNET_MessageHeader header 
)
static

Definition at line 272 of file testing_api_cmd_netjail_start_cmds_helper.c.

278 {
279  const struct GNUNET_HELPER_Handle *helper;
280  struct TestingSystemCount *tbc;
281  unsigned int count;
282 
284  "send message of type %u to locals\n",
285  header->type);
286  tbc = GNUNET_new (struct TestingSystemCount);
287  tbc->ns = ns;
288  if (0 == i)
289  count = j;
290  else
291  count = (i - 1) * ns->local_m + j + ns->known;
292 
293  helper = ns->helper[count - 1];
294 
295 
296 
298  (struct GNUNET_HELPER_Handle *) helper,
299  header,
300  GNUNET_NO,
301  &clear_msg,
302  tbc);
303 
304  tbc->shandle = sh;
305 }
static struct SolverHandle * sh
struct GNUNET_HELPER_SendHandle * GNUNET_HELPER_send(struct GNUNET_HELPER_Handle *h, const struct GNUNET_MessageHeader *msg, int can_drop, GNUNET_HELPER_Continuation cont, void *cont_cls)
Send an message to the helper.
Definition: helper.c:614
@ GNUNET_NO
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Entry in the queue of messages we need to transmit to the helper.
Definition: helper.c:36
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct NetJailState * ns
Struct to store information handed over to callbacks.
static void clear_msg(void *cls, int result)
Continuation function from GNUNET_HELPER_send()
#define LOG(kind,...)
Generic logging shortcut.

References clear_msg(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_new, GNUNET_NO, LOG, ns, TestingSystemCount::ns, sh, TestingSystemCount::shandle, and GNUNET_MessageHeader::type.

Referenced by send_all_local_tests_prepared(), and send_all_peers_started().

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

◆ send_all_local_tests_prepared()

static void send_all_local_tests_prepared ( unsigned int  i,
unsigned int  j,
struct NetJailState ns 
)
static

Definition at line 309 of file testing_api_cmd_netjail_start_cmds_helper.c.

311 {
313  size_t msg_length;
314 
315 
316  msg_length = sizeof(struct GNUNET_TESTING_CommandAllLocalTestsPrepared);
318  reply->header.type = htons (
320  reply->header.size = htons ((uint16_t) msg_length);
321 
322  send_message_to_locals (i, j, ns, &reply->header);
323  GNUNET_free (reply);
324 }
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED.
Definition: testing_cmds.h:108
static void send_message_to_locals(unsigned int i, unsigned int j, struct NetJailState *ns, struct GNUNET_MessageHeader *header)

References GNUNET_free, GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED, GNUNET_new, GNUNET_TESTING_CommandAllLocalTestsPrepared::header, ns, send_message_to_locals(), GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by helper_mst().

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

◆ send_all_peers_started()

static void send_all_peers_started ( unsigned int  i,
unsigned int  j,
struct NetJailState ns 
)
static

Definition at line 328 of file testing_api_cmd_netjail_start_cmds_helper.c.

329 {
331  size_t msg_length;
332 
333  msg_length = sizeof(struct GNUNET_TESTING_CommandAllPeersStarted);
335  reply->header.type = htons (
337  reply->header.size = htons ((uint16_t) msg_length);
338 
339  send_message_to_locals (i, j, ns, &reply->header);
340  GNUNET_free (reply);
341 }
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED.
Definition: testing_cmds.h:78

References GNUNET_free, GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED, GNUNET_new, GNUNET_TESTING_CommandAllPeersStarted::header, ns, send_message_to_locals(), GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by helper_mst().

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

◆ barrier_attached()

void barrier_attached ( struct NetJailState ns,
const struct GNUNET_MessageHeader message 
)

Definition at line 345 of file testing_api_cmd_netjail_start_cmds_helper.c.

347 {
348  struct CommandBarrierAttached *am;
349  struct GNUNET_TESTING_NetjailNode *node;
350  struct GNUNET_TESTING_Barrier *barrier;
351  struct GNUNET_ShortHashCode key;
352  struct GNUNET_HashCode hc;
353  const char *barrier_name;
354 
355  am = (struct CommandBarrierAttached *) message;
356  barrier_name = (const char *) &am[1];
357  barrier = TST_interpreter_get_barrier (ns->is, barrier_name);
358  GNUNET_assert (NULL != barrier);
359  node = GNUNET_TESTING_barrier_get_node (barrier, am->node_number);
360  if (NULL == node)
361  {
362  node = GNUNET_new (struct GNUNET_TESTING_NetjailNode);
363  node->node_number = am->node_number;
364 
365  GNUNET_CRYPTO_hash (&(node->node_number), sizeof(node->node_number), &hc);
366  memcpy (&key, &hc, sizeof (key));
368  &key,
369  node,
371  }
373  barrier->expected_reaches = barrier->expected_reaches + am->expected_reaches;
374 }
struct GNUNET_HashCode key
The key used in the DHT.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Message send by a child loop to inform the master loop how much GNUNET_CMDS_BARRIER_REACHED messages ...
Definition: testing.h:49
uint32_t expected_reaches
How often the child loop will reach the barrier.
Definition: testing.h:58
uint32_t node_number
The number of the node the barrier is running on.
Definition: testing.h:63
A 512-bit hashcode.
A 256-bit hashcode.
struct GNUNET_CONTAINER_MultiShortmap * nodes
Hash map containing the global known nodes which are not natted.
Definition: testing.h:177
unsigned int expected_reaches
Number of commands attached to this barrier.
Definition: testing.h:192
Node in the netjail topology.
unsigned int node_number
The overall number of the node in the whole test system.
unsigned int expected_reaches
The number of cmds waiting for a specific barrier.
struct GNUNET_TESTING_NetjailNode * GNUNET_TESTING_barrier_get_node(struct GNUNET_TESTING_Barrier *barrier, unsigned int node_number)
Getting a node from a map by global node number.
struct GNUNET_TESTING_Barrier * TST_interpreter_get_barrier(struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
Getting a barrier from the interpreter.

References GNUNET_TESTING_NetjailNode::expected_reaches, CommandBarrierAttached::expected_reaches, GNUNET_TESTING_Barrier::expected_reaches, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_new, GNUNET_TESTING_barrier_get_node(), key, GNUNET_TESTING_NetjailNode::node_number, CommandBarrierAttached::node_number, GNUNET_TESTING_Barrier::nodes, ns, and TST_interpreter_get_barrier().

Referenced by helper_mst().

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

◆ barrier_reached()

void barrier_reached ( struct NetJailState ns,
const struct GNUNET_MessageHeader message 
)

Definition at line 378 of file testing_api_cmd_netjail_start_cmds_helper.c.

380 {
381  struct GNUNET_TESTING_Barrier *barrier;
382  const char *barrier_name;
383  struct GNUNET_TESTING_CommandBarrierReached *rm = (struct
385  *) message;
386 
387  barrier_name = (const char *) &rm[1];
388 
389  barrier = TST_interpreter_get_barrier (ns->is, barrier_name);
390  GNUNET_assert (NULL != barrier);
392  "barrier %s reached %p %u\n",
393  barrier_name,
394  barrier,
395  barrier->reached);
396  barrier->reached++;
398  "%u %p\n",
399  barrier->reached,
400  barrier);
401  if (GNUNET_TESTING_barrier_crossable (barrier))
402  {
404  "%s can be crossed\n",
405  barrier_name);
407  }
409  "barrier %s reached finished\n",
410  barrier_name);
411 }
const char * name
Name of the barrier.
Definition: testing.h:182
unsigned int reached
Number of commands which reached this barrier.
Definition: testing.h:197
void TST_interpreter_finish_attached_cmds(struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
Finish all "barrier reached" comands attached to this barrier.
unsigned int GNUNET_TESTING_barrier_crossable(struct GNUNET_TESTING_Barrier *barrier)
This function checks, if a barrier can be crossed, which actually means that the cmd representing the...

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_TESTING_barrier_crossable(), LOG, GNUNET_TESTING_Barrier::name, ns, GNUNET_TESTING_Barrier::reached, TST_interpreter_finish_attached_cmds(), and TST_interpreter_get_barrier().

Referenced by helper_mst().

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

◆ helper_mst()

static int 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
clsclosure
clientidentification of the client
messagethe actual message
Returns
GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 427 of file testing_api_cmd_netjail_start_cmds_helper.c.

428 {
429  struct NetJailState *ns = cls;
430  unsigned int total_number = ns->local_m * ns->global_n + ns->known;
431  uint16_t message_type = ntohs (message->type);
433 
434  switch (message_type)
435  {
437  barrier_attached (ns, message);
438  break;
440  barrier_reached (ns, message);
441  break;
443  ns->number_of_testsystems_started++;
444  break;
446  ns->number_of_peers_started++;
447  if (ns->number_of_peers_started == total_number)
448  {
449  for (int i = 1; i <= ns->known; i++)
450  {
451  send_all_peers_started (0,i, ns);
452  }
453  for (int i = 1; i <= ns->global_n; i++)
454  {
455  for (int j = 1; j <= ns->local_m; j++)
456  {
457  send_all_peers_started (i,j, ns);
458  }
459  }
460  ns->number_of_peers_started = 0;
461  }
462  break;
464  ns->number_of_local_tests_prepared++;
465  if (ns->number_of_local_tests_prepared == total_number)
466  {
467  for (int i = 1; i <= ns->known; i++)
468  {
470  }
471 
472  for (int i = 1; i <= ns->global_n; i++)
473  {
474  for (int j = 1; j <= ns->local_m; j++)
475  {
477  }
478  }
479  }
480  break;
482  lf = (struct GNUNET_TESTING_CommandLocalFinished *) message;
483 
484  ns->number_of_local_tests_finished++;
485  if (GNUNET_OK != lf->rv)
486  {
487  GNUNET_TESTING_async_fail (&(ns->ac));
488  } else if (ns->number_of_local_tests_finished == total_number)
489  {
490  GNUNET_SCHEDULER_cancel (ns->timeout_task);
491  ns->timeout_task = NULL;
493  }
494  break;
495  default:
496  // We received a message we can not handle.
497  GNUNET_assert (0);
498  }
499 
501  "total %u sysstarted %u peersstarted %u prep %u finished %u %u %u %u\n",
502  total_number,
503  ns->number_of_testsystems_started,
504  ns->number_of_peers_started,
505  ns->number_of_local_tests_prepared,
506  ns->number_of_local_tests_finished,
507  ns->local_m,
508  ns->global_n,
509  ns->known);
510 
511 
512 
513 
514  return GNUNET_OK;
515 }
void lf(char *msg)
Definition: gnunet_gst.c:587
void GNUNET_TESTING_async_finish(struct GNUNET_TESTING_AsyncContext *ac)
The asynchronous command of ac has finished.
void GNUNET_TESTING_async_fail(struct GNUNET_TESTING_AsyncContext *ac)
The asynchronous command of ac has failed.
@ GNUNET_OK
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_PEER_STARTED
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACHED
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_REPLY
The reply message from gnunet-cmds-helper.
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void barrier_attached(struct NetJailState *ns, const struct GNUNET_MessageHeader *message)
static void send_all_peers_started(unsigned int i, unsigned int j, struct NetJailState *ns)
static void send_all_local_tests_prepared(unsigned int i, unsigned int j, struct NetJailState *ns)
void barrier_reached(struct NetJailState *ns, const struct GNUNET_MessageHeader *message)

References barrier_attached(), barrier_reached(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACHED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_PEER_STARTED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_REPLY, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), lf(), LOG, ns, send_all_local_tests_prepared(), send_all_peers_started(), and GNUNET_MessageHeader::type.

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 523 of file testing_api_cmd_netjail_start_cmds_helper.c.

524 {
525  struct NetJailState *ns = cls;
526 
527  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Called exp_cb.\n");
528  if (NULL != ns->timeout_task)
529  GNUNET_SCHEDULER_cancel (ns->timeout_task);
530  GNUNET_TESTING_async_fail (&(ns->ac));
531 }
#define GNUNET_log(kind,...)

References GNUNET_ERROR_TYPE_DEBUG, 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:

◆ create_helper_init_msg_()

static struct GNUNET_TESTING_CommandHelperInit* create_helper_init_msg_ ( const char *  plugin_name)
static

Function to initialize a init message for the helper.

Parameters
plugin_nameName of the test case plugin the helper will load.

Definition at line 541 of file testing_api_cmd_netjail_start_cmds_helper.c.

542 {
544  uint16_t plugin_name_len;
545  uint16_t msg_size;
546 
547  GNUNET_assert (NULL != plugin_name);
548  plugin_name_len = strlen (plugin_name);
549  msg_size = sizeof(struct GNUNET_TESTING_CommandHelperInit) + plugin_name_len;
550  msg = GNUNET_malloc (msg_size);
551  msg->header.size = htons (msg_size);
553  msg->plugin_name_size = htons (plugin_name_len);
554  GNUNET_memcpy ((char *) &msg[1],
555  plugin_name,
556  plugin_name_len);
557  return msg;
558 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static char * plugin_name
Name of our plugin.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT
The initialization message towards gnunet-cmds-helper.
Initialization message for gnunet-cmds-testbed to start cmd binary.
Definition: testing_cmds.h:39

References GNUNET_assert, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT, msg, plugin_name, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by start_helper().

Here is the caller graph for this function:

◆ start_helper()

static void start_helper ( struct NetJailState ns,
unsigned int  m,
unsigned int  n 
)
static

Function which start a single helper process.

Definition at line 566 of file testing_api_cmd_netjail_start_cmds_helper.c.

569 {
570  struct TestcasePlugin *plugin;
571  struct GNUNET_HELPER_Handle *helper;
573  struct TestingSystemCount *tbc;
574  char *m_char;
575  char *n_char;
576  char *global_n_char;
577  char *local_m_char;
578  char *known_char;
579  char *node_id;
580  char *plugin_name;
581  char *read_file;
582  pid_t pid;
583  unsigned int script_num;
584  struct GNUNET_ShortHashCode *hkey;
585  struct GNUNET_ShortHashCode key;
586  struct GNUNET_HashCode hc;
587  struct GNUNET_TESTING_NetjailTopology *topology = ns->topology;
588  struct GNUNET_TESTING_NetjailNode *node;
589  struct GNUNET_TESTING_NetjailNode *barrier_node;
590  struct GNUNET_TESTING_NetjailNamespace *namespace;
591  char *data_dir;
592  char *script_name;
594  struct GNUNET_TESTING_Barrier *barrier;
595  struct GNUNET_TESTING_BarrierList *barriers;
596  unsigned int node_num;
597  char *binary_path;
598 
599  if (0 == n)
600  {
601  node_num = m;
602  script_num = m - 1;
603  }
604  else
605  {
606  node_num = (n - 1) * ns->local_m + m + ns->known;
607  script_num = n - 1 + (n - 1) * ns->local_m + m + ns->known;
608  }
609  pid = getpid ();
610 
611  GNUNET_asprintf (&m_char, "%u", m);
612  GNUNET_asprintf (&n_char, "%u", n);
613  GNUNET_asprintf (&local_m_char, "%u", ns->local_m);
614  GNUNET_asprintf (&global_n_char, "%u",ns->global_n);
615  GNUNET_asprintf (&known_char, "%u",ns->known);
616  GNUNET_asprintf (&node_id, "%s%06x-%06x\n",
617  "if",
618  pid,
619  script_num);
620  // GNUNET_asprintf (&topology_data, "'%s'", ns->topology_data);
621  GNUNET_asprintf (&read_file, "%u", *(ns->read_file));
622 
624  GNUNET_asprintf (&script_name, "%s%s", data_dir, NETJAIL_EXEC_SCRIPT);
625  unsigned int helper_check = GNUNET_OS_check_helper_binary (
626  script_name,
627  GNUNET_YES,
628  NULL);
629 
630  tbc = GNUNET_new (struct TestingSystemCount);
631  tbc->ns = ns;
632 
633  if (GNUNET_NO == helper_check)
634  {
636  "No SUID for %s!\n",
637  script_name);
639  }
640  else if (GNUNET_NO == helper_check)
641  {
643  "%s not found!\n",
644  script_name);
646  }
647 
649 
651  "sysstarted %u peersstarted %u prep %u finished %u %u %u %u\n",
652  ns->number_of_testsystems_started,
653  ns->number_of_peers_started,
654  ns->number_of_local_tests_prepared,
655  ns->number_of_local_tests_finished,
656  ns->local_m,
657  ns->global_n,
658  ns->known);
659  {
660  char *const script_argv[] = {script_name,
661  m_char,
662  n_char,
663  binary_path,
664  global_n_char,
665  local_m_char,
666  node_id,
667  read_file,
668  ns->topology_data,
669  NULL};
670  helper = GNUNET_HELPER_start (
671  GNUNET_YES,
672  script_name,
673  script_argv,
674  &helper_mst,
675  &exp_cb,
676  ns);
677  GNUNET_array_append (ns->helper, ns->n_helper, helper);
678  }
680  helper);
681  plugin_name = topology->plugin;
682 
683  hkey = GNUNET_new (struct GNUNET_ShortHashCode);
684  if (0 == n)
685  {
686  GNUNET_CRYPTO_hash (&m, sizeof(m), &hc);
687  memcpy (hkey,
688  &hc,
689  sizeof (*hkey));
690  if (1 == GNUNET_CONTAINER_multishortmap_contains (topology->map_globals,
691  hkey))
692  {
693  node = GNUNET_CONTAINER_multishortmap_get (topology->map_globals,
694  hkey);
695  if (NULL != node->plugin)
696  plugin_name = node->plugin;
697  }
698  }
699  else
700  {
701  GNUNET_CRYPTO_hash (&n, sizeof(n), &hc);
702  memcpy (hkey,
703  &hc,
704  sizeof (*hkey));
705  if (1 == GNUNET_CONTAINER_multishortmap_contains (topology->map_namespaces,
706  hkey))
707  {
708  namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces,
709  hkey);
710  GNUNET_CRYPTO_hash (&m, sizeof(m), &hc);
711  memcpy (hkey,
712  &hc,
713  sizeof (*hkey));
714  if (1 == GNUNET_CONTAINER_multishortmap_contains (namespace->nodes,
715  hkey))
716  {
717  node = GNUNET_CONTAINER_multishortmap_get (namespace->nodes,
718  hkey);
719  if (NULL != node->plugin)
720  plugin_name = node->plugin;
721  }
722  }
723 
724 
725  }
726  GNUNET_assert (NULL != node);
727  node->node_number = node_num;
728  plugin = GNUNET_new (struct TestcasePlugin);
730  NULL);
731  barriers = plugin->api->get_waiting_for_barriers ();
732 
733 
734  for (pos = barriers->head; NULL != pos; pos = pos->next)
735  {
736  barrier = TST_interpreter_get_barrier (ns->is, pos->barrier_name);
737  if (NULL == barrier)
738  {
740  "barrier %s added\n",
741  pos->barrier_name);
742  barrier = GNUNET_new (struct GNUNET_TESTING_Barrier);
743  barrier->name = pos->barrier_name;
744  barrier->shadow = GNUNET_YES;
745  TST_interpreter_add_barrier (ns->is, barrier);
746 
748  "%u %p\n",
749  barrier->reached,
750  barrier);
751 
753  }
755  "barrier %p %s node %u added \n",
756  barrier,
757  pos->barrier_name,
758  node->node_number);
759  barrier_node = GNUNET_new (struct GNUNET_TESTING_NetjailNode);
760  barrier_node->node_number = node->node_number;
761  barrier_node->expected_reaches = pos->expected_reaches;
762  barrier->expected_reaches = barrier->expected_reaches
763  + pos->expected_reaches;
765  "number_to_be_reached %u\n",
766  barrier->number_to_be_reached);
767  if (GNUNET_YES == barrier->shadow)
768  barrier->number_to_be_reached++;
770  "number_to_be_reached %u\n",
771  barrier->number_to_be_reached);
772  GNUNET_CRYPTO_hash (&(node->node_number), sizeof(node->node_number), &hc);
773  memcpy (&key, &hc, sizeof (key));
775  &key,
776  barrier_node,
778  }
779 
780  tbc->plugin = plugin;
781 
783 
784  tbc->shandle = GNUNET_HELPER_send (
785  helper,
786  &msg->header,
787  GNUNET_NO,
788  &clear_msg,
789  tbc);
790 
791  if (NULL == tbc->shandle)
792  {
794  "Send handle is NULL!\n");
796  }
797  GNUNET_free (pos);
798  GNUNET_free (binary_path);
799  GNUNET_free (hkey);
800  GNUNET_free (msg);
801  GNUNET_free (m_char);
802  GNUNET_free (n_char);
803  GNUNET_free (local_m_char);
804  GNUNET_free (global_n_char);
805  GNUNET_free (known_char);
806  GNUNET_free (node_id);
808  GNUNET_free (data_dir);
809  GNUNET_free (script_name);
810  GNUNET_free (barriers);
811 }
enum GNUNET_TESTBED_TopologyOption topology
The topology to generate.
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
struct TestcasePlugin * plugin
The process handle to the testbed service.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
void GNUNET_TESTING_interpreter_fail(struct GNUNET_TESTING_Interpreter *is)
Current command failed, clean up and fail the test case.
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
void * GNUNET_CONTAINER_multishortmap_get(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multishortmap_contains(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
struct GNUNET_HELPER_Handle * GNUNET_HELPER_start(int with_control_pipe, const char *binary_name, char *const binary_argv[], GNUNET_MessageTokenizerCallback cb, GNUNET_HELPER_ExceptionCallback exp_cb, void *cb_cls)
Starts a helper and begins reading from it.
Definition: helper.c:461
@ GNUNET_YES
@ GNUNET_ERROR_TYPE_ERROR
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
char * GNUNET_OS_get_libexec_binary_path(const char *progname)
Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the ...
enum GNUNET_GenericReturnValue GNUNET_OS_check_helper_binary(const char *binary, bool check_suid, const char *params)
Check whether an executable exists and possibly if the suid bit is set on the file.
char * GNUNET_OS_installation_get_path(enum GNUNET_OS_InstallationPathKind dirkind)
Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX,...
@ GNUNET_OS_IPK_DATADIR
Return the directory where data is installed (share/gnunet/)
void * GNUNET_PLUGIN_load(const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition: plugin.c:198
enum GNUNET_GenericReturnValue read_file(char const *const filename, char **buffer)
Definition: pabc_helper.c:71
An entry for a barrier list.
unsigned int expected_reaches
Number of commands attached to the barrier.
struct GNUNET_TESTING_BarrierListEntry * next
A list to hold barriers provided by plugins.
struct GNUNET_TESTING_BarrierListEntry * head
List head.
unsigned int shadow
Definition: testing.h:214
unsigned int number_to_be_reached
Number of commands which need to reach the barrier to change state.
Definition: testing.h:209
char * plugin
Plugin for the test case to be run on this node.
GNUNET_TESTING_PLUGIN_GET_WAITING_FOR_BARRIERS get_waiting_for_barriers
Handle for a plugin.
Definition: testing.h:94
struct GNUNET_TESTING_PluginFunctions * api
Plugin API.
Definition: testing.h:103
void TST_interpreter_add_barrier(struct GNUNET_TESTING_Interpreter *is, struct GNUNET_TESTING_Barrier *barrier)
Add a barrier to the loop.
static struct GNUNET_TESTING_CommandHelperInit * create_helper_init_msg_(const char *plugin_name)
Function to initialize a init message for the helper.
static void exp_cb(void *cls)
Callback called if there was an exception during execution of the helper.
static int helper_mst(void *cls, const struct GNUNET_MessageHeader *message)
Functions with this signature are called whenever a complete message is received by the tokenizer.
void GNUNET_TESTING_add_netjail_helper(struct GNUNET_TESTING_Interpreter *is, const struct GNUNET_HELPER_Handle *helper)
Adding a helper handle to the interpreter.
#define HELPER_CMDS_BINARY
Definition: testing_cmds.h:30

References TestcasePlugin::api, GNUNET_TESTING_BarrierListEntry::barrier_name, clear_msg(), create_helper_init_msg_(), exp_cb(), GNUNET_TESTING_BarrierListEntry::expected_reaches, GNUNET_TESTING_NetjailNode::expected_reaches, GNUNET_TESTING_Barrier::expected_reaches, GNUNET_TESTING_PluginFunctions::get_waiting_for_barriers, GNUNET_array_append, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multishortmap_contains(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELPER_send(), GNUNET_HELPER_start(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_PLUGIN_load(), GNUNET_TESTING_add_netjail_helper(), GNUNET_TESTING_interpreter_fail(), GNUNET_YES, GNUNET_TESTING_BarrierList::head, HELPER_CMDS_BINARY, helper_mst(), key, LOG, m, msg, GNUNET_TESTING_Barrier::name, NETJAIL_EXEC_SCRIPT, GNUNET_TESTING_BarrierListEntry::next, GNUNET_TESTING_NetjailNode::node_number, GNUNET_TESTING_Barrier::nodes, ns, TestingSystemCount::ns, GNUNET_TESTING_Barrier::number_to_be_reached, pid, GNUNET_TESTING_NetjailNode::plugin, plugin, TestingSystemCount::plugin, plugin_name, GNUNET_TESTING_Barrier::reached, read_file(), GNUNET_TESTING_Barrier::shadow, TestingSystemCount::shandle, topology, TST_interpreter_add_barrier(), and TST_interpreter_get_barrier().

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
clsthe interpreter state

Definition at line 820 of file testing_api_cmd_netjail_start_cmds_helper.c.

821 {
822  struct NetJailState *ns = cls;
823  struct GNUNET_TESTING_Command *cmd;
824 
825  ns->timeout_task = NULL;
827  "Terminating cmd due to global timeout\n");
830 }
A command to be run by the interpreter.
struct GNUNET_TESTING_AsyncContext * ac
Pointer to the asynchronous context in the command's closure.
struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_get_current_command(struct GNUNET_TESTING_Interpreter *is)
Returns the actual running command.

References GNUNET_TESTING_Command::ac, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_TESTING_async_finish(), GNUNET_TESTING_interpreter_get_current_command(), 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
clsclosure.
cmdCMD being run.
isinterpreter state.

Definition at line 841 of file testing_api_cmd_netjail_start_cmds_helper.c.

843 {
844  struct NetJailState *ns = cls;
845 
846  ns->is = is;
847  for (int i = 1; i <= ns->known; i++)
848  {
850  "i %u\n",
851  i);
852  start_helper (ns,
853  i,
854  0);
855  }
856 
857  for (int i = 1; i <= ns->global_n; i++)
858  {
859  for (int j = 1; j <= ns->local_m; j++)
860  {
862  "i %u j %u\n",
863  i,
864  j);
865  start_helper (ns,
866  j,
867  i);
868  }
869  }
871  "Adding timeout %s\n",
873  ns->timeout_task
874  = GNUNET_SCHEDULER_add_delayed (ns->timeout,
875  &do_timeout,
876  ns);
877 }
struct GNUNET_TESTING_Interpreter * is
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569
static void do_timeout(void *cls)
Function run when the cmd terminates (good or bad) with timeout.
static void start_helper(struct NetJailState *ns, unsigned int m, unsigned int n)
Function which start a single helper process.

References do_timeout(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), is, ns, and start_helper().

Here is the call graph for this function:

◆ GNUNET_TESTING_cmd_netjail_start_cmds_helper()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_netjail_start_cmds_helper ( const char *  label,
struct GNUNET_TESTING_NetjailTopology topology,
unsigned int *  read_file,
char *  topology_data,
struct GNUNET_TIME_Relative  timeout 
)

Create command.

This command executes a shell script which starts a helper process.

Parameters
labelName for the command.
topologyThe complete topology information.
read_fileFlag indicating if the the name of the topology file is send to the helper, or a string with the topology data.
topology_dataIf read_file is GNUNET_NO, topology_data holds the string with the topology.
timeoutBefore this timeout is reached this cmd MUST finish.
Returns
command.

Definition at line 841 of file testing_api_cmd_netjail_start_cmds_helper.c.

897 {
898  struct NetJailState *ns;
899 
900  ns = GNUNET_new (struct NetJailState);
901  ns->local_m = topology->nodes_m;
902  ns->global_n = topology->namespaces_n;
903  ns->known = topology->nodes_x;
904  ns->plugin_name = topology->plugin;
905  ns->topology = topology;
906  ns->read_file = read_file;
907  ns->topology_data = topology_data;
909 
910  return GNUNET_TESTING_command_new (ns, label,
914  &ns->ac);
915 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
struct GNUNET_TESTING_Command GNUNET_TESTING_command_new(void *cls, const char *label, GNUNET_TESTING_CommandRunRoutine run, GNUNET_TESTING_CommandCleanupRoutine cleanup, GNUNET_TESTING_CommandGetTraits traits, struct GNUNET_TESTING_AsyncContext *ac)
Create a new command.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:603
char * topology_data
String with topology data or name of topology file.
static void netjail_exec_cleanup(void *cls)
Code to clean up resource this cmd used.
static void netjail_exec_run(void *cls, struct GNUNET_TESTING_Interpreter *is)
This function starts a helper process for each node.
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.