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 compatibility 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 RunContextOperation *	search_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 successful 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_Controller *	GNUNET_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__)

Generic loggins shorthand.

Definition at line 39 of file testbed_api_testbed.c.

DEBUG

#define DEBUG

(

...

)

LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging shortcut.

Definition at line 45 of file testbed_api_testbed.c.

DEFAULT_SETUP_TIMEOUT

#define DEFAULT_SETUP_TIMEOUT   300

The default setup timeout in seconds.

Definition at line 51 of file testbed_api_testbed.c.

TESTBED_CONFIG_SECTION

#define TESTBED_CONFIG_SECTION   "testbed"

Configuration section for testbed.

Definition at line 57 of file testbed_api_testbed.c.

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.

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.

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.

{
  RC_INIT = 0,
 
  RC_LINKED,
 
  RC_PEERS_CREATED,
 
  RC_READY,
 
  /* /\** */
  /*  * Peers are stopped */
  /*  *\/ */
  /* RC_PEERS_STOPPED, */
 
  /* /\** */
  /*  * Peers are destroyed */
  /*  *\/ */
  /* RC_PEERS_DESTROYED */
 
  RC_PEERS_SHUTDOWN
};

Function Documentation

rcop_key()

static uint32_t rcop_key ( void *  rcop )

static

Return a 32-bit key from a pointer.

Parameters

rcop	the pointer

Returns

32-bit key

Definition at line 338 of file testbed_api_testbed.c.

{
  return *((uint32_t *) &rcop);
}

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

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

cls	the SearchContext
key	the 32-bit key
value	the RunContextOperation element

Returns

GNUNET_YES to continue iteration; GNUNET_NO to cancel it

Definition at line 370 of file testbed_api_testbed.c.

{
  struct RunContextOperation *rcop = value;
  struct SearchContext *sc = cls;
 
  GNUNET_assert (NULL != rcop);
  if (sc->query == rcop->op)
  {
    GNUNET_assert (NULL == sc->result);
    sc->result = rcop;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, RunContextOperation::op, sc, and value.

Referenced by search_rcop().

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

rc	the RunContext whose rcop_map will be searched for the given operation
op	the given operation to search for

Returns

the matching RunContextOperation if found; NULL if not

Definition at line 395 of file testbed_api_testbed.c.

{
  struct SearchContext sc;
 
  sc.query = op;
  sc.result = NULL;
  if (GNUNET_SYSERR ==
      GNUNET_CONTAINER_multihashmap32_get_multiple (rc->rcop_map,
                                                    rcop_key (op),
                                                    &search_iterator,
                                                    &sc))
  {
    GNUNET_assert (NULL != sc.result);
    return sc.result;
  }
  return NULL;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, op, rcop_key(), GNUNET_TESTBED_RunHandle::rcop_map, sc, and search_iterator().

Referenced by event_cb().

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

rc	the RunContext into whose map is to be used for insertion
rcop	the RunContextOperation to insert

Definition at line 422 of file testbed_api_testbed.c.

{
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_put (rc->rcop_map,
                                                      rcop_key (rcop->op), rcop,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
}

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().

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

rc	the RunContext from whose map the given RunContextOperaton has to be removed
rcop	the RunContextOperation

Definition at line 440 of file testbed_api_testbed.c.

{
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap32_remove (rc->rcop_map,
                                                         rcop_key (rcop->op),
                                                         rcop));
}

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().

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

rc	the run context

Definition at line 456 of file testbed_api_testbed.c.

{
  unsigned int hid;
 
  GNUNET_assert (NULL == rc->register_hosts_task);
  GNUNET_assert (NULL == rc->reg_handle);
  GNUNET_assert (NULL == rc->peers);
  GNUNET_assert (NULL == rc->hclist);
  GNUNET_assert (RC_PEERS_SHUTDOWN == rc->state);
  GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (rc->rcop_map));
  GNUNET_CONTAINER_multihashmap32_destroy (rc->rcop_map);
  if (NULL != rc->c)
    GNUNET_TESTBED_controller_disconnect (rc->c);
  if (NULL != rc->cproc)
    GNUNET_TESTBED_controller_stop (rc->cproc);
  if (NULL != rc->h)
    GNUNET_TESTBED_host_destroy (rc->h);
  for (hid = 0; hid < rc->num_hosts; hid++)
    GNUNET_TESTBED_host_destroy (rc->hosts[hid]);
  GNUNET_free (rc->hosts);
  if (NULL != rc->cfg)
    GNUNET_CONFIGURATION_destroy (rc->cfg);
  GNUNET_free (rc->topo_file);
  GNUNET_free (rc->trusted_ip);
  GNUNET_free (rc);
}

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_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().

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

cls	the RunContext
key	the 32-bit key
value	the RunContextOperation element

Returns

always GNUNET_YES

Definition at line 493 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct RunContextOperation *rcop = value;
 
  GNUNET_assert (rc == rcop->rc);
  remove_rcop (rc, rcop);
  GNUNET_TESTBED_operation_done (rcop->op);
  GNUNET_free (rcop);
  return GNUNET_YES;
}

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

Referenced by rc_cleanup_operations().

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

rc	the RunContext

Definition at line 512 of file testbed_api_testbed.c.

{
  struct CompatibilityCheckContext *hc;
  unsigned int nhost;
 
  if (NULL != rc->hclist)
  {
    for (nhost = 0; nhost < rc->num_hosts; nhost++)
    {
      hc = &rc->hclist[nhost];
      if (NULL != hc->h)
        GNUNET_TESTBED_is_host_habitable_cancel (hc->h);
    }
    GNUNET_free (rc->hclist);
    rc->hclist = NULL;
  }
  /* Stop register hosts task if it is running */
  if (NULL != rc->register_hosts_task)
  {
    GNUNET_SCHEDULER_cancel (rc->register_hosts_task);
    rc->register_hosts_task = NULL;
  }
  if (NULL != rc->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (rc->timeout_task);
    rc->timeout_task = NULL;
  }
  if (NULL != rc->reg_handle)
  {
    GNUNET_TESTBED_cancel_registration (rc->reg_handle);
    rc->reg_handle = NULL;
  }
  if (NULL != rc->topology_operation)
  {
    GNUNET_TESTBED_operation_done (rc->topology_operation);
    rc->topology_operation = NULL;
  }
  /* cancel any exiting operations */
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CONTAINER_multihashmap32_iterate (rc->rcop_map,
                                                          &rcop_cleanup_iterator,
                                                          rc));
}

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, CompatibilityCheckContext::rc, 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().

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

rc	the run context

Definition at line 563 of file testbed_api_testbed.c.

{
  GNUNET_SCHEDULER_cancel (rc->interrupt_task);
  rc->interrupt_task = NULL;
}

References GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_RunHandle::interrupt_task, and CompatibilityCheckContext::rc.

Referenced by wait_op_completion().

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

cls	run context

Definition at line 577 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct RunContextOperation *rcop;
 
  if ((NULL == rc->cproc)
      || (NULL == rc->c)
      || (GNUNET_YES == rc->shutdown))
  {
    if (NULL != rc->peers)
    {
      GNUNET_free (rc->peers);
      rc->peers = NULL;
    }
    goto cleanup_;
  }
  if (NULL == rc->peers)
    goto cleanup_;
  rc->shutdown = GNUNET_YES;
  rcop = GNUNET_new (struct RunContextOperation);
  rcop->rc = rc;
  rcop->op = GNUNET_TESTBED_shutdown_peers (rc->c, rcop, NULL, NULL);
  GNUNET_assert (NULL != rcop->op);
  DEBUG ("Shutting down peers\n");
  rc->pstart_time = GNUNET_TIME_absolute_get ();
  insert_rcop (rc, rcop);
  return;
 
cleanup_:
  rc->state = RC_PEERS_SHUTDOWN;
  cancel_interrupt_task (rc);
  cleanup (rc);
}

References GNUNET_TESTBED_RunHandle::c, cancel_interrupt_task(), cleanup(), 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().

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

cls	the RunContext which has to be acted upon

Definition at line 618 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct GNUNET_TESTBED_Controller *c = rc->c;
  unsigned int size;
 
  /* reschedule */
  rc->interrupt_task = GNUNET_SCHEDULER_add_shutdown (&interrupt, rc);
  rc_cleanup_operations (rc);
  if ((GNUNET_NO == rc->shutdown) &&
      (NULL != c) &&
      (NULL != c->opc_map) &&
      (0 != (size = GNUNET_CONTAINER_multihashmap32_size (c->opc_map))))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Shutdown postponed as there are %u operations currently active\n",
         size);
    c->opcq_empty_cb = &wait_op_completion;
    c->opcq_empty_cls = rc;
    return;
  }
  wait_op_completion (rc);
}

References GNUNET_TESTBED_RunHandle::c, 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, rc_cleanup_operations(), GNUNET_TESTBED_RunHandle::shutdown, size, and wait_op_completion().

Referenced by GNUNET_TESTBED_run().

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

rc	the RunContext

Returns

the representation string; this is NOT reentrant

Definition at line 651 of file testbed_api_testbed.c.

{
  struct GNUNET_TIME_Relative ptime;
 
  ptime = GNUNET_TIME_absolute_get_duration (rc->pstart_time);
  return GNUNET_STRINGS_relative_time_to_string (ptime, GNUNET_YES);
}

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().

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

cls	the RunHandle

Definition at line 666 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct RunContextOperation *rcop;
  unsigned int peer;
 
  DEBUG ("Starting Peers\n");
  rc->pstart_time = GNUNET_TIME_absolute_get ();
  for (peer = 0; peer < rc->num_peers; peer++)
  {
    rcop = GNUNET_new (struct RunContextOperation);
    rcop->rc = rc;
    rcop->op = GNUNET_TESTBED_peer_start (NULL, rc->peers[peer], NULL, NULL);
    GNUNET_assert (NULL != rcop->op);
    rcop->cls = rc->peers[peer];
    insert_rcop (rc, rcop);
  }
  rc->peer_count = 0;
}

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().

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

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

Definition at line 697 of file testbed_api_testbed.c.

{
  struct RunContextOperation *rcop = cls;
  struct GNUNET_TESTBED_RunHandle *rc;
 
  GNUNET_assert (NULL != rcop);
  GNUNET_assert (NULL != (rc = rcop->rc));
  remove_rcop (rc, rcop);
  GNUNET_TESTBED_operation_done (rcop->op);
  GNUNET_free (rcop);
  if (NULL == peer)
  {
    if (NULL != emsg)
      LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
           emsg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  rc->peers[rc->peer_count] = peer;
  rc->peer_count++;
  if (rc->peer_count < rc->num_peers)
    return;
  DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
  rc->state = RC_PEERS_CREATED;
  GNUNET_SCHEDULER_add_now (&start_peers_task, rc);
}

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().

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

rc	the RunContext

Definition at line 731 of file testbed_api_testbed.c.

{
  GNUNET_SCHEDULER_cancel (rc->timeout_task);
  rc->timeout_task = NULL;
  if (NULL != rc->test_master)
    rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
                     rc->links_succeeded, rc->links_failed);
}

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().

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

cls	the operation closure given to GNUNET_TESTBED_overlay_configure_topology_va() and GNUNET_TESTBED_overlay_configure() calls
nsuccess	the number of successful overlay connects
nfailures	the number of overlay connects which failed

Definition at line 751 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
 
  DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
  GNUNET_TESTBED_operation_done (rc->topology_operation);
  rc->topology_operation = NULL;
  rc->links_succeeded = nsuccess;
  rc->links_failed = nfailures;
  rc->state = RC_READY;
  call_master (rc);
}

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

Referenced by event_cb().

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

rc	the RunContext

Definition at line 772 of file testbed_api_testbed.c.

{
  struct RunContextOperation *rcop;
  unsigned int peer;
 
  DEBUG ("Creating peers\n");
  rc->pstart_time = GNUNET_TIME_absolute_get ();
  rc->peers =
    GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Peer *) * rc->num_peers);
  GNUNET_assert (NULL != rc->c);
  rc->peer_count = 0;
  for (peer = 0; peer < rc->num_peers; peer++)
  {
    rcop = GNUNET_new (struct RunContextOperation);
    rcop->rc = rc;
    rcop->op =
      GNUNET_TESTBED_peer_create (rc->c,
                                  (0 ==
                                   rc->num_hosts) ? rc->h : rc->hosts[peer
                                                                      % rc->
                                                                      num_hosts],
                                  rc->cfg, &peer_create_cb, rcop);
    GNUNET_assert (NULL != rcop->op);
    insert_rcop (rc, rcop);
  }
}

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().

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

cls	closure
event	information about the event

Definition at line 808 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct RunContextOperation *rcop;
 
  if (RC_INIT == rc->state)
  {
    switch (event->type)
    {
    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
      rcop = event->op_cls;
      if (NULL != event->details.operation_finished.emsg)
      {
        LOG (GNUNET_ERROR_TYPE_ERROR, _ (
               "Linking controllers failed. Exiting"));
        GNUNET_SCHEDULER_shutdown ();
      }
      else
        rc->reg_hosts++;
      GNUNET_assert (event->op == rcop->op);
      remove_rcop (rc, rcop);
      GNUNET_TESTBED_operation_done (rcop->op);
      GNUNET_free (rcop);
      if (rc->reg_hosts == rc->num_hosts)
      {
        rc->state = RC_LINKED;
        create_peers (rc);
      }
      return;
 
    default:
      GNUNET_break (0);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
  if (GNUNET_TESTBED_ET_OPERATION_FINISHED != event->type)
    goto call_cc;
  if (NULL == (rcop = search_rcop (rc, event->op)))
    goto call_cc;
  remove_rcop (rc, rcop);
  GNUNET_TESTBED_operation_done (rcop->op);
  GNUNET_free (rcop);
  if ((GNUNET_NO == rc->shutdown)
      && (NULL != event->details.operation_finished.emsg))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR, "A operation has failed with error: %s\n",
         event->details.operation_finished.emsg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_assert (GNUNET_YES == rc->shutdown);
  switch (rc->state)
  {
  case RC_LINKED:
  case RC_PEERS_CREATED:
  case RC_READY:
    rc->state = RC_PEERS_SHUTDOWN;
    GNUNET_free (rc->peers);
    rc->peers = NULL;
    DEBUG ("Peers shut down in %s\n", prof_time (rc));
    GNUNET_SCHEDULER_shutdown ();
    break;
 
  default:
    GNUNET_assert (0);
  }
  return;
 
call_cc:
  if ((0 != (rc->event_mask & (1LL << event->type))) && (NULL != rc->cc))
    rc->cc (rc->cc_cls, event);
  if (GNUNET_TESTBED_ET_PEER_START != event->type)
    return;
  if (NULL == (rcop = search_rcop (rc, event->op))) /* Not our operation */
    return;
  remove_rcop (rc, rcop);
  GNUNET_TESTBED_operation_done (rcop->op);
  GNUNET_free (rcop);
  rc->peer_count++;
  if (rc->peer_count < rc->num_peers)
    return;
  DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
  if (GNUNET_TESTBED_TOPOLOGY_NONE != rc->topology)
  {
    switch (rc->topology)
    {
    case GNUNET_TESTBED_TOPOLOGY_NONE:
      GNUNET_assert (0);
 
    case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
    case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
    case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
      rc->topology_operation =
        GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
                                                   rc->peers, &rc->num_oc,
                                                   &topology_completion_callback,
                                                   rc,
                                                   rc->topology,
                                                   rc->random_links,
                                                   GNUNET_TESTBED_TOPOLOGY_OPTION_END);
      break;
 
    case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
      GNUNET_assert (NULL != rc->topo_file);
      rc->topology_operation =
        GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
                                                   rc->peers, &rc->num_oc,
                                                   &topology_completion_callback,
                                                   rc,
                                                   rc->topology,
                                                   rc->topo_file,
                                                   GNUNET_TESTBED_TOPOLOGY_OPTION_END);
      break;
 
    case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
      {
        unsigned long long number;
        unsigned int cap;
        GNUNET_assert (GNUNET_OK ==
                       GNUNET_CONFIGURATION_get_value_number (rc->cfg,
                                                              TESTBED_CONFIG_SECTION,
                                                              SCALE_FREE_CAP,
                                                              &number));
        cap = (unsigned int) number;
        GNUNET_assert (GNUNET_OK ==
                       GNUNET_CONFIGURATION_get_value_number (rc->cfg,
                                                              TESTBED_CONFIG_SECTION,
                                                              SCALE_FREE_M,
                                                              &number));
        rc->topology_operation =
          GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
                                                     rc->peers, &rc->num_oc,
                                                     &
                                                     topology_completion_callback,
                                                     rc,
                                                     rc->topology,
                                                     cap,      /* uint16_t */
                                                     (unsigned int) number,   /* uint8_t */
                                                     GNUNET_TESTBED_TOPOLOGY_OPTION_END);
      }
      break;
 
    default:
      rc->topology_operation =
        GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
                                                   rc->peers, &rc->num_oc,
                                                   &topology_completion_callback,
                                                   rc,
                                                   rc->topology,
                                                   GNUNET_TESTBED_TOPOLOGY_OPTION_END);
    }
    if (NULL == rc->topology_operation)
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Not generating a topology. Check number of peers\n");
    else
    {
      DEBUG ("Creating overlay topology\n");
      rc->pstart_time = GNUNET_TIME_absolute_get ();
      return;
    }
  }
  rc->state = RC_READY;
  call_master (rc);
}

References _, call_master(), GNUNET_TESTBED_RunHandle::cc, GNUNET_TESTBED_RunHandle::cc_cls, GNUNET_TESTBED_RunHandle::cfg, 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_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, consensus-simulation::int, LOG, GNUNET_TESTBED_RunHandle::num_hosts, GNUNET_TESTBED_RunHandle::num_oc, GNUNET_TESTBED_RunHandle::num_peers, number, GNUNET_TESTBED_EventInformation::op, RunContextOperation::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, 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().

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

cls	the RunContext

Definition at line 1009 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  struct RunContextOperation *rcop;
  unsigned int slave;
 
  rc->register_hosts_task = NULL;
  if (rc->reg_hosts == rc->num_hosts)
  {
    DEBUG ("All hosts successfully registered\n");
    /* Start slaves */
    for (slave = 0; slave < rc->num_hosts; slave++)
    {
      rcop = GNUNET_new (struct RunContextOperation);
      rcop->rc = rc;
      rcop->op =
        GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave],
                                        rc->h, GNUNET_YES);
      GNUNET_assert (NULL != rcop->op);
      insert_rcop (rc, rcop);
    }
    rc->reg_hosts = 0;
    return;
  }
  rc->reg_handle =
    GNUNET_TESTBED_register_host (rc->c, rc->hosts[rc->reg_hosts],
                                  host_registration_completion, rc);
  rc->reg_hosts++;
}

References GNUNET_TESTBED_RunHandle::c, 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(), and host_registration_completion().

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

cls	the closure
emsg	the error message; NULL if host registration is successful

Definition at line 991 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
 
  rc->reg_handle = NULL;
  if (NULL != emsg)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ ("Host registration failed for a host. Error: %s\n"), emsg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  rc->register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts,
                                                      rc);
}

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

Referenced by register_hosts().

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 successful startup of the controller process.

Parameters

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

Definition at line 1050 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  uint64_t event_mask;
 
  if (status != GNUNET_OK)
  {
    rc->cproc = NULL;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Controller crash detected. Shutting down.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_CONFIGURATION_destroy (rc->cfg);
  rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
  event_mask = rc->event_mask;
  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
  if (rc->topology < GNUNET_TESTBED_TOPOLOGY_NONE)
    event_mask |= GNUNET_TESTBED_ET_CONNECT;
  rc->c =
    GNUNET_TESTBED_controller_connect (rc->h, event_mask, &event_cb, rc);
  if (0 < rc->num_hosts)
  {
    rc->reg_hosts = 0;
    rc->register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, rc);
    return;
  }
  rc->state = RC_LINKED;
  create_peers (rc);
}

References _, GNUNET_TESTBED_RunHandle::c, cfg, GNUNET_TESTBED_RunHandle::cfg, 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, RC_LINKED, GNUNET_TESTBED_RunHandle::reg_hosts, register_hosts(), GNUNET_TESTBED_RunHandle::register_hosts_task, GNUNET_TESTBED_RunHandle::state, status, and GNUNET_TESTBED_RunHandle::topology.

Referenced by GNUNET_TESTBED_run(), and host_habitable_cb().

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

cls	closure
name	name of the interface (can be NULL for unknown)
isDefault	is this presumably the default interface
addr	address of this interface (can be NULL for unknown or unassigned)
broadcast_addr	the broadcast address (can be NULL for unknown or unassigned)
netmask	the network mask (can be NULL for unknown or unassigned))
addrlen	length of the address

Returns

GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 1097 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
  char hostip[NI_MAXHOST];
  char *buf;
 
  if (sizeof(struct sockaddr_in) != addrlen)
    return GNUNET_OK;           /* Only consider IPv4 for now */
  if (0 !=
      getnameinfo (addr, addrlen, hostip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getnameinfo");
  if (NULL == rc->trusted_ip)
  {
    rc->trusted_ip = GNUNET_strdup (hostip);
    return GNUNET_YES;
  }
  (void) GNUNET_asprintf (&buf, "%s; %s", rc->trusted_ip, hostip);
  GNUNET_free (rc->trusted_ip);
  rc->trusted_ip = buf;
  return GNUNET_YES;
}

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

Referenced by host_habitable_cb().

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

cls	NULL
host	the host whose status is being reported; will be NULL if the host given to GNUNET_TESTBED_is_host_habitable() is NULL
status	GNUNET_YES if it is habitable; GNUNET_NO if not

Definition at line 1133 of file testbed_api_testbed.c.

{
  struct CompatibilityCheckContext *hc = cls;
  struct GNUNET_TESTBED_RunHandle *rc;
  struct GNUNET_TESTBED_Host **old_hosts;
  unsigned int nhost;
 
  GNUNET_assert (NULL != (rc = hc->rc));
  nhost = hc->index;
  GNUNET_assert (nhost <= rc->num_hosts);
  GNUNET_assert (host == rc->hosts[nhost]);
  hc->h = NULL;
  if (GNUNET_NO == status)
  {
    if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
      LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Host %s cannot start testbed\n"),
           GNUNET_TESTBED_host_get_hostname (host));
    else
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Testbed cannot be started on localhost\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  rc->reg_hosts++;
  if (rc->reg_hosts < rc->num_hosts)
    return;
  GNUNET_free (rc->hclist);
  rc->hclist = NULL;
  rc->h = rc->hosts[0];
  rc->num_hosts--;
  if (0 < rc->num_hosts)
  {
    old_hosts = rc->hosts;
    rc->hosts =
      GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts);
    GNUNET_memcpy (rc->hosts, &old_hosts[1],
                   (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts));
    GNUNET_free (old_hosts);
  }
  else
  {
    GNUNET_free (rc->hosts);
    rc->hosts = NULL;
  }
  GNUNET_TESTBED_host_resolve_ (rc->h);
  for (nhost = 0; nhost < rc->num_hosts; nhost++)
    GNUNET_TESTBED_host_resolve_ (rc->hosts[nhost]);
  GNUNET_OS_network_interfaces_list (netint_proc, rc);
  if (NULL == rc->trusted_ip)
    rc->trusted_ip = GNUNET_strdup ("127.0.0.1");
  rc->cproc =
    GNUNET_TESTBED_controller_start (rc->trusted_ip, rc->h,
                                     &controller_status_cb, rc);
  GNUNET_free (rc->trusted_ip);
  rc->trusted_ip = NULL;
  if (NULL == rc->cproc)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Cannot start the master controller"));
    GNUNET_SCHEDULER_shutdown ();
  }
}

References _, 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, CompatibilityCheckContext::rc, GNUNET_TESTBED_RunHandle::reg_hosts, status, and GNUNET_TESTBED_RunHandle::trusted_ip.

Referenced by GNUNET_TESTBED_run().

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

cls	the RunContext

Definition at line 1203 of file testbed_api_testbed.c.

{
  struct GNUNET_TESTBED_RunHandle *rc = cls;
 
  rc->timeout_task = NULL;
  LOG (GNUNET_ERROR_TYPE_ERROR,
       _ ("Shutting down testbed due to timeout while setup.\n"));
  GNUNET_SCHEDULER_shutdown ();
  if (NULL != rc->test_master)
    rc->test_master (rc->test_master_cls, rc, 0, NULL, 0, 0);
  rc->test_master = NULL;
}

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

Referenced by GNUNET_TESTBED_run().

Here is the call graph for this function:

Here is the caller graph for this function: