GNUnet  0.10.x
Data Structures | Macros | Enumerations | Functions
testbed_api_testbed.c File Reference

high-level testbed management More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "testbed_api.h"
#include "testbed_api_peers.h"
#include "testbed_api_hosts.h"
#include "testbed_api_topology.h"
Include dependency graph for testbed_api_testbed.c:

Go to the source code of this file.

Data Structures

struct  RunContextOperation
 Context information for the operation we start. More...
 
struct  CompatibilityCheckContext
 Context for host compability checks. More...
 
struct  GNUNET_TESTBED_RunHandle
 Testbed Run Handle. More...
 
struct  SearchContext
 Context information to be used while searching for operation contexts. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)
 Generic loggins shorthand. More...
 
#define DEBUG(...)   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 Debug logging shortcut. More...
 
#define DEFAULT_SETUP_TIMEOUT   300
 The default setup timeout in seconds. More...
 
#define TESTBED_CONFIG_SECTION   "testbed"
 Configuration section for testbed. More...
 
#define SCALE_FREE_CAP   "SCALE_FREE_TOPOLOGY_CAP"
 Option string for the maximum number of edges a peer is permitted to have while generating scale free topology. More...
 
#define SCALE_FREE_M   "SCALE_FREE_TOPOLOGY_M"
 Option string for the number of edges to be established when adding a new node to the scale free network. More...
 

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
}
 States of RunContext. More...
 

Functions

static uint32_t rcop_key (void *rcop)
 Return a 32-bit key from a pointer. More...
 
static int search_iterator (void *cls, uint32_t key, void *value)
 Iterator for searching over the elements matching a given query. More...
 
static struct RunContextOperationsearch_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct GNUNET_TESTBED_Operation *op)
 Initiate a search for the given operation in the rcop_map. More...
 
static void insert_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
 Insert an RunContextOperation into the rcop_map of the given RunContext. More...
 
static void remove_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
 Remove a RunContextOperation from the rcop_map of the given RunContext. More...
 
static void cleanup (struct GNUNET_TESTBED_RunHandle *rc)
 Assuming all peers have been destroyed cleanup run handle. More...
 
static int rcop_cleanup_iterator (void *cls, uint32_t key, void *value)
 Iterator for cleaning up elements from rcop_map. More...
 
static void rc_cleanup_operations (struct GNUNET_TESTBED_RunHandle *rc)
 Cancels operations and tasks which are assigned to the given run context. More...
 
static void cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc)
 Cancels the scheduled interrupt task. More...
 
static void wait_op_completion (void *cls)
 This callback will be called when all the operations are completed (done/cancelled) More...
 
static void interrupt (void *cls)
 Task run upon interrupts (SIGINT, SIGTERM) and upon scheduler shutdown. More...
 
static const char * prof_time (struct GNUNET_TESTBED_RunHandle *rc)
 Function to return the string representation of the duration between current time and `pstart_time' in `RunContext'. More...
 
static void start_peers_task (void *cls)
 Task for starting peers. More...
 
static void peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
 Functions of this signature are called when a peer has been successfully created. More...
 
static void call_master (struct GNUNET_TESTBED_RunHandle *rc)
 call test master callback More...
 
static void topology_completion_callback (void *cls, unsigned int nsuccess, unsigned int nfailures)
 Callbacks of this type are called when topology configuration is completed. More...
 
static void create_peers (struct GNUNET_TESTBED_RunHandle *rc)
 Function to create peers. More...
 
static void event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
 Signature of the event handler function called by the respective event controller. More...
 
static void register_hosts (void *cls)
 Task to register all hosts available in the global host list. More...
 
static void host_registration_completion (void *cls, const char *emsg)
 Callback which will be called to after a host registration succeeded or failed. More...
 
static void controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, int status)
 Callback to signal successfull startup of the controller process. More...
 
static int netint_proc (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
 Callback function invoked for each interface found. More...
 
static void host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status)
 Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to inform whether the given host is habitable or not. More...
 
static void timeout_task (void *cls)
 Task run upon timeout while setting up the testbed. More...
 
void GNUNET_TESTBED_run (const char *host_filename, const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int num_peers, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls, GNUNET_TESTBED_TestMaster test_master, void *test_master_cls)
 Convenience method for running a testbed with a single call. More...
 
struct GNUNET_TESTBED_ControllerGNUNET_TESTBED_run_get_controller_handle (struct GNUNET_TESTBED_RunHandle *h)
 Obtain handle to the master controller from a testbed run. More...
 

Detailed Description

high-level testbed management

Author
Christian Grothoff
Sree Harsha Totakura

Definition in file testbed_api_testbed.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)

◆ DEBUG

#define DEBUG (   ...)    LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

◆ DEFAULT_SETUP_TIMEOUT

#define DEFAULT_SETUP_TIMEOUT   300

The default setup timeout in seconds.

Definition at line 51 of file testbed_api_testbed.c.

Referenced by GNUNET_TESTBED_run().

◆ TESTBED_CONFIG_SECTION

#define TESTBED_CONFIG_SECTION   "testbed"

Configuration section for testbed.

Definition at line 57 of file testbed_api_testbed.c.

Referenced by event_cb(), and GNUNET_TESTBED_run().

◆ SCALE_FREE_CAP

#define SCALE_FREE_CAP   "SCALE_FREE_TOPOLOGY_CAP"

Option string for the maximum number of edges a peer is permitted to have while generating scale free topology.

Definition at line 63 of file testbed_api_testbed.c.

Referenced by event_cb(), and GNUNET_TESTBED_run().

◆ SCALE_FREE_M

#define SCALE_FREE_M   "SCALE_FREE_TOPOLOGY_M"

Option string for the number of edges to be established when adding a new node to the scale free network.

Definition at line 69 of file testbed_api_testbed.c.

Referenced by event_cb(), and GNUNET_TESTBED_run().

Enumeration Type Documentation

◆ State

enum State

States of RunContext.

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 97 of file testbed_api_testbed.c.

98 {
102  RC_INIT = 0,
103 
107  RC_LINKED,
108 
113 
119  RC_READY,
120 
121  /* /\** */
122  /* * Peers are stopped */
123  /* *\/ */
124  /* RC_PEERS_STOPPED, */
125 
126  /* /\** */
127  /* * Peers are destroyed */
128  /* *\/ */
129  /* RC_PEERS_DESTROYED */
130 
135 };
The testbed run is ready and the master callback can be called now.
Controllers on given hosts started and linked.
Peers are created.
Initial state.
All peers shutdown (stopped and destroyed)

Function Documentation

◆ rcop_key()

static uint32_t rcop_key ( void *  rcop)
static

Return a 32-bit key from a pointer.

Parameters
rcopthe pointer
Returns
32-bit key

Definition at line 340 of file testbed_api_testbed.c.

Referenced by insert_rcop(), remove_rcop(), and search_rcop().

341 {
342  return * ((uint32_t *) &rcop);
343 }
Here is the caller graph for this function:

◆ search_iterator()

static int search_iterator ( void *  cls,
uint32_t  key,
void *  value 
)
static

Iterator for searching over the elements matching a given query.

Parameters
clsthe SearchContext
keythe 32-bit key
valuethe RunContextOperation element
Returns
GNUNET_YES to continue iteration; GNUNET_NO to cancel it

Definition at line 372 of file testbed_api_testbed.c.

References RunContextOperation::cls, GNUNET_assert, GNUNET_NO, GNUNET_YES, RunContextOperation::op, SearchContext::query, SearchContext::result, sc, and value.

Referenced by search_rcop().

373 {
374  struct RunContextOperation *rcop = value;
375  struct SearchContext *sc = cls;
376 
377  GNUNET_assert (NULL != rcop);
378  if (sc->query == rcop->op)
379  {
380  GNUNET_assert (NULL == sc->result);
381  sc->result = rcop;
382  return GNUNET_NO;
383  }
384  return GNUNET_YES;
385 }
Context information for the operation we start.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:81
static char * value
Value of the record to add/remove.
struct RunContextOperation * result
The Run context operation which has the operation being queried.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_TESTBED_Operation * query
The operation pointer to look for.
Context information to be used while searching for operation contexts.
Definition: testbed_api.c:233
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the caller graph for this function:

◆ search_rcop()

static struct RunContextOperation* search_rcop ( struct GNUNET_TESTBED_RunHandle rc,
struct GNUNET_TESTBED_Operation op 
)
static

Initiate a search for the given operation in the rcop_map.

Parameters
rcthe RunContext whose rcop_map will be searched for the given operation
opthe given operation to search for
Returns
the matching RunContextOperation if found; NULL if not

Definition at line 397 of file testbed_api_testbed.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, RunContextOperation::op, SearchContext::query, rcop_key(), GNUNET_TESTBED_RunHandle::rcop_map, SearchContext::result, and search_iterator().

Referenced by event_cb().

398 {
399  struct SearchContext sc;
400 
401  sc.query = op;
402  sc.result = NULL;
403  if (GNUNET_SYSERR ==
405  rcop_key (op),
407  &sc))
408  {
409  GNUNET_assert (NULL != sc.result);
410  return sc.result;
411  }
412  return NULL;
413 }
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_CONTAINER_multihashmap32_get_multiple(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
static uint32_t rcop_key(void *rcop)
Return a 32-bit key from a pointer.
static int search_iterator(void *cls, uint32_t key, void *value)
Iterator for searching over the elements matching a given query.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Context information to be used while searching for operation contexts.
Definition: testbed_api.c:233
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
Here is the call graph for this function:
Here is the caller graph for this function:

◆ insert_rcop()

static void insert_rcop ( struct GNUNET_TESTBED_RunHandle rc,
struct RunContextOperation rcop 
)
static

Insert an RunContextOperation into the rcop_map of the given RunContext.

Parameters
rcthe RunContext into whose map is to be used for insertion
rcopthe RunContextOperation to insert

Definition at line 423 of file testbed_api_testbed.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_OK, RunContextOperation::op, rcop_key(), and GNUNET_TESTBED_RunHandle::rcop_map.

Referenced by create_peers(), register_hosts(), start_peers_task(), and wait_op_completion().

424 {
427  rcop_key (rcop->op), rcop,
429 }
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static uint32_t rcop_key(void *rcop)
Return a 32-bit key from a pointer.
Allow multiple values with the same key.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ remove_rcop()

static void remove_rcop ( struct GNUNET_TESTBED_RunHandle rc,
struct RunContextOperation rcop 
)
static

Remove a RunContextOperation from the rcop_map of the given RunContext.

Parameters
rcthe RunContext from whose map the given RunContextOperaton has to be removed
rcopthe RunContextOperation

Definition at line 440 of file testbed_api_testbed.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_YES, RunContextOperation::op, rcop_key(), and GNUNET_TESTBED_RunHandle::rcop_map.

Referenced by event_cb(), peer_create_cb(), and rcop_cleanup_iterator().

441 {
444  rcop_key (rcop->op),
445  rcop));
446 }
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static uint32_t rcop_key(void *rcop)
Return a 32-bit key from a pointer.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_YES
Definition: gnunet_common.h:80
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup()

static void cleanup ( struct GNUNET_TESTBED_RunHandle rc)
static

Assuming all peers have been destroyed cleanup run handle.

Parameters
rcthe run context

Definition at line 454 of file testbed_api_testbed.c.

References GNUNET_TESTBED_RunHandle::c, GNUNET_TESTBED_RunHandle::cfg, GNUNET_TESTBED_RunHandle::cproc, GNUNET_assert, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_free, GNUNET_free_non_null, GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_controller_stop(), GNUNET_TESTBED_host_destroy(), GNUNET_TESTBED_RunHandle::h, GNUNET_TESTBED_RunHandle::hclist, GNUNET_TESTBED_RunHandle::hosts, GNUNET_TESTBED_RunHandle::num_hosts, GNUNET_TESTBED_RunHandle::peers, RC_PEERS_SHUTDOWN, GNUNET_TESTBED_RunHandle::rcop_map, GNUNET_TESTBED_RunHandle::reg_handle, GNUNET_TESTBED_RunHandle::register_hosts_task, GNUNET_TESTBED_RunHandle::state, GNUNET_TESTBED_RunHandle::topo_file, and GNUNET_TESTBED_RunHandle::trusted_ip.

Referenced by wait_op_completion().

455 {
456  unsigned int hid;
457 
458  GNUNET_assert (NULL == rc->register_hosts_task);
459  GNUNET_assert (NULL == rc->reg_handle);
460  GNUNET_assert (NULL == rc->peers);
461  GNUNET_assert (NULL == rc->hclist);
465  if (NULL != rc->c)
467  if (NULL != rc->cproc)
469  if (NULL != rc->h)
471  for (hid = 0; hid < rc->num_hosts; hid++)
474  if (NULL != rc->cfg)
478  GNUNET_free (rc);
479 }
void GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c)
Stop the given controller (also will terminate all peers and controllers dependent on this controller...
Definition: testbed_api.c:1723
enum State state
State of this context.
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
void GNUNET_TESTBED_controller_stop(struct GNUNET_TESTBED_ControllerProc *cproc)
Stop the controller process (also will terminate all peers and controllers dependent on this controll...
struct GNUNET_TESTBED_ControllerProc * cproc
The handle to the controller process.
char * trusted_ip
The trusted IP string.
struct GNUNET_TESTBED_Controller * c
The controller handle.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
char * topo_file
The file containing topology data.
struct CompatibilityCheckContext * hclist
Array of compatibility check contexts.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
void GNUNET_TESTBED_host_destroy(struct GNUNET_TESTBED_Host *host)
Destroy a host handle.
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the controller.
struct GNUNET_TESTBED_Host ** hosts
An array of hosts loaded from the hostkeys file.
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
#define GNUNET_free(ptr)
Wrapper around free.
All peers shutdown (stopped and destroyed)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rcop_cleanup_iterator()

static int rcop_cleanup_iterator ( void *  cls,
uint32_t  key,
void *  value 
)
static

Iterator for cleaning up elements from rcop_map.

Parameters
clsthe RunContext
keythe 32-bit key
valuethe RunContextOperation element
Returns
always GNUNET_YES

Definition at line 491 of file testbed_api_testbed.c.

References RunContextOperation::cls, GNUNET_assert, GNUNET_free, GNUNET_TESTBED_operation_done(), GNUNET_YES, RunContextOperation::op, RunContextOperation::rc, remove_rcop(), and value.

Referenced by rc_cleanup_operations().

492 {
493  struct GNUNET_TESTBED_RunHandle *rc = cls;
494  struct RunContextOperation *rcop = value;
495 
496  GNUNET_assert (rc == rcop->rc);
497  remove_rcop (rc, rcop);
499  GNUNET_free (rcop);
500  return GNUNET_YES;
501 }
Context information for the operation we start.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
static char * value
Value of the record to add/remove.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
static void remove_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Remove a RunContextOperation from the rcop_map of the given RunContext.
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rc_cleanup_operations()

static void rc_cleanup_operations ( struct GNUNET_TESTBED_RunHandle rc)
static

Cancels operations and tasks which are assigned to the given run context.

Parameters
rcthe RunContext

Definition at line 510 of file testbed_api_testbed.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TESTBED_cancel_registration(), GNUNET_TESTBED_is_host_habitable_cancel(), GNUNET_TESTBED_operation_done(), CompatibilityCheckContext::h, GNUNET_TESTBED_RunHandle::hclist, GNUNET_TESTBED_RunHandle::num_hosts, rcop_cleanup_iterator(), GNUNET_TESTBED_RunHandle::rcop_map, GNUNET_TESTBED_RunHandle::reg_handle, GNUNET_TESTBED_RunHandle::register_hosts_task, GNUNET_TESTBED_RunHandle::timeout_task, and GNUNET_TESTBED_RunHandle::topology_operation.

Referenced by interrupt().

511 {
512  struct CompatibilityCheckContext *hc;
513  unsigned int nhost;
514 
515  if (NULL != rc->hclist)
516  {
517  for (nhost = 0; nhost < rc->num_hosts; nhost++)
518  {
519  hc = &rc->hclist[nhost];
520  if (NULL != hc->h)
522  }
523  GNUNET_free (rc->hclist);
524  rc->hclist = NULL;
525  }
526  /* Stop register hosts task if it is running */
527  if (NULL != rc->register_hosts_task)
528  {
530  rc->register_hosts_task = NULL;
531  }
532  if (NULL != rc->timeout_task)
533  {
535  rc->timeout_task = NULL;
536  }
537  if (NULL != rc->reg_handle)
538  {
540  rc->reg_handle = NULL;
541  }
542  if (NULL != rc->topology_operation)
543  {
545  rc->topology_operation = NULL;
546  }
547  /* cancel any exiting operations */
551  rc));
552 }
void GNUNET_TESTBED_cancel_registration(struct GNUNET_TESTBED_HostRegistrationHandle *handle)
Cancel the pending registration.
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run of a timeout.
void GNUNET_TESTBED_is_host_habitable_cancel(struct GNUNET_TESTBED_HostHabitableCheckHandle *handle)
Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
Context for host compability checks.
struct GNUNET_TESTBED_HostHabitableCheckHandle * h
Handle for the compability check.
struct CompatibilityCheckContext * hclist
Array of compatibility check contexts.
struct GNUNET_TESTBED_Operation * topology_operation
The topology generation operation.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
static int rcop_cleanup_iterator(void *cls, uint32_t key, void *value)
Iterator for cleaning up elements from rcop_map.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cancel_interrupt_task()

static void cancel_interrupt_task ( struct GNUNET_TESTBED_RunHandle rc)
static

Cancels the scheduled interrupt task.

Parameters
rcthe run context

Definition at line 561 of file testbed_api_testbed.c.

References GNUNET_SCHEDULER_cancel(), and GNUNET_TESTBED_RunHandle::interrupt_task.

Referenced by wait_op_completion().

562 {
564  rc->interrupt_task = NULL;
565 }
struct GNUNET_SCHEDULER_Task * interrupt_task
Task run upon shutdown interrupts.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ wait_op_completion()

static void wait_op_completion ( void *  cls)
static

This callback will be called when all the operations are completed (done/cancelled)

Parameters
clsrun context

Definition at line 575 of file testbed_api_testbed.c.

References GNUNET_TESTBED_RunHandle::c, cancel_interrupt_task(), cleanup(), RunContextOperation::cls, GNUNET_TESTBED_RunHandle::cproc, DEBUG, GNUNET_assert, GNUNET_free, GNUNET_new, GNUNET_TESTBED_shutdown_peers(), GNUNET_TIME_absolute_get(), GNUNET_YES, insert_rcop(), RunContextOperation::op, GNUNET_TESTBED_RunHandle::peers, GNUNET_TESTBED_RunHandle::pstart_time, RunContextOperation::rc, RC_PEERS_SHUTDOWN, GNUNET_TESTBED_RunHandle::shutdown, and GNUNET_TESTBED_RunHandle::state.

Referenced by interrupt().

576 {
577  struct GNUNET_TESTBED_RunHandle *rc = cls;
578  struct RunContextOperation *rcop;
579 
580  if ( (NULL == rc->cproc)
581  || (NULL == rc->c)
582  || (GNUNET_YES == rc->shutdown) )
583  {
584  if (NULL != rc->peers)
585  {
586  GNUNET_free (rc->peers);
587  rc->peers = NULL;
588  }
589  goto cleanup_;
590  }
591  if (NULL == rc->peers)
592  goto cleanup_;
593  rc->shutdown = GNUNET_YES;
594  rcop = GNUNET_new (struct RunContextOperation);
595  rcop->rc = rc;
596  rcop->op = GNUNET_TESTBED_shutdown_peers (rc->c, rcop, NULL, NULL);
597  GNUNET_assert (NULL != rcop->op);
598  DEBUG ("Shutting down peers\n");
600  insert_rcop (rc, rcop);
601  return;
602 
603  cleanup_:
604  rc->state = RC_PEERS_SHUTDOWN;
606  cleanup (rc);
607 }
Context information for the operation we start.
enum State state
State of this context.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
static void insert_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Insert an RunContextOperation into the rcop_map of the given RunContext.
struct GNUNET_TESTBED_ControllerProc * cproc
The handle to the controller process.
struct GNUNET_TESTBED_Controller * c
The controller handle.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static void cancel_interrupt_task(struct GNUNET_TESTBED_RunHandle *rc)
Cancels the scheduled interrupt task.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_shutdown_peers(struct GNUNET_TESTBED_Controller *c, void *op_cls, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls)
Stops and destroys all peers.
Definition: testbed_api.c:2288
static void cleanup(struct GNUNET_TESTBED_RunHandle *rc)
Assuming all peers have been destroyed cleanup run handle.
int shutdown
Have we already shutdown.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
All peers shutdown (stopped and destroyed)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ interrupt()

static void interrupt ( void *  cls)
static

Task run upon interrupts (SIGINT, SIGTERM) and upon scheduler shutdown.

Parameters
clsthe RunContext which has to be acted upon

Definition at line 616 of file testbed_api_testbed.c.

References GNUNET_TESTBED_RunHandle::c, RunContextOperation::cls, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_RunHandle::interrupt_task, LOG, GNUNET_TESTBED_Controller::opc_map, GNUNET_TESTBED_Controller::opcq_empty_cb, GNUNET_TESTBED_Controller::opcq_empty_cls, RunContextOperation::rc, rc_cleanup_operations(), GNUNET_TESTBED_RunHandle::shutdown, size, and wait_op_completion().

Referenced by GNUNET_TESTBED_run().

617 {
618  struct GNUNET_TESTBED_RunHandle *rc = cls;
619  struct GNUNET_TESTBED_Controller *c = rc->c;
620  unsigned int size;
621 
622  /* reschedule */
625  if ( (GNUNET_NO == rc->shutdown) &&
626  (NULL != c) &&
627  (NULL != c->opc_map) &&
628  (0 != (size = GNUNET_CONTAINER_multihashmap32_size (c->opc_map))))
629  {
631  "Shutdown postponed as there are %u operations currently active\n",
632  size);
634  c->opcq_empty_cls = rc;
635  return;
636  }
637  wait_op_completion (rc);
638 }
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:194
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
TESTBED_opcq_empty_cb opcq_empty_cb
If this callback is not NULL, schedule it as a task when opc_map gets empty.
Definition: testbed_api.h:235
static void wait_op_completion(void *cls)
This callback will be called when all the operations are completed (done/cancelled) ...
struct GNUNET_TESTBED_Controller * c
The controller handle.
#define GNUNET_NO
Definition: gnunet_common.h:81
static void interrupt(void *cls)
Task run upon interrupts (SIGINT, SIGTERM) and upon scheduler shutdown.
struct GNUNET_SCHEDULER_Task * interrupt_task
Task run upon shutdown interrupts.
#define LOG(kind,...)
Generic loggins shorthand.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_MultiHashMap32 * opc_map
The map of active operation contexts.
Definition: testbed_api.h:230
static unsigned int size
Size of the "table".
Definition: peer.c:67
void * opcq_empty_cls
Closure for the above task.
Definition: testbed_api.h:240
static void rc_cleanup_operations(struct GNUNET_TESTBED_RunHandle *rc)
Cancels operations and tasks which are assigned to the given run context.
int shutdown
Have we already shutdown.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ prof_time()

static const char* prof_time ( struct GNUNET_TESTBED_RunHandle rc)
static

Function to return the string representation of the duration between current time and `pstart_time' in `RunContext'.

Parameters
rcthe RunContext
Returns
the representation string; this is NOT reentrant

Definition at line 649 of file testbed_api_testbed.c.

References GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, and GNUNET_TESTBED_RunHandle::pstart_time.

Referenced by event_cb(), peer_create_cb(), and topology_completion_callback().

650 {
651  struct GNUNET_TIME_Relative ptime;
652 
655 }
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
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:727
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
#define GNUNET_YES
Definition: gnunet_common.h:80
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ start_peers_task()

static void start_peers_task ( void *  cls)
static

Task for starting peers.

Parameters
clsthe RunHandle

Definition at line 664 of file testbed_api_testbed.c.

References RunContextOperation::cls, DEBUG, GNUNET_assert, GNUNET_new, GNUNET_TESTBED_peer_start(), GNUNET_TIME_absolute_get(), insert_rcop(), GNUNET_TESTBED_RunHandle::num_peers, RunContextOperation::op, peer, GNUNET_TESTBED_RunHandle::peer_count, GNUNET_TESTBED_RunHandle::peers, GNUNET_TESTBED_RunHandle::pstart_time, and RunContextOperation::rc.

Referenced by peer_create_cb().

665 {
666  struct GNUNET_TESTBED_RunHandle *rc = cls;
667  struct RunContextOperation *rcop;
668  unsigned int peer;
669 
670  DEBUG ("Starting Peers\n");
672  for (peer = 0; peer < rc->num_peers; peer++)
673  {
674  rcop = GNUNET_new (struct RunContextOperation);
675  rcop->rc = rc;
676  rcop->op = GNUNET_TESTBED_peer_start (NULL, rc->peers[peer], NULL, NULL);
677  GNUNET_assert (NULL != rcop->op);
678  rcop->cls = rc->peers[peer];
679  insert_rcop (rc, rcop);
680  }
681  rc->peer_count = 0;
682 }
Context information for the operation we start.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
static void insert_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Insert an RunContextOperation into the rcop_map of the given RunContext.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_start(void *op_cls, struct GNUNET_TESTBED_Peer *peer, GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
Start the given peer.
unsigned int num_peers
number of peers to start
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
unsigned int peer_count
Current peer count for an operation; Set this to 0 and increment for each successful operation on a p...
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ peer_create_cb()

static void peer_create_cb ( void *  cls,
struct GNUNET_TESTBED_Peer peer,
const char *  emsg 
)
static

Functions of this signature are called when a peer has been successfully created.

Parameters
clsthe closure from GNUNET_TESTBED_peer_create()
peerthe handle for the created peer; NULL on any error during creation
emsgNULL if peer is not NULL; else MAY contain the error description

Definition at line 695 of file testbed_api_testbed.c.

References RunContextOperation::cls, DEBUG, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), LOG, GNUNET_TESTBED_RunHandle::num_peers, RunContextOperation::op, peer, GNUNET_TESTBED_RunHandle::peer_count, GNUNET_TESTBED_RunHandle::peers, prof_time(), RunContextOperation::rc, RC_PEERS_CREATED, remove_rcop(), start_peers_task(), and GNUNET_TESTBED_RunHandle::state.

Referenced by create_peers().

696 {
697  struct RunContextOperation *rcop = cls;
698  struct GNUNET_TESTBED_RunHandle *rc;
699 
700  GNUNET_assert (NULL != rcop);
701  GNUNET_assert (NULL != (rc = rcop->rc));
702  remove_rcop (rc, rcop);
704  GNUNET_free (rcop);
705  if (NULL == peer)
706  {
707  if (NULL != emsg)
708  LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
709  emsg);
711  return;
712  }
713  rc->peers[rc->peer_count] = peer;
714  rc->peer_count++;
715  if (rc->peer_count < rc->num_peers)
716  return;
717  DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
718  rc->state = RC_PEERS_CREATED;
720 }
static void start_peers_task(void *cls)
Task for starting peers.
Context information for the operation we start.
enum State state
State of this context.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
unsigned int num_peers
number of peers to start
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define LOG(kind,...)
Generic loggins shorthand.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Peers are created.
unsigned int peer_count
Current peer count for an operation; Set this to 0 and increment for each successful operation on a p...
static void remove_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Remove a RunContextOperation from the rcop_map of the given RunContext.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
static const char * prof_time(struct GNUNET_TESTBED_RunHandle *rc)
Function to return the string representation of the duration between current time and `pstart_time&#39; i...
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ call_master()

static void call_master ( struct GNUNET_TESTBED_RunHandle rc)
static

call test master callback

Parameters
rcthe RunContext

Definition at line 729 of file testbed_api_testbed.c.

References GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_RunHandle::links_failed, GNUNET_TESTBED_RunHandle::links_succeeded, GNUNET_TESTBED_RunHandle::num_peers, GNUNET_TESTBED_RunHandle::peers, GNUNET_TESTBED_RunHandle::test_master, GNUNET_TESTBED_RunHandle::test_master_cls, and GNUNET_TESTBED_RunHandle::timeout_task.

Referenced by event_cb(), and topology_completion_callback().

730 {
732  rc->timeout_task = NULL;
733  if (NULL != rc->test_master)
734  rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
735  rc->links_succeeded, rc->links_failed);
736 }
unsigned int links_succeeded
the number of overlay link connection attempts that succeeded
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run of a timeout.
unsigned int links_failed
the number of overlay link connection attempts that failed
unsigned int num_peers
number of peers to start
void * test_master_cls
The closure for the TestMaster callback.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
GNUNET_TESTBED_TestMaster test_master
TestMaster callback to call when testbed initialization is done.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ topology_completion_callback()

static void topology_completion_callback ( void *  cls,
unsigned int  nsuccess,
unsigned int  nfailures 
)
static

Callbacks of this type are called when topology configuration is completed.

Parameters
clsthe operation closure given to GNUNET_TESTBED_overlay_configure_topology_va() and GNUNET_TESTBED_overlay_configure() calls
nsuccessthe number of successful overlay connects
nfailuresthe number of overlay connects which failed

Definition at line 749 of file testbed_api_testbed.c.

References call_master(), RunContextOperation::cls, DEBUG, GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_RunHandle::links_failed, GNUNET_TESTBED_RunHandle::links_succeeded, prof_time(), RunContextOperation::rc, RC_READY, GNUNET_TESTBED_RunHandle::state, and GNUNET_TESTBED_RunHandle::topology_operation.

Referenced by event_cb().

751 {
752  struct GNUNET_TESTBED_RunHandle *rc = cls;
753 
754  DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
756  rc->topology_operation = NULL;
757  rc->links_succeeded = nsuccess;
758  rc->links_failed = nfailures;
759  rc->state = RC_READY;
760  call_master (rc);
761 }
enum State state
State of this context.
unsigned int links_succeeded
the number of overlay link connection attempts that succeeded
unsigned int links_failed
the number of overlay link connection attempts that failed
The testbed run is ready and the master callback can be called now.
struct GNUNET_TESTBED_Operation * topology_operation
The topology generation operation.
static void call_master(struct GNUNET_TESTBED_RunHandle *rc)
call test master callback
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
#define DEBUG(...)
Debug logging shortcut.
static const char * prof_time(struct GNUNET_TESTBED_RunHandle *rc)
Function to return the string representation of the duration between current time and `pstart_time&#39; i...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ create_peers()

static void create_peers ( struct GNUNET_TESTBED_RunHandle rc)
static

Function to create peers.

Parameters
rcthe RunContext

Definition at line 770 of file testbed_api_testbed.c.

References GNUNET_TESTBED_RunHandle::c, GNUNET_TESTBED_RunHandle::cfg, DEBUG, GNUNET_assert, GNUNET_malloc, GNUNET_new, GNUNET_TESTBED_peer_create(), GNUNET_TIME_absolute_get(), GNUNET_TESTBED_RunHandle::h, GNUNET_TESTBED_RunHandle::hosts, insert_rcop(), GNUNET_TESTBED_RunHandle::num_hosts, GNUNET_TESTBED_RunHandle::num_peers, RunContextOperation::op, peer, GNUNET_TESTBED_RunHandle::peer_count, peer_create_cb(), GNUNET_TESTBED_RunHandle::peers, GNUNET_TESTBED_RunHandle::pstart_time, and RunContextOperation::rc.

Referenced by controller_status_cb(), and event_cb().

771 {
772  struct RunContextOperation *rcop;
773  unsigned int peer;
774 
775  DEBUG ("Creating peers\n");
777  rc->peers =
778  GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *) * rc->num_peers);
779  GNUNET_assert (NULL != rc->c);
780  rc->peer_count = 0;
781  for (peer = 0; peer < rc->num_peers; peer++)
782  {
783  rcop = GNUNET_new (struct RunContextOperation);
784  rcop->rc = rc;
785  rcop->op =
787  (0 ==
788  rc->num_hosts) ? rc->h : rc->hosts[peer %
789  rc->num_hosts],
790  rc->cfg, &peer_create_cb, rcop);
791  GNUNET_assert (NULL != rcop->op);
792  insert_rcop (rc, rcop);
793  }
794 }
Context information for the operation we start.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
static void insert_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Insert an RunContextOperation into the rcop_map of the given RunContext.
struct GNUNET_TESTBED_Controller * c
The controller handle.
unsigned int num_peers
number of peers to start
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static void peer_create_cb(void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
Functions of this signature are called when a peer has been successfully created. ...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
unsigned int peer_count
Current peer count for an operation; Set this to 0 and increment for each successful operation on a p...
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the controller.
struct GNUNET_TESTBED_Host ** hosts
An array of hosts loaded from the hostkeys file.
A peer controlled by the testing framework.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_create(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_TESTBED_PeerCreateCallback cb, void *cls)
Create the given peer at the specified host using the given controller.
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ event_cb()

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

Signature of the event handler function called by the respective event controller.

Parameters
clsclosure
eventinformation about the event

Definition at line 805 of file testbed_api_testbed.c.

References _, call_master(), GNUNET_TESTBED_RunHandle::cc, GNUNET_TESTBED_RunHandle::cc_cls, GNUNET_TESTBED_RunHandle::cfg, RunContextOperation::cls, create_peers(), DEBUG, GNUNET_TESTBED_EventInformation::details, GNUNET_TESTBED_RunHandle::event_mask, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_overlay_configure_topology(), GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI, GNUNET_TESTBED_TOPOLOGY_FROM_FILE, GNUNET_TESTBED_TOPOLOGY_NONE, GNUNET_TESTBED_TOPOLOGY_OPTION_END, GNUNET_TESTBED_TOPOLOGY_SCALE_FREE, GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD, GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING, GNUNET_TIME_absolute_get(), GNUNET_YES, LOG, GNUNET_TESTBED_RunHandle::num_hosts, GNUNET_TESTBED_RunHandle::num_oc, GNUNET_TESTBED_RunHandle::num_peers, number, RunContextOperation::op, GNUNET_TESTBED_EventInformation::op, GNUNET_TESTBED_EventInformation::operation_finished, GNUNET_TESTBED_RunHandle::peer_count, GNUNET_TESTBED_RunHandle::peers, prof_time(), GNUNET_TESTBED_RunHandle::pstart_time, GNUNET_TESTBED_RunHandle::random_links, RunContextOperation::rc, RC_INIT, RC_LINKED, RC_PEERS_CREATED, RC_PEERS_SHUTDOWN, RC_READY, GNUNET_TESTBED_RunHandle::reg_hosts, register_hosts(), remove_rcop(), SCALE_FREE_CAP, SCALE_FREE_M, search_rcop(), GNUNET_TESTBED_RunHandle::shutdown, GNUNET_TESTBED_RunHandle::state, TESTBED_CONFIG_SECTION, GNUNET_TESTBED_RunHandle::topo_file, GNUNET_TESTBED_RunHandle::topology, topology_completion_callback(), GNUNET_TESTBED_RunHandle::topology_operation, and GNUNET_TESTBED_EventInformation::type.

Referenced by controller_status_cb().

806 {
807  struct GNUNET_TESTBED_RunHandle *rc = cls;
808  struct RunContextOperation *rcop;
809 
810  if (RC_INIT == rc->state)
811  {
812  switch (event->type)
813  {
815  rcop = event->op_cls;
816  if (NULL != event->details.operation_finished.emsg)
817  {
818  LOG (GNUNET_ERROR_TYPE_ERROR, _("Linking controllers failed. Exiting"));
820  }
821  else
822  rc->reg_hosts++;
823  GNUNET_assert (event->op == rcop->op);
824  remove_rcop (rc, rcop);
826  GNUNET_free (rcop);
827  if (rc->reg_hosts == rc->num_hosts)
828  {
829  rc->state = RC_LINKED;
830  create_peers (rc);
831  }
832  return;
833  default:
834  GNUNET_break (0);
836  return;
837  }
838  }
840  goto call_cc;
841  if (NULL == (rcop = search_rcop (rc, event->op)))
842  goto call_cc;
843  remove_rcop (rc, rcop);
845  GNUNET_free (rcop);
846  if ( (GNUNET_NO == rc->shutdown)
847  && (NULL != event->details.operation_finished.emsg) )
848  {
849  LOG (GNUNET_ERROR_TYPE_ERROR, "A operation has failed with error: %s\n",
850  event->details.operation_finished.emsg);
852  return;
853  }
855  switch (rc->state)
856  {
857  case RC_LINKED:
858  case RC_PEERS_CREATED:
859  case RC_READY:
860  rc->state = RC_PEERS_SHUTDOWN;
862  rc->peers = NULL;
863  DEBUG ("Peers shut down in %s\n", prof_time (rc));
865  break;
866  default:
867  GNUNET_assert (0);
868  }
869  return;
870 
871 call_cc:
872  if ((0 != (rc->event_mask & (1LL << event->type))) && (NULL != rc->cc))
873  rc->cc (rc->cc_cls, event);
874  if (GNUNET_TESTBED_ET_PEER_START != event->type)
875  return;
876  if (NULL == (rcop = search_rcop (rc, event->op))) /* Not our operation */
877  return;
878  remove_rcop (rc, rcop);
880  GNUNET_free (rcop);
881  rc->peer_count++;
882  if (rc->peer_count < rc->num_peers)
883  return;
884  DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
886  {
887  switch (rc->topology)
888  {
890  GNUNET_assert (0);
894  rc->topology_operation =
896  rc->peers, &rc->num_oc,
898  rc,
899  rc->topology,
900  rc->random_links,
902  break;
904  GNUNET_assert (NULL != rc->topo_file);
905  rc->topology_operation =
907  rc->peers, &rc->num_oc,
909  rc,
910  rc->topology,
911  rc->topo_file,
913  break;
915  {
916  unsigned long long number;
917  unsigned int cap;
921  &number));
922  cap = (unsigned int) number;
925  SCALE_FREE_M,
926  &number));
927  rc->topology_operation =
929  rc->peers, &rc->num_oc,
931  rc,
932  rc->topology,
933  cap, /* uint16_t */
934  (unsigned int) number, /* uint8_t */
936  }
937  break;
938  default:
939  rc->topology_operation =
941  rc->peers, &rc->num_oc,
943  rc,
944  rc->topology,
946  }
947  if (NULL == rc->topology_operation)
949  "Not generating a topology. Check number of peers\n");
950  else
951  {
952  DEBUG ("Creating overlay topology\n");
954  return;
955  }
956  }
957  rc->state = RC_READY;
958  call_master (rc);
959 }
Context information for the operation we start.
enum State state
State of this context.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
void * cc_cls
The pointer to the controller callback.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
All peers are disconnected.
unsigned int num_oc
Expected overlay connects.
static struct RunContextOperation * search_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct GNUNET_TESTBED_Operation *op)
Initiate a search for the given operation in the rcop_map.
#define TESTBED_CONFIG_SECTION
Configuration section for testbed.
unsigned int num_peers
number of peers to start
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
enum GNUNET_TESTBED_EventType type
Type of the event.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
The testbed run is ready and the master callback can be called now.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
Read a topology from a given file.
#define SCALE_FREE_M
Option string for the number of edges to be established when adding a new node to the scale free netw...
#define LOG(kind,...)
Generic loggins shorthand.
char * topo_file
The file containing topology data.
struct GNUNET_TESTBED_Operation * topology_operation
The topology generation operation.
static void create_peers(struct GNUNET_TESTBED_RunHandle *rc)
Function to create peers.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_overlay_configure_topology(void *op_cls, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int *max_connections, GNUNET_TESTBED_TopologyCompletionCallback comp_cb, void *comp_cb_cls, enum GNUNET_TESTBED_TopologyOption topo,...)
All peers must have been started before calling this function.
A requested testbed operation has been completed.
unsigned int reg_hosts
Number of registered hosts.
static void call_master(struct GNUNET_TESTBED_RunHandle *rc)
call test master callback
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2046
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_TESTBED_EventInformation::@58::@63 operation_finished
Details about an operation finished event.
The options should always end with this.
Controllers on given hosts started and linked.
static void topology_completion_callback(void *cls, unsigned int nsuccess, unsigned int nfailures)
Callbacks of this type are called when topology configuration is completed.
union GNUNET_TESTBED_EventInformation::@58 details
Details about the event.
Small-world network (2d torus plus random links).
Peers are created.
Initial state.
unsigned int peer_count
Current peer count for an operation; Set this to 0 and increment for each successful operation on a p...
GNUNET_TESTBED_ControllerCallback cc
The callback to use as controller callback.
unsigned int random_links
Number of random links to established.
enum GNUNET_TESTBED_TopologyOption topology
The topology which has to be achieved with the peers started in this context.
static void remove_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Remove a RunContextOperation from the rcop_map of the given RunContext.
unsigned int num_hosts
Number of hosts in the given host file.
int shutdown
Have we already shutdown.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the controller.
#define GNUNET_YES
Definition: gnunet_common.h:80
static const char * prof_time(struct GNUNET_TESTBED_RunHandle *rc)
Function to return the string representation of the duration between current time and `pstart_time&#39; i...
#define GNUNET_free(ptr)
Wrapper around free.
uint64_t event_mask
The event mask for the controller.
All peers shutdown (stopped and destroyed)
struct GNUNET_TESTBED_Operation * op
Handle for the corresponding operation that generated this event.
Small-world network (ring plus random links).
#define SCALE_FREE_CAP
Option string for the maximum number of edges a peer is permitted to have while generating scale free...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ register_hosts()

static void register_hosts ( void *  cls)
static

Task to register all hosts available in the global host list.

Parameters
clsthe RunContext
clsRunContext

Definition at line 1001 of file testbed_api_testbed.c.

References GNUNET_TESTBED_RunHandle::c, RunContextOperation::cls, DEBUG, GNUNET_assert, GNUNET_new, GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_register_host(), GNUNET_YES, GNUNET_TESTBED_RunHandle::h, host_registration_completion(), GNUNET_TESTBED_RunHandle::hosts, insert_rcop(), GNUNET_TESTBED_RunHandle::num_hosts, RunContextOperation::op, RunContextOperation::rc, GNUNET_TESTBED_RunHandle::reg_handle, GNUNET_TESTBED_RunHandle::reg_hosts, and GNUNET_TESTBED_RunHandle::register_hosts_task.

Referenced by controller_status_cb(), event_cb(), and host_registration_completion().

1002 {
1003  struct GNUNET_TESTBED_RunHandle *rc = cls;
1004  struct RunContextOperation *rcop;
1005  unsigned int slave;
1006 
1007  rc->register_hosts_task = NULL;
1008  if (rc->reg_hosts == rc->num_hosts)
1009  {
1010  DEBUG ("All hosts successfully registered\n");
1011  /* Start slaves */
1012  for (slave = 0; slave < rc->num_hosts; slave++)
1013  {
1014  rcop = GNUNET_new (struct RunContextOperation);
1015  rcop->rc = rc;
1016  rcop->op =
1017  GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave],
1018  rc->h, GNUNET_YES);
1019  GNUNET_assert (NULL != rcop->op);
1020  insert_rcop (rc, rcop);
1021  }
1022  rc->reg_hosts = 0;
1023  return;
1024  }
1025  rc->reg_handle =
1028  rc->reg_hosts++;
1029 }
Context information for the operation we start.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_controller_link(void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *delegated_host, struct GNUNET_TESTBED_Host *slave_host, int is_subordinate)
Create a link from slave controller to delegated controller.
Definition: testbed_api.c:1833
static void insert_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Insert an RunContextOperation into the rcop_map of the given RunContext.
struct GNUNET_TESTBED_Controller * c
The controller handle.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
unsigned int reg_hosts
Number of registered hosts.
#define DEBUG(...)
Debug logging shortcut.
static void host_registration_completion(void *cls, const char *emsg)
Callback which will be called to after a host registration succeeded or failed.
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_TESTBED_Host ** hosts
An array of hosts loaded from the hostkeys file.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
struct GNUNET_TESTBED_HostRegistrationHandle * GNUNET_TESTBED_register_host(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_HostRegistrationCompletion cc, void *cc_cls)
Register a host with the controller.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ host_registration_completion()

static void host_registration_completion ( void *  cls,
const char *  emsg 
)
static

Callback which will be called to after a host registration succeeded or failed.

Parameters
clsthe closure
emsgthe error message; NULL if host registration is successful

Definition at line 978 of file testbed_api_testbed.c.

References _, RunContextOperation::cls, GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), LOG, RunContextOperation::rc, GNUNET_TESTBED_RunHandle::reg_handle, register_hosts(), and GNUNET_TESTBED_RunHandle::register_hosts_task.

Referenced by register_hosts().

979 {
980  struct GNUNET_TESTBED_RunHandle *rc = cls;
981 
982  rc->reg_handle = NULL;
983  if (NULL != emsg)
984  {
986  _("Host registration failed for a host. Error: %s\n"), emsg);
988  return;
989  }
991  rc);
992 }
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
#define LOG(kind,...)
Generic loggins shorthand.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
static void register_hosts(void *cls)
Task to register all hosts available in the global host list.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ controller_status_cb()

static void controller_status_cb ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle cfg,
int  status 
)
static

Callback to signal successfull startup of the controller process.

Parameters
clsthe closure from GNUNET_TESTBED_controller_start()
cfgthe configuration with which the controller has been started; NULL if status is not GNUNET_OK
statusGNUNET_OK if the startup is successfull; GNUNET_SYSERR if not, GNUNET_TESTBED_controller_stop() shouldn't be called in this case

Definition at line 1042 of file testbed_api_testbed.c.

References _, GNUNET_TESTBED_RunHandle::c, GNUNET_TESTBED_RunHandle::cfg, RunContextOperation::cls, GNUNET_TESTBED_RunHandle::cproc, create_peers(), event_cb(), event_mask, GNUNET_TESTBED_RunHandle::event_mask, GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_dup(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_controller_connect(), GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_TOPOLOGY_NONE, GNUNET_TESTBED_RunHandle::h, GNUNET_TESTBED_RunHandle::num_hosts, RunContextOperation::rc, RC_LINKED, GNUNET_TESTBED_RunHandle::reg_hosts, register_hosts(), GNUNET_TESTBED_RunHandle::register_hosts_task, GNUNET_TESTBED_RunHandle::state, and GNUNET_TESTBED_RunHandle::topology.

Referenced by GNUNET_TESTBED_run(), and host_habitable_cb().

1044 {
1045  struct GNUNET_TESTBED_RunHandle *rc = cls;
1046  uint64_t event_mask;
1047 
1048  if (status != GNUNET_OK)
1049  {
1050  rc->cproc = NULL;
1052  _("Controller crash detected. Shutting down.\n"));
1054  return;
1055  }
1057  rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
1058  event_mask = rc->event_mask;
1059  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
1060  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
1062  event_mask |= GNUNET_TESTBED_ET_CONNECT;
1063  rc->c =
1064  GNUNET_TESTBED_controller_connect (rc->h, event_mask, &event_cb, rc);
1065  if (0 < rc->num_hosts)
1066  {
1067  rc->reg_hosts = 0;
1069  return;
1070  }
1071  rc->state = RC_LINKED;
1072  create_peers (rc);
1073 }
enum State state
State of this context.
static void event_cb(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Signature of the event handler function called by the respective event controller.
All peers are disconnected.
struct GNUNET_TESTBED_ControllerProc * cproc
The handle to the controller process.
struct GNUNET_TESTBED_Controller * c
The controller handle.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
static void create_peers(struct GNUNET_TESTBED_RunHandle *rc)
Function to create peers.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
A requested testbed operation has been completed.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
uint16_t status
See PRISM_STATUS_*-constants.
unsigned int reg_hosts
Number of registered hosts.
uint64_t event_mask
Global event mask for all testbed events.
Controllers on given hosts started and linked.
struct GNUNET_TESTBED_Controller * GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls)
Connect to a controller process.
Definition: testbed_api.c:1558
A connection between two peers was established.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
enum GNUNET_TESTBED_TopologyOption topology
The topology which has to be achieved with the peers started in this context.
#define GNUNET_log(kind,...)
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the controller.
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
static void register_hosts(void *cls)
Task to register all hosts available in the global host list.
uint64_t event_mask
The event mask for the controller.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ netint_proc()

static int netint_proc ( void *  cls,
const char *  name,
int  isDefault,
const struct sockaddr *  addr,
const struct sockaddr *  broadcast_addr,
const struct sockaddr *  netmask,
socklen_t  addrlen 
)
static

Callback function invoked for each interface found.

Parameters
clsclosure
namename of the interface (can be NULL for unknown)
isDefaultis this presumably the default interface
addraddress of this interface (can be NULL for unknown or unassigned)
broadcast_addrthe broadcast address (can be NULL for unknown or unassigned)
netmaskthe network mask (can be NULL for unknown or unassigned))
addrlenlength of the address
Returns
GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 1089 of file testbed_api_testbed.c.

References buf, RunContextOperation::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_OK, GNUNET_strdup, GNUNET_YES, RunContextOperation::rc, and GNUNET_TESTBED_RunHandle::trusted_ip.

Referenced by host_habitable_cb().

1092 {
1093  struct GNUNET_TESTBED_RunHandle *rc = cls;
1094  char hostip[NI_MAXHOST];
1095  char *buf;
1096 
1097  if (sizeof (struct sockaddr_in) != addrlen)
1098  return GNUNET_OK; /* Only consider IPv4 for now */
1099  if (0 !=
1100  getnameinfo (addr, addrlen, hostip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
1102  if (NULL == rc->trusted_ip)
1103  {
1104  rc->trusted_ip = GNUNET_strdup (hostip);
1105  return GNUNET_YES;
1106  }
1107  (void) GNUNET_asprintf (&buf, "%s; %s", rc->trusted_ip, hostip);
1108  GNUNET_free (rc->trusted_ip);
1109  rc->trusted_ip = buf;
1110  return GNUNET_YES;
1111 }
char * trusted_ip
The trusted IP string.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char buf[2048]
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ host_habitable_cb()

static void host_habitable_cb ( void *  cls,
const struct GNUNET_TESTBED_Host host,
int  status 
)
static

Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to inform whether the given host is habitable or not.

The Handle returned by GNUNET_TESTBED_is_host_habitable() is invalid after this callback is called

Parameters
clsNULL
hostthe host whose status is being reported; will be NULL if the host given to GNUNET_TESTBED_is_host_habitable() is NULL
statusGNUNET_YES if it is habitable; GNUNET_NO if not

Definition at line 1125 of file testbed_api_testbed.c.

References _, RunContextOperation::cls, controller_status_cb(), GNUNET_TESTBED_RunHandle::cproc, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_TESTBED_controller_start(), GNUNET_TESTBED_host_get_hostname(), GNUNET_TESTBED_host_resolve_(), CompatibilityCheckContext::h, GNUNET_TESTBED_RunHandle::h, GNUNET_TESTBED_RunHandle::hclist, GNUNET_TESTBED_RunHandle::hosts, CompatibilityCheckContext::index, LOG, netint_proc(), GNUNET_TESTBED_RunHandle::num_hosts, RunContextOperation::rc, CompatibilityCheckContext::rc, GNUNET_TESTBED_RunHandle::reg_hosts, and GNUNET_TESTBED_RunHandle::trusted_ip.

Referenced by GNUNET_TESTBED_run().

1127 {
1128  struct CompatibilityCheckContext *hc = cls;
1129  struct GNUNET_TESTBED_RunHandle *rc;
1130  struct GNUNET_TESTBED_Host **old_hosts;
1131  unsigned int nhost;
1132 
1133  GNUNET_assert (NULL != (rc = hc->rc));
1134  nhost = hc->index;
1135  GNUNET_assert (nhost <= rc->num_hosts);
1136  GNUNET_assert (host == rc->hosts[nhost]);
1137  hc->h = NULL;
1138  if (GNUNET_NO == status)
1139  {
1140  if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
1141  LOG (GNUNET_ERROR_TYPE_ERROR, _("Host %s cannot start testbed\n"),
1143  else
1145  _("Testbed cannot be started on localhost\n"));
1147  return;
1148  }
1149  rc->reg_hosts++;
1150  if (rc->reg_hosts < rc->num_hosts)
1151  return;
1152  GNUNET_free (rc->hclist);
1153  rc->hclist = NULL;
1154  rc->h = rc->hosts[0];
1155  rc->num_hosts--;
1156  if (0 < rc->num_hosts)
1157  {
1158  old_hosts = rc->hosts;
1159  rc->hosts =
1160  GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * rc->num_hosts);
1161  GNUNET_memcpy (rc->hosts, &old_hosts[1],
1162  (sizeof (struct GNUNET_TESTBED_Host *) * rc->num_hosts));
1163  GNUNET_free (old_hosts);
1164  }
1165  else
1166  {
1167  GNUNET_free (rc->hosts);
1168  rc->hosts = NULL;
1169  }
1171  for (nhost = 0; nhost < rc->num_hosts; nhost++)
1172  GNUNET_TESTBED_host_resolve_ (rc->hosts[nhost]);
1174  if (NULL == rc->trusted_ip)
1175  rc->trusted_ip = GNUNET_strdup ("127.0.0.1");
1176  rc->cproc =
1178  &controller_status_cb, rc);
1179  GNUNET_free (rc->trusted_ip);
1180  rc->trusted_ip = NULL;
1181  if (NULL == rc->cproc)
1182  {
1183  LOG (GNUNET_ERROR_TYPE_ERROR, _("Cannot start the master controller"));
1185  }
1186 }
unsigned int index
Index of the host in the run context&#39;s hosts array.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_ControllerProc * cproc
The handle to the controller process.
char * trusted_ip
The trusted IP string.
Context for host compability checks.
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:388
Opaque handle to a host running experiments managed by the testing framework.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
struct GNUNET_TESTBED_HostHabitableCheckHandle * h
Handle for the compability check.
#define GNUNET_memcpy(dst, src, n)
#define LOG(kind,...)
Generic loggins shorthand.
struct CompatibilityCheckContext * hclist
Array of compatibility check contexts.
void GNUNET_TESTBED_host_resolve_(struct GNUNET_TESTBED_Host *host)
Resolves the hostname of the host to an ip address.
uint16_t status
See PRISM_STATUS_*-constants.
struct GNUNET_TESTBED_RunHandle * rc
The run context.
unsigned int reg_hosts
Number of registered hosts.
static int netint_proc(void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
Callback function invoked for each interface found.
const char * GNUNET_TESTBED_host_get_hostname(const struct GNUNET_TESTBED_Host *host)
Obtain the host&#39;s hostname.
unsigned int num_hosts
Number of hosts in the given host file.
struct GNUNET_TESTBED_Host ** hosts
An array of hosts loaded from the hostkeys file.
static void controller_status_cb(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, int status)
Callback to signal successfull startup of the controller process.
struct GNUNET_TESTBED_ControllerProc * GNUNET_TESTBED_controller_start(const char *trusted_ip, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_ControllerStatusCallback cb, void *cls)
Starts a controller process at the given host.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ timeout_task()

static void timeout_task ( void *  cls)
static

Task run upon timeout while setting up the testbed.

Parameters
clsthe RunContext

Definition at line 1195 of file testbed_api_testbed.c.

References _, RunContextOperation::cls, GNUNET_ERROR_TYPE_ERROR, GNUNET_SCHEDULER_shutdown(), LOG, RunContextOperation::rc, GNUNET_TESTBED_RunHandle::test_master, GNUNET_TESTBED_RunHandle::test_master_cls, and GNUNET_TESTBED_RunHandle::timeout_task.

Referenced by GNUNET_TESTBED_run().

1196 {
1197  struct GNUNET_TESTBED_RunHandle *rc = cls;
1198 
1199  rc->timeout_task = NULL;
1201  _("Shutting down testbed due to timeout while setup.\n"));
1203  if (NULL != rc->test_master)
1204  rc->test_master (rc->test_master_cls, rc, 0, NULL, 0, 0);
1205  rc->test_master = NULL;
1206 }
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run of a timeout.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
#define LOG(kind,...)
Generic loggins shorthand.
void * test_master_cls
The closure for the TestMaster callback.
GNUNET_TESTBED_TestMaster test_master
TestMaster callback to call when testbed initialization is done.
Here is the call graph for this function:
Here is the caller graph for this function: