/**
* Functions of this signature are called when a peer has been successfully
* created
*
* @param cls the closure from GNUNET_TESTBED_peer_create()
* @param peer the handle for the created peer; NULL on any error during
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
GNUNET_assert (NULL != peer);
GNUNET_assert (NULL == emsg);
switch (result)
{
case MASTER_STARTED:
result = MASTER_PEER_CREATE_SUCCESS;
master_peer = peer;
GNUNET_TESTBED_operation_done (op);
op = GNUNET_TESTBED_peer_start (NULL, master_peer, NULL, NULL);
break;
case SLAVE1_LINK_SUCCESS:
result = SLAVE1_PEER_CREATE_SUCCESS;
slave1_peer = peer;
GNUNET_TESTBED_operation_done (op);
op = GNUNET_TESTBED_peer_start (NULL, slave1_peer, NULL, NULL);
break;
case SLAVE2_LINK_SUCCESS:
result = SLAVE2_PEER_CREATE_SUCCESS;
slave2_peer = peer;
GNUNET_TESTBED_operation_done (op);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 1), &delay_task,
NULL);
break;
default:
GNUNET_assert (0);
}
GNUNET_assert (NULL != op);
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct DLLOperation *dll_op;
unsigned int nhost;
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
GNUNET_SCHEDULER_cancel (register_hosts_task);
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != topology_op)
GNUNET_TESTBED_operation_done (topology_op);
for (nhost = 0; nhost < num_hosts; nhost++)
if (NULL != hosts[nhost])
GNUNET_TESTBED_host_destroy (hosts[nhost]);
GNUNET_free_non_null (hosts);
while (NULL != (dll_op = dll_op_head))
{
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
}
if (NULL != mc)
GNUNET_TESTBED_controller_disconnect (mc);
if (NULL != mc_proc)
GNUNET_TESTBED_controller_stop (mc_proc);
if (NULL != cfg)
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
}
/**
* Shutdown nicely
*/
static void
do_close (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
switch (test_step)
{
case TEST_STEP_1_HOP:
if (NULL != peer_data[0].socket)
GNUNET_STREAM_close (peer_data[0].socket);
if (NULL != peer_data[1].socket)
GNUNET_STREAM_close (peer_data[1].socket);
if (NULL != peer2_listen_socket)
GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */
break;
case TEST_STEP_2_HOP:
if (NULL != peer_data[1].socket)
GNUNET_STREAM_close (peer_data[1].socket);
if (NULL != peer_data[0].op)
GNUNET_TESTBED_operation_done (peer_data[0].op);
if (NULL != peer_data[1].op)
GNUNET_TESTBED_operation_done (peer_data[1].op);
break;
case TEST_STEP_3_HOP:
GNUNET_break (0);
}
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_SCHEDULER_NO_TASK != write_task)
GNUNET_SCHEDULER_cancel (write_task);
GNUNET_SCHEDULER_shutdown (); /* Shutdown this testcase */
if (NULL != meter)
{
free_meter (meter);
meter = NULL;
}
}
/**
* Functions of this signature are called when a peer has been successfully
* started or stopped.
*
* @param cls the closure from GNUNET_TESTBED_peer_start/stop()
* @param emsg NULL on success; otherwise an error description
*/
static void
peer_churn_cb (void *cls, const char *emsg)
{
struct DLLOperation *dll_op = cls;
struct GNUNET_TESTBED_Operation *op;
static unsigned int started_peers;
op = dll_op->op;
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
if (NULL != emsg)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("An operation has failed while starting peers\n"));
GNUNET_TESTBED_operation_done (op);
GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
GNUNET_TESTBED_operation_done (op);
if (++started_peers == num_peers)
{
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
printf ("%u peers started successfully in %.2f seconds\n",
num_peers, ((double) prof_time.rel_value) / 1000.00);
fflush (stdout);
result = GNUNET_OK;
if ((0 == num_links) && (topology == GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI))
{
fprintf (stdout, "Testbed running, waiting for keystroke to shut down\n");
(void) getc (stdin);
shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
return;
}
state = STATE_PEERS_LINKING;
/* Do overlay connect */
prof_start_time = GNUNET_TIME_absolute_get ();
switch (topology)
{
case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
topology_op =
GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peers, NULL,
topology,
num_links,
GNUNET_TESTBED_TOPOLOGY_DISABLE_AUTO_RETRY,
GNUNET_TESTBED_TOPOLOGY_OPTION_END);
break;
case GNUNET_TESTBED_TOPOLOGY_CLIQUE:
topology_op =
GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peers, NULL,
topology,
GNUNET_TESTBED_TOPOLOGY_DISABLE_AUTO_RETRY,
GNUNET_TESTBED_TOPOLOGY_OPTION_END);
num_links = num_peers * (num_peers - 1);
break;
default:
GNUNET_assert (0);
}
}
}
/**
* Check if the get_handle is being used, if so stop the request. Either
* way, schedule the end_badly_cont function which actually shuts down the
* test.
*/
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
int c;
if (GNUNET_SCHEDULER_NO_TASK != wait_task)
{
GNUNET_SCHEDULER_cancel (wait_task);
wait_task = GNUNET_SCHEDULER_NO_TASK;
}
for (c = 0; c < 3; c++)
{
if (NULL != nh[c])
{
GNUNET_NAMESTORE_disconnect(nh[c]);
nh[c] = NULL;
}
if (NULL != get_cfg_ops[c])
{
GNUNET_TESTBED_operation_done(get_cfg_ops[c]);
get_cfg_ops[c] = NULL;
}
if (NULL != cfg_handles[c])
{
GNUNET_CONFIGURATION_destroy (cfg_handles[c]);
cfg_handles[c] = NULL;
}
}
if (NULL != topology_op)
{
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
}
if (NULL != lookup_handle)
{
GNUNET_GNS_cancel_lookup_request (lookup_handle);
lookup_handle = NULL;
}
if (NULL != gh)
{
GNUNET_GNS_disconnect(gh);
gh = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Test failed \n");
GNUNET_SCHEDULER_shutdown ();
ok = 1;
}
static void
destroy (void *cls)
{
struct GNUNET_CONSENSUS_Handle *consensus = cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"destroying consensus\n");
GNUNET_CONSENSUS_destroy (consensus);
peers_done++;
if (peers_done == num_peers)
{
unsigned int i;
for (i = 0; i < num_peers; i++)
GNUNET_TESTBED_operation_done (testbed_operations[i]);
for (i = 0; i < num_peers; i++)
printf ("P%u got %u of %u elements\n",
i,
results_for_peer[i],
num_values);
if (NULL != statistics_filename)
statistics_file = fopen (statistics_filename, "w");
GNUNET_TESTBED_get_statistics (num_peers, peers, NULL, NULL,
statistics_cb,
statistics_done_cb,
NULL);
}
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (NULL != hc_handle)
GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
GNUNET_assert (NULL == delayed_connect_task);
if (NULL != common_operation)
GNUNET_TESTBED_operation_done (common_operation);
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != controller1)
GNUNET_TESTBED_controller_disconnect (controller1);
GNUNET_CONFIGURATION_destroy (cfg);
if (NULL != cfg2)
GNUNET_CONFIGURATION_destroy (cfg2);
if (NULL != cp1)
GNUNET_TESTBED_controller_stop (cp1);
if (NULL != host)
GNUNET_TESTBED_host_destroy (host);
if (NULL != neighbour1)
GNUNET_TESTBED_host_destroy (neighbour1);
if (NULL != neighbour2)
GNUNET_TESTBED_host_destroy (neighbour2);
}
static void
do_publish1 (void *cls,
struct GNUNET_TESTBED_Operation *op,
const char *emsg)
{
unsigned int *coco = cls;
int do_index;
int anonymity;
GNUNET_TESTBED_operation_done (op);
if (NULL != emsg)
{
cleanup ();
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
ok = 1;
return;
}
if (0 != (--(*coco)))
return; /* more connections to be created */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
(unsigned long long) FILESIZE);
if (NULL != strstr (progname, "index"))
do_index = GNUNET_YES;
else
do_index = GNUNET_NO;
if (NULL != strstr (progname, "dht"))
anonymity = 0;
else
anonymity = 1;
GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
do_index, FILESIZE, SEED1, VERBOSE, &do_publish2,
NULL);
}
/**
* Cleans up the queue used for forwarding link controllers requests
*/
void
GST_free_lcfq ()
{
struct LCFContextQueue *lcfq;
struct LCFContext *lcf;
if (NULL != lcfq_head)
{
if (NULL != lcf_proc_task_id)
{
GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
lcf_proc_task_id = NULL;
}
}
GNUNET_assert (NULL == lcf_proc_task_id);
for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head)
{
lcf = lcfq->lcf;
GNUNET_SERVER_client_drop (lcf->client);
if (NULL != lcf->op)
GNUNET_TESTBED_operation_done (lcf->op);
if (NULL != lcf->timeout_task)
GNUNET_SCHEDULER_cancel (lcf->timeout_task);
GNUNET_free (lcf);
GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
GNUNET_free (lcfq);
}
}
/**
* Called when a decryption has succeeded.
*
* @param cls Plaintext
* @param plaintext Plaintext
*/
static void decrypt_cb (void *cls,
const struct GNUNET_SECRETSHARING_Plaintext *plaintext)
{
struct GNUNET_SECRETSHARING_DecryptionHandle **dhp = cls;
unsigned int n = dhp - decrypt_handles;
num_decrypted++;
*dhp = NULL;
// we should still be connected if this is called
GNUNET_assert (NULL != connect_ops[n]);
GNUNET_TESTBED_operation_done (connect_ops[n]);
if (NULL == plaintext)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decrypt failed for peer %u\n", n);
return;
}
else if (0 == memcmp (&reference_plaintext, plaintext, sizeof (struct GNUNET_SECRETSHARING_Plaintext)))
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "decrypt got correct result for peer %u\n", n);
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decrypt got wrong result for peer %u\n", n);
if (num_decrypted == num_peers)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "every peer decrypted\n");
GNUNET_SCHEDULER_shutdown ();
}
*dhp = NULL;
}
/**
* Controller event callback
*
* @param cls NULL
* @param event the controller event
*/
static void
controller_event_cb (void *cls,
const struct GNUNET_TESTBED_EventInformation *event)
{
switch (event->type)
{
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
if (NULL != event->details.operation_finished.emsg)
{
FPRINTF (stderr, "Error while expecting an operation to succeed:%s \n",
event->details.operation_finished.emsg);
GNUNET_assert (0);
}
break;
case GNUNET_TESTBED_ET_CONNECT:
GNUNET_TESTBED_operation_done (common_op);
/* Get the peer identity and configuration of peers */
common_op =
GNUNET_TESTBED_peer_get_information (peer_data[0].peer,
GNUNET_TESTBED_PIT_IDENTITY,
&peerinfo_cb, &peer_data[0]);
break;
default:
GNUNET_assert (0);
}
}
void testbed_controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
static int connections = 0;
switch (event->type)
{
case GNUNET_TESTBED_ET_OPERATION_FINISHED:
/* This part will still be called when
GNUNET_TESTBED_peer_get_information() succeeds. However, the code is
now more relevant in operation completion callback */
break;
case GNUNET_TESTBED_ET_CONNECT:
connections ++;
if (connections == 3)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers connected\n");
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
all_connected ();
}
break;
default:
/* whatever ... */
break;
}
}
/**
* Callback for event from slave controllers
*
* @param cls NULL
* @param event information about the event
*/
static void
slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
struct LCFContext *lcf;
/* We currently only get here when working on LCFContexts */
GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
lcf = event->op_cls;
GNUNET_assert (lcf->op == event->op);
GNUNET_TESTBED_operation_done (lcf->op);
lcf->op = NULL;
GNUNET_assert (FINISHED == lcf->state);
GNUNET_assert (NULL != lcf->timeout_task);
GNUNET_SCHEDULER_cancel (lcf->timeout_task);
if (NULL == event->details.operation_finished.emsg)
send_controller_link_response (lcf->client, lcf->operation_id,
GNUNET_TESTBED_host_get_cfg_
(GST_host_list[lcf->delegated_host_id]),
NULL);
else
send_controller_link_response (lcf->client, lcf->operation_id,
NULL,
event->details.operation_finished.emsg);
GNUNET_assert (NULL == lcf_proc_task_id);
lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
return;
}
/**
* Callback to be called when the requested peer information is available
*
* @param cb_cls the closure from GNUNET_TETSBED_peer_get_information()
* @param op the operation this callback corresponds to
* @param pinfo the result; will be NULL if the operation has failed
* @param emsg error message if the operation has failed; will be NULL if the
* operation is successfull
*/
static void
peer_info_cb (void *cb_cls,
struct GNUNET_TESTBED_Operation *op,
const struct GNUNET_TESTBED_PeerInformation *pinfo,
const char *emsg)
{
struct GNUNET_PeerIdentity *p;
int i;
GNUNET_assert (NULL == emsg);
p = (struct GNUNET_PeerIdentity *) cb_cls;
if (pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY)
{
*p = *pinfo->result.id;
num_retrieved_peer_ids++;
if (num_retrieved_peer_ids == num_peers)
for (i = 0; i < num_peers; i++)
testbed_operations[i] =
GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing", session_connect_complete, NULL,
session_connect_adapter, session_disconnect_adapter, &session_handles[i]);
}
else
{
GNUNET_assert (0);
}
GNUNET_TESTBED_operation_done (op);
}
static void
do_download (void *cls,
const char *emsg)
{
struct DownloadContext *dc = cls;
struct GNUNET_FS_Uri *uri = dc->uri;
GNUNET_TESTBED_operation_done (op);
op = NULL;
if (NULL != dc->fn)
{
GNUNET_DISK_directory_remove (dc->fn);
GNUNET_free (dc->fn);
}
GNUNET_free (dc);
if (NULL != emsg)
{
GNUNET_SCHEDULER_shutdown ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to stop source daemon: %s\n",
emsg);
GNUNET_FS_uri_destroy (uri);
ok = 1;
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
(unsigned long long) FILESIZE);
start_time = GNUNET_TIME_absolute_get ();
GNUNET_FS_TEST_download (daemons[0], TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop,
NULL);
GNUNET_FS_uri_destroy (uri);
}
/**
* Callback to be called when the requested peer information is available
*
* @param cb_cls the closure from GNUNET_TETSBED_peer_get_information()
* @param op the operation this callback corresponds to
* @param pinfo the result; will be NULL if the operation has failed
* @param emsg error message if the operation has failed; will be NULL if the
* operation is successfull
*/
static void
peerinfo_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
const struct GNUNET_TESTBED_PeerInformation *pinfo,
const char *emsg)
{
struct PeerData *pdata = cb_cls;
GNUNET_assert (NULL == emsg);
GNUNET_assert (common_op == op);
GNUNET_assert (NULL != pdata);
memcpy (&pdata->id, pinfo->result.id, sizeof (struct GNUNET_PeerIdentity));
GNUNET_TESTBED_operation_done (op);
if (pdata == &peer_data[0])
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 1 id: %s\n",
GNUNET_i2s (&pdata->id));
common_op = GNUNET_TESTBED_peer_get_information (peer_data[1].peer,
GNUNET_TESTBED_PIT_IDENTITY,
&peerinfo_cb, &peer_data[1]);
}
else if (pdata == &peer_data[1])
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n",
GNUNET_i2s (&pdata->id));
if (TEST_STEP_2_HOP == test_step)
peer_data[1].op =
GNUNET_TESTBED_service_connect (&peer_data[1], peer_data[1].peer,
"stream", NULL, NULL, stream_ca,
stream_da, &peer_data[1]);
else
GNUNET_break (0); /* FIXME: 3 hop test case here... */
}
}
/**
* Function called when get_statistics operation is cancelled or marked as done
*
* @param cls the GetStatsContext
*/
static void
oprelease_get_stats (void *cls)
{
struct GetStatsContext *sc = cls;
unsigned int peer;
LOG_DEBUG ("Cleaning up get_statistics operation\n");
if (NULL != sc->call_completion_task_id)
GNUNET_SCHEDULER_cancel (sc->call_completion_task_id);
if (NULL != sc->ops)
{
for (peer = 0; peer < sc->num_peers; peer++)
{
if (NULL != sc->ops[peer])
{
GNUNET_TESTBED_operation_done (sc->ops[peer]);
sc->ops[peer] = NULL;
}
}
GNUNET_free (sc->ops);
}
GNUNET_free_non_null (sc->subsystem);
GNUNET_free_non_null (sc->name);
GNUNET_free (sc);
if (GNUNET_YES ==
GNUNET_TESTBED_operation_queue_destroy_empty_ (no_wait_queue))
no_wait_queue = NULL;
}
static void
topology_completed (void *cls,
unsigned int nsuccess,
unsigned int nfailures)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Links successful %u / %u failed\n",
nsuccess,
nfailures);
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
if (nfailures > 0)
{
fprintf (stderr,
"Error: links successful %u but %u failed\n",
nsuccess,
nfailures);
ok = 1;
}
else
ok = 0;
GNUNET_SCHEDULER_shutdown ();
}
/**
* Functions of this signature are called when a peer has been successfully
* created
*
* @param cls the closure from GNUNET_TESTBED_peer_create()
* @param peer the handle for the created peer; NULL on any error during
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
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);
}
/**
* Cleans up the queue used for forwarding link controllers requests
*/
void
GST_free_lcf ()
{
struct LCFContext *lcf;
if (NULL != lcf_head)
{
if (NULL != lcf_proc_task_id)
{
GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
lcf_proc_task_id = NULL;
}
}
GNUNET_assert (NULL == lcf_proc_task_id);
for (lcf = lcf_head; NULL != lcf; lcf = lcf_head)
{
if (NULL != lcf->op)
GNUNET_TESTBED_operation_done (lcf->op);
if (NULL != lcf->timeout_task)
GNUNET_SCHEDULER_cancel (lcf->timeout_task);
GNUNET_CONTAINER_DLL_remove (lcf_head,
lcf_tail,
lcf);
GNUNET_free (lcf);
}
}
/**
* Functions of this signature are called when a peer has been successfully
* created
*
* @param cls NULL
* @param peer the handle for the created peer; NULL on any error during
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
switch (result)
{
case CONTROLLER1_UP:
if ((NULL == peer1.operation) || (NULL == peer) || (NULL != peer1.peer))
{
GNUNET_break (0);
abort_test ();
return;
}
peer1.peer = peer;
GNUNET_TESTBED_operation_done (peer1.operation);
result = PEER1_CREATED;
peer1.operation = GNUNET_TESTBED_peer_start (NULL, peer, NULL, NULL);
break;
case CONTROLLER2_UP:
if ((NULL == peer2.operation) || (NULL == peer) || (NULL != peer2.peer))
{
GNUNET_break (0);
abort_test ();
return;
}
peer2.peer = peer;
GNUNET_TESTBED_operation_done (peer2.operation);
result = PEER2_CREATED;
peer2.operation = GNUNET_TESTBED_peer_start (NULL, peer, NULL, NULL);
break;
case CONTROLLER3_UP:
if ((NULL == peer3.operation) || (NULL == peer) || (NULL != peer3.peer))
{
GNUNET_break (0);
abort_test ();
return;
}
peer3.peer = peer;
GNUNET_TESTBED_operation_done (peer3.operation);
result = PEER3_CREATED;
peer3.operation = GNUNET_TESTBED_peer_start (NULL, peer, NULL, NULL);
break;
default:
GNUNET_break (0);
abort_test ();
return;
}
}
static void
in_time_shutdown_task ()
{
if (NULL != basic_mqtt_op_publish)
{
GNUNET_TESTBED_operation_done (basic_mqtt_op_publish); /* calls the gmqtt_da_publish() for closing
down the connection */
basic_mqtt_op_publish = NULL;
}
if (NULL != basic_mqtt_op_subscribe)
{
GNUNET_TESTBED_operation_done (basic_mqtt_op_subscribe); /* calls the gmqtt_da_subscribe() for closing
down the connection */
basic_mqtt_op_subscribe = NULL;
}
GNUNET_SCHEDULER_cancel(shutdown_tid);
GNUNET_SCHEDULER_shutdown (); /* Also kills the testbed */
}
/**
* Task run on timeout to shut everything down.
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
unsigned int i;
for (i=0;i<NUM_PEERS;i++)
GNUNET_TESTBED_operation_done (nse_peers[i].op);
GNUNET_SCHEDULER_shutdown ();
}
/**
* Functions of this signature are called when a peer has been successfully
* created
*
* @param cls the closure from GNUNET_TESTBED_peer_create()
* @param peer the handle for the created peer; NULL on any error during
* creation
* @param emsg NULL if peer is not NULL; else MAY contain the error description
*/
static void
peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
{
struct DLLOperation *dll_op = cls;
struct GNUNET_TESTBED_Peer **peer_ptr;
static unsigned int created_peers;
unsigned int peer_cnt;
if (NULL != emsg)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Creating a peer failed. Error: %s\n"), emsg);
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
GNUNET_SCHEDULER_cancel (abort_task);
abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
return;
}
peer_ptr = dll_op->cls;
GNUNET_assert (NULL == *peer_ptr);
*peer_ptr = peer;
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
if (++created_peers == num_peers)
{
prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
printf ("%u peers created successfully in %.2f seconds\n",
num_peers, ((double) prof_time.rel_value) / 1000.00);
fflush (stdout);
/* Now peers are to be started */
state = STATE_PEERS_STARTING;
prof_start_time = GNUNET_TIME_absolute_get ();
for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
{
dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
dll_op->op = GNUNET_TESTBED_peer_start (dll_op, peers[peer_cnt],
&peer_churn_cb, dll_op);
GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
}
}
}
static void
shutdown_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != basic_mqtt_op_publish)
{
GNUNET_TESTBED_operation_done (basic_mqtt_op_publish); /* calls the gmqtt_da() for closing
down the connection */
basic_mqtt_op_publish = NULL;
}
if (NULL != basic_mqtt_op_subscribe)
{
GNUNET_TESTBED_operation_done (basic_mqtt_op_subscribe); /* calls the gmqtt_da() for closing
down the connection */
basic_mqtt_op_subscribe = NULL;
}
GNUNET_SCHEDULER_shutdown (); /* Also kills the testbed */
}
static void
do_shutdown (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
shutdown_task = NULL;
if (NULL != topology_op)
{
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
}
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
if (NULL != op)
{
GNUNET_TESTBED_operation_done (op);
op = NULL;
}
GNUNET_SCHEDULER_shutdown ();
}
/**
* Clean up the testbed.
*
* @param ctx handle for the testbed
*/
void
GNUNET_DHT_TEST_cleanup (struct GNUNET_DHT_TEST_Context *ctx)
{
unsigned int i;
for (i=0;i<ctx->num_peers;i++)
GNUNET_TESTBED_operation_done (ctx->ops[i]);
GNUNET_free (ctx->ops);
GNUNET_free (ctx->dhts);
GNUNET_free (ctx);
GNUNET_SCHEDULER_shutdown ();
}
/**
* Iterator for cleaning up elements from rcop_map
*
* @param cls the RunContext
* @param key the 32-bit key
* @param value the RunContextOperation element
* @return always GNUNET_YES
*/
static int
rcop_cleanup_iterator (void *cls, uint32_t key, void *value)
{
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;
}
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
shutdown_tid = GNUNET_SCHEDULER_NO_TASK;
if (NULL != basic_mqtt_op)
{
GNUNET_TESTBED_operation_done (basic_mqtt_op); /* calls the gmqtt_da() for closing
down the connection */
basic_mqtt_op = NULL;
}
GNUNET_SCHEDULER_shutdown (); /* Also kills the testbed */
}
