/*
This file is part of GNUnet
- (C) 2008--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008--2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#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"
*/
#define DEFAULT_SETUP_TIMEOUT 300
+
/**
- * Testbed Run Handle
+ * Configuration section for testbed
+ */
+#define TESTBED_CONFIG_SECTION "testbed"
+
+/**
+ * Option string for the maximum number of edges a peer is permitted to have
+ * while generating scale free topology
+ */
+#define SCALE_FREE_CAP "SCALE_FREE_TOPOLOGY_CAP"
+
+/**
+ * Option string for the number of edges to be established when adding a new
+ * node to the scale free network
*/
-struct RunContext;
+#define SCALE_FREE_M "SCALE_FREE_TOPOLOGY_M"
/**
* Context information for the operation we start
/**
* Context information for GNUNET_TESTBED_run()
*/
- struct RunContext *rc;
+ struct GNUNET_TESTBED_RunHandle *rc;
/**
* Closure
*/
RC_INIT = 0,
-#if ENABLE_LL
- /**
- * Island level controllers are started and linked
- */
- RC_ISLANDS_LINKED,
-#endif
-
/**
* Controllers on given hosts started and linked
*/
/**
* The run context
*/
- struct RunContext *rc;
+ struct GNUNET_TESTBED_RunHandle *rc;
/**
* Handle for the compability check
unsigned int index;
};
-#if ENABLE_LL
-/**
- * Structure to represent an island of SuperMUC's nodes
- */
-struct Island
-{
- /**
- * Array of nodes in this island
- */
- struct GNUNET_TESTBED_Host **hosts;
-
- /**
- * Number of nodes in the above array
- */
- unsigned int nhosts;
-};
-#endif
/**
* Testbed Run Handle
*/
-struct RunContext
+struct GNUNET_TESTBED_RunHandle
{
/**
* The controller handle
*/
struct GNUNET_TESTBED_Host **hosts;
-#if ENABLE_LL
- /**
- * Array of SuperMUC islands
- */
- struct Island **islands;
-#endif
-
/**
* Array of compatibility check contexts
*/
struct GNUNET_TESTBED_Operation *topology_operation;
/**
- * The file containing topology data. Only used if the topology is set to
- * 'FROM_FILE'
+ * The file containing topology data. Only used if the topology is set to 'FROM_FILE'
*/
char *topo_file;
/**
* Host registration task
*/
- GNUNET_SCHEDULER_TaskIdentifier register_hosts_task;
-
- /**
- * Task to be run while shutting down
- */
- GNUNET_SCHEDULER_TaskIdentifier shutdown_run_task;
+ struct GNUNET_SCHEDULER_Task * register_hosts_task;
/**
* Task to be run of a timeout
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ struct GNUNET_SCHEDULER_Task * timeout_task;
/**
* Task run upon shutdown interrupts
*/
- GNUNET_SCHEDULER_TaskIdentifier interrupt_task;
+ struct GNUNET_SCHEDULER_Task *interrupt_task;
/**
* The event mask for the controller
*/
unsigned int links_failed;
-#if ENABLE_LL
- /**
- * Number of SuperMUC islands we are running on
- */
- unsigned int nislands;
-#endif
};
*/
static uint32_t
rcop_key (void *rcop)
-{
+{
return * ((uint32_t *) &rcop);
}
* @return the matching RunContextOperation if found; NULL if not
*/
static struct RunContextOperation *
-search_rcop (struct RunContext *rc, struct GNUNET_TESTBED_Operation *op)
+search_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct GNUNET_TESTBED_Operation *op)
{
struct SearchContext sc;
-
+
sc.query = op;
sc.result = NULL;
- if (GNUNET_SYSERR ==
+ if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap32_get_multiple (rc->rcop_map,
rcop_key (op),
&search_iterator,
* @param rcop the RunContextOperation to insert
*/
static void
-insert_rcop (struct RunContext *rc, struct RunContextOperation *rcop)
+insert_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
{
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap32_put (rc->rcop_map,
* @param rcop the RunContextOperation
*/
static void
-remove_rcop (struct RunContext *rc, struct RunContextOperation *rcop)
+remove_rcop (struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
{
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap32_remove (rc->rcop_map,
rcop));
}
-#if ENABLE_LL
-static void
-cleanup_islands (struct RunContext *rc)
-{
- struct Island *island;
- unsigned int cnt;
-
- GNUNET_assert (NULL != rc->islands);
- for (cnt = 0; cnt < rc->nislands; cnt++)
- {
- island = rc->islands[cnt];
- GNUNET_free (island->hosts);
- GNUNET_free (island);
- }
- GNUNET_free (rc->islands);
- rc->islands = NULL;
-}
-#endif
-
/**
* Assuming all peers have been destroyed cleanup run handle
*
- * @param cls the run handle
- * @param tc the task context from scheduler
+ * @param rc the run context
*/
static void
-cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup (struct GNUNET_TESTBED_RunHandle *rc)
{
- struct RunContext *rc = cls;
- unsigned int cnt;
+ unsigned int hid;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rc->register_hosts_task);
+ GNUNET_assert (NULL == rc->register_hosts_task);
GNUNET_assert (NULL == rc->reg_handle);
GNUNET_assert (NULL == rc->peers);
GNUNET_assert (NULL == rc->hclist);
GNUNET_TESTBED_controller_stop (rc->cproc);
if (NULL != rc->h)
GNUNET_TESTBED_host_destroy (rc->h);
-#if ENABLE_LL
- if (NULL != rc->islands)
- cleanup_islands (rc);
-#endif
- for (cnt = 0; cnt < rc->num_hosts; cnt++)
- GNUNET_TESTBED_host_destroy (rc->hosts[cnt]);
+ for (hid = 0; hid < rc->num_hosts; hid++)
+ GNUNET_TESTBED_host_destroy (rc->hosts[hid]);
GNUNET_free_non_null (rc->hosts);
if (NULL != rc->cfg)
GNUNET_CONFIGURATION_destroy (rc->cfg);
/**
- * Iterator for cleaning up elements from rcop_map
+ * Iterator for cleaning up elements from rcop_map
*
* @param cls the RunContext
* @param key the 32-bit key
static int
rcop_cleanup_iterator (void *cls, uint32_t key, void *value)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop = value;
GNUNET_assert (rc == rcop->rc);
/**
- * Frees memory, closes pending operations, cancels actives tasks of the given
- * RunContext
+ * Cancels operations and tasks which are assigned to the given run context
*
* @param rc the RunContext
*/
static void
-cleanup (struct RunContext *rc)
+rc_cleanup_operations (struct GNUNET_TESTBED_RunHandle *rc)
{
struct CompatibilityCheckContext *hc;
unsigned int nhost;
rc->hclist = NULL;
}
/* Stop register hosts task if it is running */
- if (GNUNET_SCHEDULER_NO_TASK != rc->register_hosts_task)
+ if (NULL != rc->register_hosts_task)
{
GNUNET_SCHEDULER_cancel (rc->register_hosts_task);
- rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
+ rc->register_hosts_task = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != rc->timeout_task)
+ if (NULL != rc->timeout_task)
{
GNUNET_SCHEDULER_cancel (rc->timeout_task);
- rc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- if (GNUNET_SCHEDULER_NO_TASK != rc->interrupt_task)
- {
- GNUNET_SCHEDULER_cancel (rc->interrupt_task);
- rc->interrupt_task = GNUNET_SCHEDULER_NO_TASK;
+ rc->timeout_task = NULL;
}
if (NULL != rc->reg_handle)
{
rc->topology_operation = NULL;
}
/* cancel any exiting operations */
- GNUNET_assert (GNUNET_SYSERR !=
+ GNUNET_assert (GNUNET_SYSERR !=
GNUNET_CONTAINER_multihashmap32_iterate (rc->rcop_map,
&rcop_cleanup_iterator,
rc));
/**
- * Stops the testbed run and releases any used resources
+ * Cancels the scheduled interrupt task
*
- * @param cls the tesbed run handle
- * @param tc the task context from scheduler
+ * @param rc the run context
*/
static void
-shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc)
{
- struct RunContext *rc = cls;
- struct RunContextOperation *rcop;
-
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rc->shutdown_run_task);
- rc->shutdown_run_task = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_assert (GNUNET_NO == rc->shutdown);
- rc->shutdown = GNUNET_YES;
- cleanup (rc);
- if (NULL != rc->c)
- {
- if (NULL != rc->peers)
- {
- rcop = GNUNET_malloc (sizeof (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;
- }
- }
- rc->state = RC_PEERS_SHUTDOWN; /* No peers are present so we consider the
- * state where all peers are SHUTDOWN */
- GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
+ GNUNET_SCHEDULER_cancel (rc->interrupt_task);
+ rc->interrupt_task = NULL;
}
/**
- * Function to shutdown now
+ * This callback will be called when all the operations are completed
+ * (done/cancelled)
*
- * @param rc the RunContext
+ * @param cls run context
*/
static void
-shutdown_now (struct RunContext *rc)
+wait_op_completion (void *cls)
{
- if (GNUNET_YES == rc->shutdown)
- return;
- if (GNUNET_SCHEDULER_NO_TASK != rc->shutdown_run_task)
- GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
- GNUNET_SCHEDULER_shutdown (); /* Trigger shutdown in programs using this API */
- rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+ 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);
}
/**
- * Task run upon any interrupt. Common ones are SIGINT & SIGTERM.
+ * Task run upon interrupts (SIGINT, SIGTERM) and upon scheduler shutdown.
*
* @param cls the RunContext which has to be acted upon
- * @param tc the scheduler task context
*/
static void
-interrupt (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+interrupt (void *cls)
{
- struct RunContext *rc = cls;
-
- rc->interrupt_task = GNUNET_SCHEDULER_NO_TASK;
- shutdown_now (rc);
+ 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);
}
* @return the representation string; this is NOT reentrant
*/
static const char *
-prof_time (struct RunContext *rc)
+prof_time (struct GNUNET_TESTBED_RunHandle *rc)
{
struct GNUNET_TIME_Relative ptime;
* Task for starting peers
*
* @param cls the RunHandle
- * @param tc the task context from scheduler
*/
static void
-start_peers_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+start_peers_task (void *cls)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop;
unsigned int peer;
rc->pstart_time = GNUNET_TIME_absolute_get ();
for (peer = 0; peer < rc->num_peers; peer++)
{
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
+ 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);
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
struct RunContextOperation *rcop = cls;
- struct RunContext *rc;
+ struct GNUNET_TESTBED_RunHandle *rc;
GNUNET_assert (NULL != rcop);
GNUNET_assert (NULL != (rc = rcop->rc));
if (NULL != emsg)
LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
emsg);
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
rc->peers[rc->peer_count] = peer;
* @param rc the RunContext
*/
static void
-call_master (struct RunContext *rc)
+call_master (struct GNUNET_TESTBED_RunHandle *rc)
{
GNUNET_SCHEDULER_cancel (rc->timeout_task);
- rc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ rc->timeout_task = NULL;
if (NULL != rc->test_master)
- rc->test_master (rc->test_master_cls, rc->num_peers, rc->peers,
+ rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
rc->links_succeeded, rc->links_failed);
}
topology_completion_callback (void *cls, unsigned int nsuccess,
unsigned int nfailures)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
GNUNET_TESTBED_operation_done (rc->topology_operation);
* @param rc the RunContext
*/
static void
-create_peers (struct RunContext *rc)
+create_peers (struct GNUNET_TESTBED_RunHandle *rc)
{
struct RunContextOperation *rcop;
- struct GNUNET_TESTBED_Host *host;
unsigned int peer;
-#if ENABLE_LL
- struct Island *island;
- unsigned int icnt;
- unsigned int hcnt;
-
- island = NULL;
- icnt = 0;
- hcnt = 0;
-#endif
+
DEBUG ("Creating peers\n");
rc->pstart_time = GNUNET_TIME_absolute_get ();
rc->peers =
rc->peer_count = 0;
for (peer = 0; peer < rc->num_peers; peer++)
{
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
+ rcop = GNUNET_new (struct RunContextOperation);
rcop->rc = rc;
-#if ENABLE_LL
- if (0 != rc->nislands)
- {
- island = rc->islands[icnt];
- if (hcnt == island->nhosts)
- {
- icnt++;
- if (icnt == rc->nislands)
- icnt = 0;
- island = rc->islands[icnt];
- hcnt = 0;
- }
- GNUNET_assert (icnt < rc->nislands);
- GNUNET_assert (hcnt < island->nhosts);
- GNUNET_assert (NULL != island->hosts[hcnt]);
- host = island->hosts[hcnt];
- hcnt++;
- }
- else
- host = rc->h;
-#else
- host = (0 == rc->num_hosts) ? rc->h : rc->hosts[peer % rc->num_hosts];
-#endif
- rcop->op = GNUNET_TESTBED_peer_create (rc->c, host, rc->cfg,
- &peer_create_cb, rcop);
+ 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);
}
static void
event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop;
if (RC_INIT == rc->state)
if (NULL != event->details.operation_finished.emsg)
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Linking controllers failed. Exiting"));
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
}
else
rc->reg_hosts++;
remove_rcop (rc, rcop);
GNUNET_TESTBED_operation_done (rcop->op);
GNUNET_free (rcop);
-#if !ENABLE_LL
- if (rc->reg_hosts != rc->num_hosts)
- return;
- rc->state = RC_LINKED;
- create_peers (rc);
-#else
- if (rc->reg_hosts != rc->nislands)
- return;
- struct Island *island;
- struct GNUNET_TESTBED_Host *host;
- unsigned int cnt;
- unsigned int cnt2;
- rc->state = RC_ISLANDS_LINKED;
- rc->reg_hosts = 0;
- for (cnt = 0; cnt < rc->nislands; cnt++)
+ if (rc->reg_hosts == rc->num_hosts)
{
- island = rc->islands[cnt];
- for (cnt2 = 1; cnt2 < island->nhosts; cnt2++)
- {
- host = island->hosts[cnt2];
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
- rcop->rc = rc;
- rcop->op =
- GNUNET_TESTBED_controller_link (rcop, rc->c, host,
- island->hosts[0], GNUNET_YES);
- GNUNET_assert (NULL != rcop->op);
- insert_rcop (rc, rcop);
- rc->reg_hosts++;
- }
+ rc->state = RC_LINKED;
+ create_peers (rc);
}
- if (0 != rc->reg_hosts)
- return;
- rc->state = RC_LINKED;
- create_peers (rc);
-#endif
return;
default:
GNUNET_break (0);
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
}
-#if ENABLE_LL
- if (RC_ISLANDS_LINKED == 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 2nd level controllers failed. Exiting");
- shutdown_now (rc);
- }
- else
- rc->reg_hosts--;
- GNUNET_assert (event->op == rcop->op);
- remove_rcop (rc, rcop);
- GNUNET_TESTBED_operation_done (rcop->op);
- GNUNET_free (rcop);
- if (0 != rc->reg_hosts)
- return;
- rc->state = RC_LINKED;
- create_peers (rc);
- return;
- default:
- GNUNET_break (0);
- shutdown_now (rc);
- return;
- }
- }
-#endif
if (GNUNET_TESTBED_ET_OPERATION_FINISHED != event->type)
goto call_cc;
if (NULL == (rcop = search_rcop (rc, event->op)))
{
LOG (GNUNET_ERROR_TYPE_ERROR, "A operation has failed with error: %s\n",
event->details.operation_finished.emsg);
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_assert (GNUNET_YES == rc->shutdown);
GNUNET_free_non_null (rc->peers);
rc->peers = NULL;
DEBUG ("Peers shut down in %s\n", prof_time (rc));
- GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
+ GNUNET_SCHEDULER_shutdown ();
break;
default:
GNUNET_assert (0);
DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
if (GNUNET_TESTBED_TOPOLOGY_NONE != rc->topology)
{
- if ((GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI == rc->topology) ||
- (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING == rc->topology) ||
- (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD == 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,
rc->topology,
rc->random_links,
GNUNET_TESTBED_TOPOLOGY_OPTION_END);
- }
- else if (GNUNET_TESTBED_TOPOLOGY_FROM_FILE == rc->topology)
- {
+ 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->topology,
rc->topo_file,
GNUNET_TESTBED_TOPOLOGY_OPTION_END);
- }
- else
+ 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,
rc,
rc->topology,
GNUNET_TESTBED_TOPOLOGY_OPTION_END);
+ }
if (NULL == rc->topology_operation)
LOG (GNUNET_ERROR_TYPE_WARNING,
- "Not generating topology. Check number of peers\n");
+ "Not generating a topology. Check number of peers\n");
else
{
DEBUG ("Creating overlay topology\n");
* Task to register all hosts available in the global host list
*
* @param cls the RunContext
- * @param tc the scheduler task context
*/
static void
-register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+register_hosts (void *cls);
/**
static void
host_registration_completion (void *cls, const char *emsg)
{
- struct RunContext *rc = cls;
+ 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);
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
- rc->register_hosts_task = GNUNET_SCHEDULER_add_now (®ister_hosts, rc);
+ rc->register_hosts_task = GNUNET_SCHEDULER_add_now (®ister_hosts,
+ rc);
}
* Task to register all hosts available in the global host list
*
* @param cls RunContext
- * @param tc the scheduler task context
*/
static void
-register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+register_hosts (void *cls)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop;
- unsigned int cnt;
+ unsigned int slave;
- rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
+ rc->register_hosts_task = NULL;
if (rc->reg_hosts == rc->num_hosts)
{
DEBUG ("All hosts successfully registered\n");
- /* Start cnts */
-#if !ENABLE_LL
- for (cnt = 0; cnt < rc->num_hosts; cnt++)
+ /* Start slaves */
+ for (slave = 0; slave < rc->num_hosts; slave++)
{
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
+ rcop = GNUNET_new (struct RunContextOperation);
rcop->rc = rc;
rcop->op =
- GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[cnt],
+ GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave],
rc->h, GNUNET_YES);
GNUNET_assert (NULL != rcop->op);
insert_rcop (rc, rcop);
}
-#else
- struct Island *island;
- for (cnt = 0; cnt < rc->nislands; cnt++)
- {
- island = rc->islands[cnt];
- GNUNET_assert (0 < island->nhosts);
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
- rcop->rc = rc;
- rcop->op =
- GNUNET_TESTBED_controller_link (rcop, rc->c, island->hosts[0],
- rc->h, GNUNET_YES);
- GNUNET_assert (NULL != rcop->op);
- insert_rcop (rc, rcop);
- }
-#endif
rc->reg_hosts = 0;
return;
}
controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
int status)
{
- struct RunContext *rc = cls;
+ 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"));
- rc->cproc = NULL;
- cleanup (rc);
- if (NULL != rc->peers)
- {
- GNUNET_free (rc->peers);
- rc->peers = NULL;
- }
- if (GNUNET_YES == rc->shutdown)
- {
- rc->state = RC_PEERS_SHUTDOWN;
- GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
- }
- else
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CONFIGURATION_destroy (rc->cfg);
}
-#if ENABLE_LL
-#define ISLANDNAME_SIZE 4
-static void
-parse_islands (struct RunContext *rc)
-{
- char island_id[ISLANDNAME_SIZE];
- struct GNUNET_TESTBED_Host *host;
- struct Island *island;
- const char *hostname;
- unsigned int nhost;
-
- DEBUG ("Parsing for islands\n");
- memset (island_id, 0, ISLANDNAME_SIZE);
- island = NULL;
- for (nhost = 0; nhost < rc->num_hosts; nhost++)
- {
- host = rc->hosts[nhost];
- hostname = GNUNET_TESTBED_host_get_hostname (host);
- GNUNET_assert (NULL != hostname);
- if (NULL == island)
- {
- strncpy (island_id, hostname, ISLANDNAME_SIZE - 1);
- island = GNUNET_malloc (sizeof (struct Island));
- }
- if (0 == strncmp (island_id, hostname, ISLANDNAME_SIZE - 1))
- {
- GNUNET_array_append (island->hosts, island->nhosts, host);
- continue;
- }
- DEBUG ("Adding island `%s' with %u hosts\n", island_id, island->nhosts);
- GNUNET_array_append (rc->islands, rc->nislands, island);
- island = NULL;
- }
- if (NULL != island)
- {
- DEBUG ("Adding island `%s' with %u hosts\n", island_id, island->nhosts);
- GNUNET_array_append (rc->islands, rc->nislands, island);
- }
- DEBUG ("Total islands parsed: %u\n", rc->nislands);
-}
-#endif
-
-
/**
* Callback function invoked for each interface found.
*
const struct sockaddr *addr, const struct sockaddr *broadcast_addr,
const struct sockaddr *netmask, socklen_t addrlen)
{
- struct RunContext *rc = cls;
+ struct GNUNET_TESTBED_RunHandle *rc = cls;
char hostip[NI_MAXHOST];
char *buf;
int status)
{
struct CompatibilityCheckContext *hc = cls;
- struct RunContext *rc;
+ struct GNUNET_TESTBED_RunHandle *rc;
struct GNUNET_TESTBED_Host **old_hosts;
unsigned int nhost;
else
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Testbed cannot be started on localhost\n"));
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
rc->reg_hosts++;
GNUNET_free (rc->hosts);
rc->hosts = NULL;
}
-#if ENABLE_LL
- parse_islands (rc);
-#endif
GNUNET_TESTBED_host_resolve_ (rc->h);
for (nhost = 0; nhost < rc->num_hosts; nhost++)
GNUNET_TESTBED_host_resolve_ (rc->hosts[nhost]);
if (NULL == rc->cproc)
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Cannot start the master controller"));
- shutdown_now (rc);
+ GNUNET_SCHEDULER_shutdown ();
}
}
* Task run upon timeout while setting up the testbed
*
* @param cls the RunContext
- * @param tc the task context
*/
static void
-timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_task (void *cls)
{
- struct RunContext *rc = cls;
-
- rc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Shutting down testbed due to timeout while setup.\n"));
- shutdown_now (rc);
+ 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, 0, NULL, 0, 0);
+ rc->test_master (rc->test_master_cls, rc, 0, NULL, 0, 0);
rc->test_master = NULL;
}
GNUNET_TESTBED_TestMaster test_master,
void *test_master_cls)
{
- struct RunContext *rc;
+ struct GNUNET_TESTBED_RunHandle *rc;
char *topology;
- struct CompatibilityCheckContext *hc;
+ struct CompatibilityCheckContext *hc;
struct GNUNET_TIME_Relative timeout;
- unsigned long long random_links;
+ unsigned long long number;
unsigned int hid;
unsigned int nhost;
GNUNET_assert (num_peers > 0);
- rc = GNUNET_malloc (sizeof (struct RunContext));
+ rc = GNUNET_new (struct GNUNET_TESTBED_RunHandle);
rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
-#if ENABLE_LL
+#if ENABLE_SUPERMUC
rc->num_hosts = GNUNET_TESTBED_hosts_load_from_loadleveler (rc->cfg,
&rc->hosts);
if (0 == rc->num_hosts)
rc->state = RC_INIT;
rc->topology = GNUNET_TESTBED_TOPOLOGY_NONE;
if (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
+ GNUNET_CONFIGURATION_get_value_string (rc->cfg, TESTBED_CONFIG_SECTION,
"OVERLAY_TOPOLOGY", &topology))
{
if (GNUNET_NO == GNUNET_TESTBED_topology_get_ (&rc->topology, topology))
{
- GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "testbed",
+ GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, TESTBED_CONFIG_SECTION,
"OVERLAY_TOPLOGY",
_
("Specified topology must be supported by testbed"));
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (rc->cfg, "testbed",
+ GNUNET_CONFIGURATION_get_value_number (rc->cfg, TESTBED_CONFIG_SECTION,
"OVERLAY_RANDOM_LINKS",
- &random_links))
+ &number))
{
/* OVERLAY option RANDOM & SMALL_WORLD_RING requires OVERLAY_RANDOM_LINKS
* option to be set to the number of random links to be established */
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "testbed",
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, TESTBED_CONFIG_SECTION,
"OVERLAY_RANDOM_LINKS");
goto error_cleanup;
}
- if (random_links > UINT32_MAX)
+ if (number > UINT32_MAX)
{
GNUNET_break (0); /* Too big number */
goto error_cleanup;
}
- rc->random_links = (unsigned int) random_links;
+ rc->random_links = (unsigned int) number;
break;
case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
+ GNUNET_CONFIGURATION_get_value_filename (rc->cfg, TESTBED_CONFIG_SECTION,
"OVERLAY_TOPOLOGY_FILE",
&rc->topo_file))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "testbed",
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, TESTBED_CONFIG_SECTION,
"OVERLAY_TOPOLOGY_FILE");
goto error_cleanup;
}
+ goto warn_ignore;
+ case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (rc->cfg, TESTBED_CONFIG_SECTION,
+ SCALE_FREE_CAP, &number))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, TESTBED_CONFIG_SECTION,
+ SCALE_FREE_CAP);
+ goto error_cleanup;
+ }
+ if (UINT16_MAX < number)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Maximum number of edges a peer can have in a scale free topology"
+ " cannot be more than %u. Given `%s = %llu'"), UINT16_MAX,
+ SCALE_FREE_CAP, number);
+ goto error_cleanup;
+ }
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (rc->cfg, TESTBED_CONFIG_SECTION,
+ SCALE_FREE_M, &number))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, TESTBED_CONFIG_SECTION,
+ SCALE_FREE_M);
+ goto error_cleanup;
+ }
+ if (UINT8_MAX < number)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("The number of edges that can established when adding a new node"
+ " to scale free topology cannot be more than %u. Given `%s = %llu'"),
+ UINT8_MAX, SCALE_FREE_M, number);
+ goto error_cleanup;
+ }
+ goto warn_ignore;
default:
+ warn_ignore:
/* Warn if OVERLAY_RANDOM_LINKS is present that it will be ignored */
if (GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (rc->cfg, "testbed",
+ GNUNET_CONFIGURATION_have_value (rc->cfg, TESTBED_CONFIG_SECTION,
"OVERLAY_RANDOM_LINKS"))
LOG (GNUNET_ERROR_TYPE_WARNING,
"Ignoring value of `OVERLAY_RANDOM_LINKS' in given configuration\n");
rc->cproc =
GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h,
&controller_status_cb, rc);
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, "TESTBED",
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, TESTBED_CONFIG_SECTION,
"SETUP_TIMEOUT",
&timeout))
{
}
rc->rcop_map = GNUNET_CONTAINER_multihashmap32_create (256);
rc->timeout_task =
- GNUNET_SCHEDULER_add_delayed (timeout, &timeout_task, rc);
+ GNUNET_SCHEDULER_add_delayed (timeout, &timeout_task, rc);
+ GNUNET_assert (NULL == rc->interrupt_task);
rc->interrupt_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &interrupt,
- rc);
+ GNUNET_SCHEDULER_add_shutdown (&interrupt,
+ rc);
return;
error_cleanup:
}
+/**
+ * Obtain handle to the master controller from a testbed run. The handle
+ * returned should not be disconnected.
+ *
+ * @param h the testbed run handle
+ * @return handle to the master controller
+ */
+struct GNUNET_TESTBED_Controller *
+GNUNET_TESTBED_run_get_controller_handle (struct GNUNET_TESTBED_RunHandle *h)
+{
+ return h->c;
+}
+
+
/* end of testbed_api_testbed.c */