GNUnet  0.11.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 96 of file testbed_api_testbed.c.

97 {
101  RC_INIT = 0,
102 
106  RC_LINKED,
107 
112 
118  RC_READY,
119 
120  /* /\** */
121  /* * Peers are stopped */
122  /* *\/ */
123  /* RC_PEERS_STOPPED, */
124 
125  /* /\** */
126  /* * Peers are destroyed */
127  /* *\/ */
128  /* RC_PEERS_DESTROYED */
129 
134 };
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 338 of file testbed_api_testbed.c.

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

339 {
340  return *((uint32_t *) &rcop);
341 }
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 370 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().

371 {
372  struct RunContextOperation *rcop = value;
373  struct SearchContext *sc = cls;
374 
375  GNUNET_assert (NULL != rcop);
376  if (sc->query == rcop->op)
377  {
378  GNUNET_assert (NULL == sc->result);
379  sc->result = rcop;
380  return GNUNET_NO;
381  }
382  return GNUNET_YES;
383 }
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:78
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:225
#define GNUNET_YES
Definition: gnunet_common.h:77
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 395 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().

397 {
398  struct SearchContext sc;
399 
400  sc.query = op;
401  sc.result = NULL;
402  if (GNUNET_SYSERR ==
404  rcop_key (op),
406  &sc))
407  {
408  GNUNET_assert (NULL != sc.result);
409  return sc.result;
410  }
411  return NULL;
412 }
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:76
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:225
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
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 422 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:75
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().

442 {
445  rcop_key (rcop->op),
446  rcop));
447 }
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:77
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 456 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().

457 {
458  unsigned int hid;
459 
460  GNUNET_assert (NULL == rc->register_hosts_task);
461  GNUNET_assert (NULL == rc->reg_handle);
462  GNUNET_assert (NULL == rc->peers);
463  GNUNET_assert (NULL == rc->hclist);
467  if (NULL != rc->c)
469  if (NULL != rc->cproc)
471  if (NULL != rc->h)
473  for (hid = 0; hid < rc->num_hosts; hid++)
476  if (NULL != rc->cfg)
480  GNUNET_free (rc);
481 }
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:1720
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 493 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().

494 {
495  struct GNUNET_TESTBED_RunHandle *rc = cls;
496  struct RunContextOperation *rcop = value;
497 
498  GNUNET_assert (rc == rcop->rc);
499  remove_rcop (rc, rcop);
501  GNUNET_free (rcop);
502  return GNUNET_YES;
503 }
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:2044
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:77
#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 512 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().

513 {
514  struct CompatibilityCheckContext *hc;
515  unsigned int nhost;
516 
517  if (NULL != rc->hclist)
518  {
519  for (nhost = 0; nhost < rc->num_hosts; nhost++)
520  {
521  hc = &rc->hclist[nhost];
522  if (NULL != hc->h)
524  }
525  GNUNET_free (rc->hclist);
526  rc->hclist = NULL;
527  }
528  /* Stop register hosts task if it is running */
529  if (NULL != rc->register_hosts_task)
530  {
532  rc->register_hosts_task = NULL;
533  }
534  if (NULL != rc->timeout_task)
535  {
537  rc->timeout_task = NULL;
538  }
539  if (NULL != rc->reg_handle)
540  {
542  rc->reg_handle = NULL;
543  }
544  if (NULL != rc->topology_operation)
545  {
547  rc->topology_operation = NULL;
548  }
549  /* cancel any exiting operations */
553  rc));
554 }
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:2044
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:966
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 563 of file testbed_api_testbed.c.

References GNUNET_SCHEDULER_cancel(), and GNUNET_TESTBED_RunHandle::interrupt_task.

Referenced by wait_op_completion().

564 {
566  rc->interrupt_task = NULL;
567 }
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:966
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 577 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().

578 {
579  struct GNUNET_TESTBED_RunHandle *rc = cls;
580  struct RunContextOperation *rcop;
581 
582  if ((NULL == rc->cproc)
583  || (NULL == rc->c)
584  || (GNUNET_YES == rc->shutdown))
585  {
586  if (NULL != rc->peers)
587  {
588  GNUNET_free (rc->peers);
589  rc->peers = NULL;
590  }
591  goto cleanup_;
592  }
593  if (NULL == rc->peers)
594  goto cleanup_;
595  rc->shutdown = GNUNET_YES;
596  rcop = GNUNET_new (struct RunContextOperation);
597  rcop->rc = rc;
598  rcop->op = GNUNET_TESTBED_shutdown_peers (rc->c, rcop, NULL, NULL);
599  GNUNET_assert (NULL != rcop->op);
600  DEBUG ("Shutting down peers\n");
602  insert_rcop (rc, rcop);
603  return;
604 
605 cleanup_:
606  rc->state = RC_PEERS_SHUTDOWN;
608  cleanup (rc);
609 }
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:2282
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:77
#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 618 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().

619 {
620  struct GNUNET_TESTBED_RunHandle *rc = cls;
621  struct GNUNET_TESTBED_Controller *c = rc->c;
622  unsigned int size;
623 
624  /* reschedule */
627  if ((GNUNET_NO == rc->shutdown) &&
628  (NULL != c) &&
629  (NULL != c->opc_map) &&
630  (0 != (size = GNUNET_CONTAINER_multihashmap32_size (c->opc_map))))
631  {
633  "Shutdown postponed as there are %u operations currently active\n",
634  size);
636  c->opcq_empty_cls = rc;
637  return;
638  }
639  wait_op_completion (rc);
640 }
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:193
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:1300
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:234
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:78
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:229
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:239
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 651 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().

652 {
653  struct GNUNET_TIME_Relative ptime;
654 
657 }
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:687
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:375
#define GNUNET_YES
Definition: gnunet_common.h:77
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 666 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().

667 {
668  struct GNUNET_TESTBED_RunHandle *rc = cls;
669  struct RunContextOperation *rcop;
670  unsigned int peer;
671 
672  DEBUG ("Starting Peers\n");
674  for (peer = 0; peer < rc->num_peers; peer++)
675  {
676  rcop = GNUNET_new (struct RunContextOperation);
677  rcop->rc = rc;
678  rcop->op = GNUNET_TESTBED_peer_start (NULL, rc->peers[peer], NULL, NULL);
679  GNUNET_assert (NULL != rcop->op);
680  rcop->cls = rc->peers[peer];
681  insert_rcop (rc, rcop);
682  }
683  rc->peer_count = 0;
684 }
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 697 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().

698 {
699  struct RunContextOperation *rcop = cls;
700  struct GNUNET_TESTBED_RunHandle *rc;
701 
702  GNUNET_assert (NULL != rcop);
703  GNUNET_assert (NULL != (rc = rcop->rc));
704  remove_rcop (rc, rcop);
706  GNUNET_free (rcop);
707  if (NULL == peer)
708  {
709  if (NULL != emsg)
710  LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
711  emsg);
713  return;
714  }
715  rc->peers[rc->peer_count] = peer;
716  rc->peer_count++;
717  if (rc->peer_count < rc->num_peers)
718  return;
719  DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
720  rc->state = RC_PEERS_CREATED;
722 }
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:526
#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:1280
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:2044
#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 731 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().

732 {
734  rc->timeout_task = NULL;
735  if (NULL != rc->test_master)
736  rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
737  rc->links_succeeded, rc->links_failed);
738 }
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:966
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 751 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().

753 {
754  struct GNUNET_TESTBED_RunHandle *rc = cls;
755 
756  DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
758  rc->topology_operation = NULL;
759  rc->links_succeeded = nsuccess;
760  rc->links_failed = nfailures;
761  rc->state = RC_READY;
762  call_master (rc);
763 }
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:2044
#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 772 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().

773 {
774  struct RunContextOperation *rcop;
775  unsigned int peer;
776 
777  DEBUG ("Creating peers\n");
779  rc->peers =
780  GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Peer *) * rc->num_peers);
781  GNUNET_assert (NULL != rc->c);
782  rc->peer_count = 0;
783  for (peer = 0; peer < rc->num_peers; peer++)
784  {
785  rcop = GNUNET_new (struct RunContextOperation);
786  rcop->rc = rc;
787  rcop->op =
789  (0 ==
790  rc->num_hosts) ? rc->h : rc->hosts[peer
791  % rc->
792  num_hosts],
793  rc->cfg, &peer_create_cb, rcop);
794  GNUNET_assert (NULL != rcop->op);
795  insert_rcop (rc, rcop);
796  }
797 }
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 808 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().

809 {
810  struct GNUNET_TESTBED_RunHandle *rc = cls;
811  struct RunContextOperation *rcop;
812 
813  if (RC_INIT == rc->state)
814  {
815  switch (event->type)
816  {
818  rcop = event->op_cls;
819  if (NULL != event->details.operation_finished.emsg)
820  {
822  "Linking controllers failed. Exiting"));
824  }
825  else
826  rc->reg_hosts++;
827  GNUNET_assert (event->op == rcop->op);
828  remove_rcop (rc, rcop);
830  GNUNET_free (rcop);
831  if (rc->reg_hosts == rc->num_hosts)
832  {
833  rc->state = RC_LINKED;
834  create_peers (rc);
835  }
836  return;
837 
838  default:
839  GNUNET_break (0);
841  return;
842  }
843  }
845  goto call_cc;
846  if (NULL == (rcop = search_rcop (rc, event->op)))
847  goto call_cc;
848  remove_rcop (rc, rcop);
850  GNUNET_free (rcop);
851  if ((GNUNET_NO == rc->shutdown)
852  && (NULL != event->details.operation_finished.emsg))
853  {
854  LOG (GNUNET_ERROR_TYPE_ERROR, "A operation has failed with error: %s\n",
855  event->details.operation_finished.emsg);
857  return;
858  }
860  switch (rc->state)
861  {
862  case RC_LINKED:
863  case RC_PEERS_CREATED:
864  case RC_READY:
865  rc->state = RC_PEERS_SHUTDOWN;
867  rc->peers = NULL;
868  DEBUG ("Peers shut down in %s\n", prof_time (rc));
870  break;
871 
872  default:
873  GNUNET_assert (0);
874  }
875  return;
876 
877 call_cc:
878  if ((0 != (rc->event_mask & (1LL << event->type))) && (NULL != rc->cc))
879  rc->cc (rc->cc_cls, event);
880  if (GNUNET_TESTBED_ET_PEER_START != event->type)
881  return;
882  if (NULL == (rcop = search_rcop (rc, event->op))) /* Not our operation */
883  return;
884  remove_rcop (rc, rcop);
886  GNUNET_free (rcop);
887  rc->peer_count++;
888  if (rc->peer_count < rc->num_peers)
889  return;
890  DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
892  {
893  switch (rc->topology)
894  {
896  GNUNET_assert (0);
897 
901  rc->topology_operation =
903  rc->peers, &rc->num_oc,
905  rc,
906  rc->topology,
907  rc->random_links,
909  break;
910 
912  GNUNET_assert (NULL != rc->topo_file);
913  rc->topology_operation =
915  rc->peers, &rc->num_oc,
917  rc,
918  rc->topology,
919  rc->topo_file,
921  break;
922 
924  {
925  unsigned long long number;
926  unsigned int cap;
931  &number));
932  cap = (unsigned int) number;
936  SCALE_FREE_M,
937  &number));
938  rc->topology_operation =
940  rc->peers, &rc->num_oc,
941  &
943  rc,
944  rc->topology,
945  cap, /* uint16_t */
946  (unsigned int) number, /* uint8_t */
948  }
949  break;
950 
951  default:
952  rc->topology_operation =
954  rc->peers, &rc->num_oc,
956  rc,
957  rc->topology,
959  }
960  if (NULL == rc->topology_operation)
962  "Not generating a topology. Check number of peers\n");
963  else
964  {
965  DEBUG ("Creating overlay topology\n");
967  return;
968  }
969  }
970  rc->state = RC_READY;
971  call_master (rc);
972 }
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.
struct GNUNET_TESTBED_EventInformation::@55::@60 operation_finished
Details about an operation finished event.
#define TESTBED_CONFIG_SECTION
Configuration section for testbed.
unsigned int num_peers
number of peers to start
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:526
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...
uint32_t number
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:2044
#define DEBUG(...)
Debug logging shortcut.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
The options should always end with this.
union GNUNET_TESTBED_EventInformation::@55 details
Details about the event.
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.
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:77
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 1014 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().

1015 {
1016  struct GNUNET_TESTBED_RunHandle *rc = cls;
1017  struct RunContextOperation *rcop;
1018  unsigned int slave;
1019 
1020  rc->register_hosts_task = NULL;
1021  if (rc->reg_hosts == rc->num_hosts)
1022  {
1023  DEBUG ("All hosts successfully registered\n");
1024  /* Start slaves */
1025  for (slave = 0; slave < rc->num_hosts; slave++)
1026  {
1027  rcop = GNUNET_new (struct RunContextOperation);
1028  rcop->rc = rc;
1029  rcop->op =
1030  GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave],
1031  rc->h, GNUNET_YES);
1032  GNUNET_assert (NULL != rcop->op);
1033  insert_rcop (rc, rcop);
1034  }
1035  rc->reg_hosts = 0;
1036  return;
1037  }
1038  rc->reg_handle =
1041  rc->reg_hosts++;
1042 }
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:1831
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:77
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 991 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().

992 {
993  struct GNUNET_TESTBED_RunHandle *rc = cls;
994 
995  rc->reg_handle = NULL;
996  if (NULL != emsg)
997  {
999  _ ("Host registration failed for a host. Error: %s\n"), emsg);
1001  return;
1002  }
1004  rc);
1005 }
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#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:1280
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 1055 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().

1057 {
1058  struct GNUNET_TESTBED_RunHandle *rc = cls;
1059  uint64_t event_mask;
1060 
1061  if (status != GNUNET_OK)
1062  {
1063  rc->cproc = NULL;
1065  _ ("Controller crash detected. Shutting down.\n"));
1067  return;
1068  }
1070  rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
1071  event_mask = rc->event_mask;
1072  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
1073  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
1075  event_mask |= GNUNET_TESTBED_ET_CONNECT;
1076  rc->c =
1077  GNUNET_TESTBED_controller_connect (rc->h, event_mask, &event_cb, rc);
1078  if (0 < rc->num_hosts)
1079  {
1080  rc->reg_hosts = 0;
1082  return;
1083  }
1084  rc->state = RC_LINKED;
1085  create_peers (rc);
1086 }
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:75
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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:1280
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:1554
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 1102 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().

1105 {
1106  struct GNUNET_TESTBED_RunHandle *rc = cls;
1107  char hostip[NI_MAXHOST];
1108  char *buf;
1109 
1110  if (sizeof(struct sockaddr_in) != addrlen)
1111  return GNUNET_OK; /* Only consider IPv4 for now */
1112  if (0 !=
1113  getnameinfo (addr, addrlen, hostip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
1115  if (NULL == rc->trusted_ip)
1116  {
1117  rc->trusted_ip = GNUNET_strdup (hostip);
1118  return GNUNET_YES;
1119  }
1120  (void) GNUNET_asprintf (&buf, "%s; %s", rc->trusted_ip, hostip);
1121  GNUNET_free (rc->trusted_ip);
1122  rc->trusted_ip = buf;
1123  return GNUNET_YES;
1124 }
char * trusted_ip
The trusted IP string.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:77
#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 1138 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().

1140 {
1141  struct CompatibilityCheckContext *hc = cls;
1142  struct GNUNET_TESTBED_RunHandle *rc;
1143  struct GNUNET_TESTBED_Host **old_hosts;
1144  unsigned int nhost;
1145 
1146  GNUNET_assert (NULL != (rc = hc->rc));
1147  nhost = hc->index;
1148  GNUNET_assert (nhost <= rc->num_hosts);
1149  GNUNET_assert (host == rc->hosts[nhost]);
1150  hc->h = NULL;
1151  if (GNUNET_NO == status)
1152  {
1153  if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
1154  LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Host %s cannot start testbed\n"),
1156  else
1158  _ ("Testbed cannot be started on localhost\n"));
1160  return;
1161  }
1162  rc->reg_hosts++;
1163  if (rc->reg_hosts < rc->num_hosts)
1164  return;
1165  GNUNET_free (rc->hclist);
1166  rc->hclist = NULL;
1167  rc->h = rc->hosts[0];
1168  rc->num_hosts--;
1169  if (0 < rc->num_hosts)
1170  {
1171  old_hosts = rc->hosts;
1172  rc->hosts =
1173  GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts);
1174  GNUNET_memcpy (rc->hosts, &old_hosts[1],
1175  (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts));
1176  GNUNET_free (old_hosts);
1177  }
1178  else
1179  {
1180  GNUNET_free (rc->hosts);
1181  rc->hosts = NULL;
1182  }
1184  for (nhost = 0; nhost < rc->num_hosts; nhost++)
1185  GNUNET_TESTBED_host_resolve_ (rc->hosts[nhost]);
1187  if (NULL == rc->trusted_ip)
1188  rc->trusted_ip = GNUNET_strdup ("127.0.0.1");
1189  rc->cproc =
1191  &controller_status_cb, rc);
1192  GNUNET_free (rc->trusted_ip);
1193  rc->trusted_ip = NULL;
1194  if (NULL == rc->cproc)
1195  {
1196  LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Cannot start the master controller"));
1198  }
1199 }
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:396
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:526
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
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 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 1208 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().

1209 {
1210  struct GNUNET_TESTBED_RunHandle *rc = cls;
1211 
1212  rc->timeout_task = NULL;
1214  _ ("Shutting down testbed due to timeout while setup.\n"));
1216  if (NULL != rc->test_master)
1217  rc->test_master (rc->test_master_cls, rc, 0, NULL, 0, 0);
1218  rc->test_master = NULL;
1219 }
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:526
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#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: