/*
- This file is part of GNUnet
- (C) 2008--2012 Christian Grothoff (and other contributing authors)
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- 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.
- */
+ This file is part of GNUnet
+ (C) 2008--2012 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ 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.
+*/
/**
* @file testbed/testbed_api_testbed.c
#include "platform.h"
#include "gnunet_testbed_service.h"
+#include "testbed_api_peers.h"
/**
* Generic loggins shorthand
*/
-#define LOG(kind,...) \
+#define LOG(kind,...) \
GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)
/**
/**
* Context information for GNUNET_TESTBED_run()
*/
- struct GNUNET_TESTBED_RunHandle *rh;
+ struct RunContext *rc;
/**
* Closure
*/
- void *cls;
-
+ void *cls;
+
/**
* The next pointer for DLL
*/
struct DLLOperation *next;
-
+
/**
* The prev pointer for DLL
*/
};
+/**
+ * States of RunContext
+ */
+enum State
+{
+ /**
+ * Initial state
+ */
+ RC_INIT = 0,
+
+ /**
+ * Peers have been started
+ */
+ RC_PEERS_STARTED,
+
+ /**
+ * Peers are stopped
+ */
+ RC_PEERS_STOPPED,
+
+ /**
+ * Peers are destroyed
+ */
+ RC_PEERS_DESTROYED
+};
+
+
/**
* Testbed Run Handle
*/
-struct GNUNET_TESTBED_RunHandle
+struct RunContext
{
/**
* The controller handle
* The callback to use as controller callback
*/
GNUNET_TESTBED_ControllerCallback cc;
-
+
/**
* The pointer to the controller callback
*/
void *cc_cls;
-
+
/**
* Master task to call when testbed initialization is done
*/
GNUNET_SCHEDULER_Task master;
-
+
/**
* The closure for the master task
*/
* The head element of DLL operations
*/
struct DLLOperation *dll_op_head;
-
+
/**
* The tail element of DLL operations
*/
* Array of peers which we create
*/
struct GNUNET_TESTBED_Peer **peers;
-
+
/**
* The event mask for the controller
*/
uint64_t event_mask;
+ /**
+ * State of this context
+ */
+ enum State state;
+
/**
* Current peer count for an operation; Set this to 0 and increment for each
* successful operation on a peer
*/
unsigned int peer_count;
-
+
/**
* number of peers to start
*/
unsigned int num_peers;
- /**
- * Are we cleaning up?
- */
- int in_shutdown;
-
};
-
-
-/**
- * Configure and run a testbed using the given
- * master controller on 'num_hosts' starting
- * 'num_peers' using the given peer configuration.
- *
- * @param controller master controller for the testbed
- * (must not be destroyed until after the
- * testbed is destroyed).
- * @param num_hosts number of hosts in 'hosts', 0 to only
- * use 'localhost'
- * @param hosts list of hosts to use for the testbed
- * @param num_peers number of peers to start
- * @param peer_cfg peer configuration template to use
- * @param underlay_topology underlay topology to create
- * @param va topology-specific options
- * @return handle to the testbed
- */
-struct GNUNET_TESTBED_Testbed *
-GNUNET_TESTBED_create_va (struct GNUNET_TESTBED_Controller *controller,
- unsigned int num_hosts,
- struct GNUNET_TESTBED_Host **hosts,
- unsigned int num_peers,
- const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
- enum GNUNET_TESTBED_TopologyOption underlay_topology,
- va_list va)
-{
- GNUNET_break (0);
- return NULL;
-}
-
-
-/**
- * Configure and run a testbed using the given
- * master controller on 'num_hosts' starting
- * 'num_peers' using the given peer configuration.
- *
- * @param controller master controller for the testbed
- * (must not be destroyed until after the
- * testbed is destroyed).
- * @param num_hosts number of hosts in 'hosts', 0 to only
- * use 'localhost'
- * @param hosts list of hosts to use for the testbed
- * @param num_peers number of peers to start
- * @param peer_cfg peer configuration template to use
- * @param underlay_topology underlay topology to create
- * @param ... topology-specific options
- */
-struct GNUNET_TESTBED_Testbed *
-GNUNET_TESTBED_create (struct GNUNET_TESTBED_Controller *controller,
- unsigned int num_hosts,
- struct GNUNET_TESTBED_Host **hosts,
- unsigned int num_peers,
- const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
- enum GNUNET_TESTBED_TopologyOption underlay_topology,
- ...)
-{
- GNUNET_break (0);
- return NULL;
-}
-
-
-/**
- * Destroy a testbed. Stops all running peers and then
- * destroys all peers. Does NOT destroy the master controller.
- *
- * @param testbed testbed to destroy
- */
-void
-GNUNET_TESTBED_destroy (struct GNUNET_TESTBED_Testbed *testbed)
-{
- GNUNET_break (0);
-}
-
-
/**
* Task for starting peers
*
static void
start_peers_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct GNUNET_TESTBED_RunHandle *rh = cls;
- struct DLLOperation *dll_op;
+ struct RunContext *rc = cls;
+ struct DLLOperation *dll_op;
unsigned int peer;
-
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting Peers\n");
- for (peer = 0; peer < rh->num_peers; peer++)
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting Peers\n");
+ for (peer = 0; peer < rc->num_peers; peer++)
{
dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
- dll_op->op = GNUNET_TESTBED_peer_start (rh->peers[peer]);
- dll_op->cls = rh->peers[peer];
- GNUNET_CONTAINER_DLL_insert_tail (rh->dll_op_head, rh->dll_op_tail, dll_op);
+ dll_op->op = GNUNET_TESTBED_peer_start (rc->peers[peer], NULL, NULL);
+ dll_op->cls = rc->peers[peer];
+ GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail, dll_op);
}
- rh->peer_count = 0;
+ rc->peer_count = 0;
}
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
-static void
+static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
-{
+{
struct DLLOperation *dll_op = cls;
- struct GNUNET_TESTBED_RunHandle *rh;
-
- GNUNET_assert (NULL != dll_op);
- rh = dll_op->rh;
- GNUNET_assert (NULL != rh);
- GNUNET_CONTAINER_DLL_remove (rh->dll_op_head, rh->dll_op_tail, dll_op);
- GNUNET_TESTBED_operation_done (dll_op->op);
+ struct RunContext *rc;
+
+ GNUNET_assert (NULL != dll_op);
+ rc = dll_op->rc;
+ GNUNET_assert (NULL != rc);
+ GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
+ GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_free (dll_op);
if (NULL == peer)
{
/* FIXME: GNUNET_TESTBED_shutdown_run()? */
return;
}
- rh->peers[rh->peer_count] = peer;
- rh->peer_count++;
- if (rh->peer_count < rh->num_peers)
+ rc->peers[rc->peer_count] = peer;
+ rc->peer_count++;
+ if (rc->peer_count < rc->num_peers)
return;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Required peers created successfully\n");
- GNUNET_SCHEDULER_add_now (&start_peers_task, rh);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Required peers created successfully\n");
+ GNUNET_SCHEDULER_add_now (&start_peers_task, rc);
}
* @param tc the task context from scheduler
*/
static void
-shutdown_run_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct GNUNET_TESTBED_RunHandle *rh = cls;
- struct DLLOperation *dll_op;
-
- GNUNET_assert (NULL == rh->peers);
- if (NULL != rh->c)
- GNUNET_TESTBED_controller_disconnect (rh->c);
- if (NULL != rh->cproc)
- GNUNET_TESTBED_controller_stop (rh->cproc);
- if (NULL != rh->h)
- GNUNET_TESTBED_host_destroy (rh->h);
- if (NULL != rh->dll_op_head)
+ struct RunContext *rc = cls;
+ struct DLLOperation *dll_op;
+
+ GNUNET_assert (NULL == rc->peers);
+ GNUNET_assert (RC_PEERS_DESTROYED == rc->state);
+ 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);
+ if (NULL != rc->dll_op_head)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Some operations are still pending. Cancelling them\n"));
- while (NULL != (dll_op = rh->dll_op_head))
+ while (NULL != (dll_op = rc->dll_op_head))
{
GNUNET_TESTBED_operation_cancel (dll_op->op);
- GNUNET_CONTAINER_DLL_remove (rh->dll_op_head, rh->dll_op_tail, dll_op);
+ GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
GNUNET_free (dll_op);
}
}
- GNUNET_free (rh);
+ GNUNET_free (rc);
}
* @param cls closure
* @param event information about the event
*/
-static void
+static void
event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
- struct GNUNET_TESTBED_RunHandle *rh = cls;
+ struct RunContext *rc = cls;
struct DLLOperation *dll_op;
-
- if ((GNUNET_YES == rh->in_shutdown) &&
- (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type))
+ unsigned int peer_id;
+
+
+ if ((RC_INIT != rc->state) &&
+ ((GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type) ||
+ (GNUNET_TESTBED_ET_PEER_STOP == event->type)))
{
- for (dll_op = rh->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
+ for (dll_op = rc->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
{
- if (event->details.operation_finished.operation == dll_op->op)
+ if ((GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type) &&
+ (event->details.operation_finished.operation == dll_op->op))
+ break;
+ if ((GNUNET_TESTBED_ET_PEER_STOP == event->type) &&
+ (event->details.peer_stop.peer == dll_op->cls))
break;
}
if (NULL == dll_op)
goto call_cc;
- GNUNET_CONTAINER_DLL_remove (rh->dll_op_head, rh->dll_op_tail, dll_op);
+ GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_free (dll_op);
- rh->peer_count++;
- if (rh->peer_count < rh->num_peers)
+ rc->peer_count++;
+ if (rc->peer_count < rc->num_peers)
return;
- GNUNET_free (rh->peers);
- rh->peers = NULL;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully destroyed\n");
- GNUNET_SCHEDULER_add_now (&shutdown_run_task, rh);
- return;
+ switch (rc->state)
+ {
+ case RC_PEERS_STARTED:
+ rc->state = RC_PEERS_STOPPED;
+ rc->peer_count = 0;
+ for (peer_id = 0; peer_id < rc->num_peers; peer_id++)
+ {
+ dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
+ dll_op->op = GNUNET_TESTBED_peer_destroy (rc->peers[peer_id]);
+ GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
+ dll_op);
+ }
+ break;
+ case RC_PEERS_STOPPED:
+ rc->state = RC_PEERS_DESTROYED;
+ GNUNET_free (rc->peers);
+ rc->peers = NULL;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully destroyed\n");
+ GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
+ break;
+ default:
+ GNUNET_assert (0);
+ }
+ return;
}
- call_cc:
- rh->cc (rh->cc_cls, event);
+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;
- for (dll_op = rh->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
- if ((NULL != dll_op->cls) &&
+ for (dll_op = rc->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
+ if ((NULL != dll_op->cls) &&
(event->details.peer_start.peer == dll_op->cls))
break;
GNUNET_assert (NULL != dll_op);
- GNUNET_CONTAINER_DLL_remove (rh->dll_op_head, rh->dll_op_tail, dll_op);
+ GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_free (dll_op);
- rh->peer_count++;
- if (rh->peer_count < rh->num_peers)
+ rc->peer_count++;
+ if (rc->peer_count < rc->num_peers)
return;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Peers started successfully\n");
- GNUNET_SCHEDULER_add_continuation (rh->master, rh->master_cls,
- GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Peers started successfully\n");
+ rc->state = RC_PEERS_STARTED;
+ if (NULL != rc->master)
+ GNUNET_SCHEDULER_add_continuation (rc->master, rc->master_cls,
+ GNUNET_SCHEDULER_REASON_PREREQ_DONE);
}
* @param status GNUNET_OK if the startup is successfull; GNUNET_SYSERR if not,
* GNUNET_TESTBED_controller_stop() shouldn't be called in this case
*/
-static void
+static void
controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
- int status)
-{
- struct GNUNET_TESTBED_RunHandle *rh = cls;
+ int status)
+{
+ struct RunContext *rc = cls;
struct DLLOperation *dll_op;
+ uint64_t event_mask;
unsigned int peer;
-
+
if (status != GNUNET_OK)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed startup failed\n");
return;
}
- rh->c = GNUNET_TESTBED_controller_connect (cfg, rh->h, rh->event_mask,
- &event_cb, rh);
- rh->peers = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *)
- * rh->num_peers);
- GNUNET_assert (NULL != rh->c);
- rh->peer_count = 0;
- for (peer = 0; peer < rh->num_peers; peer++)
+ event_mask = rc->event_mask;
+ event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
+ event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
+ rc->c =
+ GNUNET_TESTBED_controller_connect (cfg, rc->h, event_mask, &event_cb, rc);
+ 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++)
{
dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
- dll_op->rh = rh;
- dll_op->op = GNUNET_TESTBED_peer_create (rh->c, rh->h, cfg, peer_create_cb,
- dll_op);
- GNUNET_CONTAINER_DLL_insert_tail (rh->dll_op_head, rh->dll_op_tail, dll_op);
+ dll_op->rc = rc;
+ dll_op->op =
+ GNUNET_TESTBED_peer_create (rc->c, rc->h, cfg, peer_create_cb, dll_op);
+ GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail, dll_op);
}
}
+/**
+ * Stops the testbed run and releases any used resources
+ *
+ * @param cls the tesbed run handle
+ * @param tc the task context from scheduler
+ */
+void
+shutdown_run_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct RunContext *rc = cls;
+ struct DLLOperation *dll_op;
+ unsigned int peer;
+
+ if (NULL != rc->c)
+ {
+ if (NULL != rc->peers)
+ {
+ rc->peer_count = 0;
+ /* Check if some peers are stopped */
+ for (peer = 0; peer < rc->num_peers; peer++)
+ {
+ if (PS_STOPPED != rc->peers[peer]->state)
+ break;
+ }
+ if (peer == rc->num_peers)
+ {
+ /* All peers are stopped */
+ rc->state = RC_PEERS_STOPPED;
+ for (peer = 0; peer < rc->num_peers; peer++)
+ {
+ dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
+ dll_op->op = GNUNET_TESTBED_peer_destroy (rc->peers[peer]);
+ GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
+ dll_op);
+ }
+ return;
+ }
+ /* Some peers are stopped */
+ for (peer = 0; peer < rc->num_peers; peer++)
+ {
+ if (PS_STARTED != rc->peers[peer]->state)
+ {
+ rc->peer_count++;
+ continue;
+ }
+ dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
+ dll_op->op = GNUNET_TESTBED_peer_stop (rc->peers[peer], NULL, NULL);
+ dll_op->cls = rc->peers[peer];
+ GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
+ dll_op);
+ }
+ if (rc->peer_count != rc->num_peers)
+ return;
+ }
+ }
+ rc->state = RC_PEERS_DESTROYED; /* No peers are present so we consider the
+ * state where all peers are destroyed */
+ GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
+}
+
+
/**
* Convenience method for running a testbed with
* a single call. Underlay and overlay topology
* or-ed values of "1LL" shifted by the
* respective 'enum GNUNET_TESTBED_EventType'
* (i.e. "(1LL << GNUNET_TESTBED_ET_CONNECT) || ...")
- * @param cc controller callback to invoke on events
+ * @param cc controller callback to invoke on events; This callback is called
+ * for all peer start events even if GNUNET_TESTBED_ET_PEER_START isn't
+ * set in the event_mask as this is the only way get access to the
+ * handle of each peer
* @param cc_cls closure for cc
* @param master task to run once the testbed is ready
- * @return the handle for this testbed run
+ * @param master_cls
*/
-struct GNUNET_TESTBED_RunHandle *
+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_SCHEDULER_Task master,
- void *master_cls)
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ unsigned int num_peers, uint64_t event_mask,
+ GNUNET_TESTBED_ControllerCallback cc, void *cc_cls,
+ GNUNET_SCHEDULER_Task master, void *master_cls)
{
- struct GNUNET_TESTBED_RunHandle *rh;
+ struct RunContext *rc;
- event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
- rh = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_RunHandle));
GNUNET_break (NULL == host_filename); /* Currently we do not support host
- files */
+ * files */
+ GNUNET_assert (NULL != cc);
+ GNUNET_assert (num_peers > 0);
host_filename = NULL;
- rh->h = GNUNET_TESTBED_host_create (NULL, NULL, 0);
- GNUNET_assert (NULL != rh->h);
- rh->cproc = GNUNET_TESTBED_controller_start ("127.0.0.1", rh->h, cfg,
- &controller_status_cb, rh);
- GNUNET_assert (NULL != rh->cproc);
- rh->num_peers = num_peers;
- rh->event_mask = event_mask;
- rh->cc = cc;
- rh->cc_cls = cc_cls;
- rh->master = master;
- rh->master_cls = master_cls;
- rh->in_shutdown = GNUNET_NO;
- return rh;
+ rc = GNUNET_malloc (sizeof (struct RunContext));
+ rc->h = GNUNET_TESTBED_host_create (NULL, NULL, 0);
+ GNUNET_assert (NULL != rc->h);
+ rc->cproc =
+ GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h, cfg,
+ &controller_status_cb, rc);
+ GNUNET_assert (NULL != rc->cproc);
+ rc->num_peers = num_peers;
+ rc->event_mask = event_mask;
+ rc->event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
+ rc->cc = cc;
+ rc->cc_cls = cc_cls;
+ rc->master = master;
+ rc->master_cls = master_cls;
+ rc->state = RC_INIT;
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+ &shutdown_run_task, rc);
}
/**
- * Stops the testbed run and releases any used resources
+ * Configure and run a testbed using the given
+ * master controller on 'num_hosts' starting
+ * 'num_peers' using the given peer configuration.
+ *
+ * @param controller master controller for the testbed
+ * (must not be destroyed until after the
+ * testbed is destroyed).
+ * @param num_hosts number of hosts in 'hosts', 0 to only
+ * use 'localhost'
+ * @param hosts list of hosts to use for the testbed
+ * @param num_peers number of peers to start
+ * @param peer_cfg peer configuration template to use
+ * @param underlay_topology underlay topology to create
+ * @param va topology-specific options
+ * @return handle to the testbed
+ */
+struct GNUNET_TESTBED_Testbed *
+GNUNET_TESTBED_create_va (struct GNUNET_TESTBED_Controller *controller,
+ unsigned int num_hosts,
+ struct GNUNET_TESTBED_Host **hosts,
+ unsigned int num_peers,
+ const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
+ enum GNUNET_TESTBED_TopologyOption underlay_topology,
+ va_list va)
+{
+ GNUNET_break (0);
+ return NULL;
+}
+
+
+/**
+ * Configure and run a testbed using the given
+ * master controller on 'num_hosts' starting
+ * 'num_peers' using the given peer configuration.
*
- * @param rh the tesbed run handle
+ * @param controller master controller for the testbed
+ * (must not be destroyed until after the
+ * testbed is destroyed).
+ * @param num_hosts number of hosts in 'hosts', 0 to only
+ * use 'localhost'
+ * @param hosts list of hosts to use for the testbed
+ * @param num_peers number of peers to start
+ * @param peer_cfg peer configuration template to use
+ * @param underlay_topology underlay topology to create
+ * @param ... topology-specific options
+ */
+struct GNUNET_TESTBED_Testbed *
+GNUNET_TESTBED_create (struct GNUNET_TESTBED_Controller *controller,
+ unsigned int num_hosts,
+ struct GNUNET_TESTBED_Host **hosts,
+ unsigned int num_peers,
+ const struct GNUNET_CONFIGURATION_Handle *peer_cfg,
+ enum GNUNET_TESTBED_TopologyOption underlay_topology,
+ ...)
+{
+ GNUNET_break (0);
+ return NULL;
+}
+
+
+/**
+ * Destroy a testbed. Stops all running peers and then
+ * destroys all peers. Does NOT destroy the master controller.
+ *
+ * @param testbed testbed to destroy
*/
void
-GNUNET_TESTBED_shutdown_run (struct GNUNET_TESTBED_RunHandle *rh)
-{
- struct DLLOperation *dll_op;
- unsigned int peer;
-
- rh->in_shutdown = GNUNET_YES;
- if (NULL != rh->c)
- {
- if (NULL != rh->peers)
- {
- rh->peer_count = 0;
- for (peer = 0; peer < rh->num_peers; peer++)
- {
- dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
- dll_op->op = GNUNET_TESTBED_peer_destroy (rh->peers[peer]);
- GNUNET_CONTAINER_DLL_insert_tail (rh->dll_op_head, rh->dll_op_tail,
- dll_op);
- }
- return;
- }
- }
- GNUNET_SCHEDULER_add_now (&shutdown_run_task, rh);
+GNUNET_TESTBED_destroy (struct GNUNET_TESTBED_Testbed *testbed)
+{
+ GNUNET_break (0);
}
+
/* end of testbed_api_testbed.c */
projects / oweals / gnunet.git / blobdiff