/*
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.
*/
/**
/**
* Host registration task
*/
- GNUNET_SCHEDULER_TaskIdentifier register_hosts_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
/**
* Assuming all peers have been destroyed cleanup run handle
*
- * @param cls the run handle
+ * @param rc the run context
*/
static void
-cleanup (void *cls)
+cleanup (struct GNUNET_TESTBED_RunHandle *rc)
{
- struct GNUNET_TESTBED_RunHandle *rc = cls;
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);
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;
+ rc->timeout_task = NULL;
}
if (NULL != rc->reg_handle)
{
cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc)
{
GNUNET_SCHEDULER_cancel (rc->interrupt_task);
- rc->interrupt_task = GNUNET_SCHEDULER_NO_TASK;
+ rc->interrupt_task = NULL;
}
if (NULL == rc->peers)
goto cleanup_;
rc->shutdown = GNUNET_YES;
- rcop = GNUNET_malloc (sizeof (struct RunContextOperation));
+ rcop = GNUNET_new (struct RunContextOperation);
rcop->rc = rc;
rcop->op = GNUNET_TESTBED_shutdown_peers (rc->c, rcop, NULL, NULL);
GNUNET_assert (NULL != rcop->op);
* 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 GNUNET_TESTBED_RunHandle *rc = cls;
struct GNUNET_TESTBED_Controller *c = rc->c;
unsigned int size;
/* reschedule */
- rc->interrupt_task = GNUNET_SCHEDULER_add_delayed
- (GNUNET_TIME_UNIT_FOREVER_REL, &interrupt, rc);
+ rc->interrupt_task = GNUNET_SCHEDULER_add_shutdown (&interrupt, rc);
rc_cleanup_operations (rc);
- if ( (GNUNET_NO == rc->shutdown)
- && (NULL != c)
- && (0 != (size = GNUNET_CONTAINER_multihashmap32_size (c->opc_map))))
+ 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);
+ 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;
* 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 GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop;
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);
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, rc->num_peers, rc->peers,
rc->links_succeeded, rc->links_failed);
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;
rcop->op =
GNUNET_TESTBED_peer_create (rc->c,
* 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);
/**
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 GNUNET_TESTBED_RunHandle *rc = cls;
struct RunContextOperation *rcop;
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 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[slave],
* 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 GNUNET_TESTBED_RunHandle *rc = cls;
- rc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Shutting down testbed due to timeout while setup.\n"));
+ 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);
unsigned int nhost;
GNUNET_assert (num_peers > 0);
- rc = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_RunHandle));
+ 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)
break;
case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (rc->cfg, TESTBED_CONFIG_SECTION,
+ GNUNET_CONFIGURATION_get_value_filename (rc->cfg, TESTBED_CONFIG_SECTION,
"OVERLAY_TOPOLOGY_FILE",
&rc->topo_file))
{
}
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: