X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftestbed%2Ftest_testbed_api_controllerlink.c;h=471ab3a94c3ec0d1dd63b49d2f056e9ff4b00eb6;hb=27c12911f4f2aba2d90099270d70de846e83854f;hp=aa3a499283015f0794bb594fa9715157bef3a58f;hpb=a514e1b40566226d87ffdd95a51df47b7613fd95;p=oweals%2Fgnunet.git diff --git a/src/testbed/test_testbed_api_controllerlink.c b/src/testbed/test_testbed_api_controllerlink.c index aa3a49928..471ab3a94 100644 --- a/src/testbed/test_testbed_api_controllerlink.c +++ b/src/testbed/test_testbed_api_controllerlink.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet - (C) 2008--2012 Christian Grothoff (and other contributing authors) + (C) 2008--2013 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 @@ -28,18 +28,18 @@ /** * The controller architecture we try to achieve in this test case: * - * Master Controller + * Master Controller * // \\ * // \\ * Slave Controller 1---------Slave Controller 3 - * || - * || + * || + * || * Slave Controller 2 */ #include "platform.h" #include "gnunet_util_lib.h" -#include "gnunet_testing_lib-new.h" +#include "gnunet_testing_lib.h" #include "gnunet_testbed_service.h" /** @@ -64,7 +64,7 @@ enum Stage * Initial stage */ INIT, - + /** * Master controller has started */ @@ -96,24 +96,24 @@ enum Stage SLAVE1_LINK_SUCCESS, /** - * Link from slave 1 to slave 2 has been successfully created. + * Peer create on slave 1 successful */ - SLAVE2_LINK_SUCCESS, + SLAVE1_PEER_CREATE_SUCCESS, /** - * Peer create on slave 1 successful + * Peer startup on slave 1 successful */ - SLAVE1_PEER_CREATE_SUCCESS, + SLAVE1_PEER_START_SUCCESS, /** - * Peer create on slave 2 successful + * Link from slave 1 to slave 2 has been successfully created. */ - SLAVE2_PEER_CREATE_SUCCESS, + SLAVE2_LINK_SUCCESS, /** - * Peer startup on slave 1 successful + * Peer create on slave 2 successful */ - SLAVE1_PEER_START_SUCCESS, + SLAVE2_PEER_CREATE_SUCCESS, /** * Peer on slave 1 successfully stopped @@ -130,6 +130,31 @@ enum Stage */ MASTER_SLAVE2_PEERS_CONNECTED, + /** + * Slave 3 has successfully registered + */ + SLAVE3_REGISTERED, + + /** + * Slave 3 has successfully started + */ + SLAVE3_STARTED, + + /** + * Peer created on slave 3 + */ + SLAVE3_PEER_CREATE_SUCCESS, + + /** + * Peer started at slave 3 + */ + SLAVE3_PEER_START_SUCCESS, + + /** + * Try to connect peers on slave2 and slave3 + */ + SLAVE2_SLAVE3_PEERS_CONNECTED, + /** * Peer on slave 2 successfully stopped */ @@ -146,25 +171,29 @@ enum Stage SLAVE2_PEER_DESTROY_SUCCESS, /** - * Slave 3 has successfully registered + * The configuration of slave 3 is acquired */ - SLAVE3_REGISTERED, + SLAVE3_GET_CONFIG_SUCCESS, /** - * Slave 3 has successfully started + * Slave 1 has linked to slave 3; */ - SLAVE3_STARTED, + SLAVE3_LINK_SUCCESS, /** - * The configuration of slave 3 is acquired + * Master peer destoryed. Destory slave 3 peer */ - SLAVE3_GET_CONFIG_SUCCESS, + MASTER_PEER_DESTROY_SUCCESS, /** - * Slave 1 has linked to slave 3; + * Slave 3 peer destroyed. Mark test as success */ - SLAVE3_LINK_SUCCESS + SUCCESS, + /** + * Marks test as skipped + */ + SKIP }; /** @@ -232,11 +261,26 @@ static struct GNUNET_TESTBED_Peer *slave1_peer; */ static struct GNUNET_TESTBED_Peer *slave2_peer; +/** + * Handle to peer started at slave 2 + */ +static struct GNUNET_TESTBED_Peer *slave3_peer; + /** * Handle to a peer started at master controller */ static struct GNUNET_TESTBED_Peer *master_peer; +/** + * The handle for whether a host is habitable or not + */ +struct GNUNET_TESTBED_HostHabitableCheckHandle *hc_handle; + +/** + * The task handle for the delay task + */ +GNUNET_SCHEDULER_TaskIdentifier delay_task_id; + /** * Event mask */ @@ -247,6 +291,20 @@ uint64_t event_mask; */ static enum Stage result; +/** + * shortcut to exit during failure + */ +#define FAIL_TEST(cond) do { \ + if (!(cond)) { \ + GNUNET_break(0); \ + if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ + GNUNET_SCHEDULER_cancel (abort_task); \ + abort_task = GNUNET_SCHEDULER_NO_TASK; \ + GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \ + return; \ + } \ + } while (0) + /** * Shutdown nicely @@ -259,6 +317,17 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { if (GNUNET_SCHEDULER_NO_TASK != abort_task) GNUNET_SCHEDULER_cancel (abort_task); + if (GNUNET_SCHEDULER_NO_TASK != delay_task_id) + { + GNUNET_SCHEDULER_cancel (delay_task_id); + delay_task_id = GNUNET_SCHEDULER_NO_TASK; + } + if (NULL != hc_handle) + GNUNET_TESTBED_is_host_habitable_cancel (hc_handle); + if (NULL != mc) + GNUNET_TESTBED_controller_disconnect (mc); + if (NULL != cp) + GNUNET_TESTBED_controller_stop (cp); if (NULL != slave3) GNUNET_TESTBED_host_destroy (slave3); if (NULL != slave2) @@ -267,14 +336,10 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_TESTBED_host_destroy (slave); if (NULL != host) GNUNET_TESTBED_host_destroy (host); - if (NULL != mc) - GNUNET_TESTBED_controller_disconnect (mc); if (NULL != cfg) GNUNET_CONFIGURATION_destroy (cfg); if (NULL != cfg3) GNUNET_CONFIGURATION_destroy (cfg3); - if (NULL != cp) - GNUNET_TESTBED_controller_stop (cp); if (NULL != rh) GNUNET_TESTBED_cancel_registration (rh); } @@ -289,7 +354,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) static void do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); + LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n"); abort_task = GNUNET_SCHEDULER_NO_TASK; do_shutdown (cls, tc); } @@ -298,8 +363,8 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) /** * Calls abort now * - * @param - * @return + * @param + * @return */ static void do_abort_now (void *cls) @@ -310,6 +375,16 @@ do_abort_now (void *cls) } +/** + * Callback which will be called to after a host registration succeeded or failed + * + * @param cls the host which has been registered + * @param emsg the error message; NULL if host registration is successful + */ +static void +registration_cont (void *cls, const char *emsg); + + /** * Task for inserting delay between tests * @@ -319,18 +394,23 @@ do_abort_now (void *cls) static void delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { + delay_task_id = GNUNET_SCHEDULER_NO_TASK; switch (result) { - case SLAVE1_PEER_START_SUCCESS: - op = GNUNET_TESTBED_peer_stop (slave1_peer, NULL, NULL); - GNUNET_assert (NULL != op); + case SLAVE2_PEER_CREATE_SUCCESS: + op = GNUNET_TESTBED_peer_stop (NULL, slave1_peer, NULL, NULL); + FAIL_TEST (NULL != op); break; case MASTER_SLAVE2_PEERS_CONNECTED: - op = GNUNET_TESTBED_peer_stop (slave2_peer, NULL, NULL); - GNUNET_assert (NULL != op); + slave3 = GNUNET_TESTBED_host_create_with_id (3, "127.0.0.1", NULL, cfg, 0); + rh = GNUNET_TESTBED_register_host (mc, slave3, ®istration_cont, NULL); + break; + case SLAVE2_SLAVE3_PEERS_CONNECTED: + op = GNUNET_TESTBED_peer_stop (NULL, slave2_peer, NULL, NULL); + FAIL_TEST (NULL != op); break; default: - GNUNET_assert (0); + FAIL_TEST (0); } } @@ -347,32 +427,42 @@ delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) static void peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg) { - GNUNET_assert (NULL != peer); - GNUNET_assert (NULL == emsg); + FAIL_TEST (NULL != peer); + FAIL_TEST (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 (master_peer, NULL, NULL); + op = GNUNET_TESTBED_peer_start (NULL, master_peer, NULL, NULL); break; - case SLAVE2_LINK_SUCCESS: + case SLAVE1_LINK_SUCCESS: result = SLAVE1_PEER_CREATE_SUCCESS; slave1_peer = peer; GNUNET_TESTBED_operation_done (op); - op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL); + op = GNUNET_TESTBED_peer_start (NULL, slave1_peer, NULL, NULL); break; - case SLAVE1_PEER_CREATE_SUCCESS: + case SLAVE2_LINK_SUCCESS: result = SLAVE2_PEER_CREATE_SUCCESS; slave2_peer = peer; GNUNET_TESTBED_operation_done (op); - op = GNUNET_TESTBED_peer_start (slave1_peer, NULL, NULL); + delay_task_id = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), + &delay_task, + NULL); + break; + case SLAVE3_STARTED: + result = SLAVE3_PEER_CREATE_SUCCESS; + slave3_peer = peer; + GNUNET_TESTBED_operation_done (op); + op = GNUNET_TESTBED_peer_start (NULL, slave3_peer, NULL, NULL); break; default: - GNUNET_assert (0); + FAIL_TEST (0); } - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != op); } @@ -385,25 +475,15 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg) static void check_operation_success (const struct GNUNET_TESTBED_EventInformation *event) { - GNUNET_assert (NULL != event); - GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type); - GNUNET_assert (event->details.operation_finished.operation == op); - GNUNET_assert (NULL == event->details.operation_finished.op_cls); - GNUNET_assert (NULL == event->details.operation_finished.emsg); - GNUNET_assert (NULL == event->details.operation_finished.generic); + FAIL_TEST (NULL != event); + FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type); + FAIL_TEST (event->op == op); + FAIL_TEST (NULL == event->op_cls); + FAIL_TEST (NULL == event->details.operation_finished.emsg); + FAIL_TEST (NULL == event->details.operation_finished.generic); } -/** - * Callback which will be called to after a host registration succeeded or failed - * - * @param cls the host which has been registered - * @param emsg the error message; NULL if host registration is successful - */ -static void -registration_cont (void *cls, const char *emsg); - - /** * Signature of the event handler function called by the * respective event controller. @@ -421,120 +501,155 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event) GNUNET_TESTBED_operation_done (op); op = NULL; result = SLAVE1_LINK_SUCCESS; - GNUNET_assert (NULL != slave2); - GNUNET_assert (NULL != slave); - op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, cfg, GNUNET_YES); - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != slave2); + FAIL_TEST (NULL != slave); + op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL); + FAIL_TEST (NULL != op); break; - case SLAVE1_LINK_SUCCESS: + case SLAVE1_PEER_START_SUCCESS: check_operation_success (event); GNUNET_TESTBED_operation_done (op); - op = NULL; result = SLAVE2_LINK_SUCCESS; - op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL); - GNUNET_assert (NULL != op); + op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL); + FAIL_TEST (NULL != op); break; case MASTER_PEER_CREATE_SUCCESS: - GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type); - GNUNET_assert (event->details.peer_start.host == host); - GNUNET_assert (event->details.peer_start.peer == master_peer); + FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type); + FAIL_TEST (event->details.peer_start.host == host); + FAIL_TEST (event->details.peer_start.peer == master_peer); GNUNET_TESTBED_operation_done (op); result = MASTER_PEER_START_SUCCESS; - slave = GNUNET_TESTBED_host_create_with_id (1, "127.0.0.1", NULL, 0); - GNUNET_assert (NULL != slave); + slave = GNUNET_TESTBED_host_create_with_id (1, "127.0.0.1", NULL, cfg, 0); + FAIL_TEST (NULL != slave); rh = GNUNET_TESTBED_register_host (mc, slave, ®istration_cont, NULL); - GNUNET_assert (NULL != rh); + FAIL_TEST (NULL != rh); break; - case SLAVE2_PEER_CREATE_SUCCESS: - GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type); - GNUNET_assert (event->details.peer_start.host == slave); - GNUNET_assert (event->details.peer_start.peer == slave1_peer); + case SLAVE1_PEER_CREATE_SUCCESS: + FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type); + FAIL_TEST (event->details.peer_start.host == slave); + FAIL_TEST (event->details.peer_start.peer == slave1_peer); GNUNET_TESTBED_operation_done (op); result = SLAVE1_PEER_START_SUCCESS; - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 1), &delay_task, - NULL); + op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, GNUNET_YES); break; - case SLAVE1_PEER_START_SUCCESS: - GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type); - GNUNET_assert (event->details.peer_stop.peer == slave1_peer); + case SLAVE2_PEER_CREATE_SUCCESS: + FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type); + FAIL_TEST (event->details.peer_stop.peer == slave1_peer); GNUNET_TESTBED_operation_done (op); result = SLAVE1_PEER_STOP_SUCCESS; - op = GNUNET_TESTBED_peer_start (slave2_peer, NULL, NULL); - GNUNET_assert (NULL != op); + op = GNUNET_TESTBED_peer_start (NULL, slave2_peer, NULL, NULL); + FAIL_TEST (NULL != op); + break; + case SLAVE3_PEER_CREATE_SUCCESS: + FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type); + FAIL_TEST (event->details.peer_start.host == slave3); + FAIL_TEST (event->details.peer_start.peer == slave3_peer); + GNUNET_TESTBED_operation_done (op); + result = SLAVE3_PEER_START_SUCCESS; + sleep (1); + LOG_DEBUG ("**************************************\n"); + op = GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, slave2_peer, + slave3_peer); + FAIL_TEST (NULL != op); + break; + case SLAVE3_PEER_START_SUCCESS: + FAIL_TEST (NULL != event); + FAIL_TEST (GNUNET_TESTBED_ET_CONNECT == event->type); + FAIL_TEST (event->details.peer_connect.peer1 == slave2_peer); + FAIL_TEST (event->details.peer_connect.peer2 == slave3_peer); + result = SLAVE2_SLAVE3_PEERS_CONNECTED; + GNUNET_TESTBED_operation_done (op); + op = NULL; + delay_task_id = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), &delay_task, + NULL); break; case SLAVE1_PEER_STOP_SUCCESS: - GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type); - GNUNET_assert (event->details.peer_start.host == slave2); - GNUNET_assert (event->details.peer_start.peer == slave2_peer); + FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type); + FAIL_TEST (event->details.peer_start.host == slave2); + FAIL_TEST (event->details.peer_start.peer == slave2_peer); GNUNET_TESTBED_operation_done (op); result = SLAVE2_PEER_START_SUCCESS; op = GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, master_peer, slave2_peer); break; case SLAVE2_PEER_START_SUCCESS: - GNUNET_assert (NULL != event); - GNUNET_assert (GNUNET_TESTBED_ET_CONNECT == event->type); - GNUNET_assert (event->details.peer_connect.peer1 == master_peer); - GNUNET_assert (event->details.peer_connect.peer2 == slave2_peer); + FAIL_TEST (NULL != event); + FAIL_TEST (GNUNET_TESTBED_ET_CONNECT == event->type); + FAIL_TEST (event->details.peer_connect.peer1 == master_peer); + FAIL_TEST (event->details.peer_connect.peer2 == slave2_peer); result = MASTER_SLAVE2_PEERS_CONNECTED; GNUNET_TESTBED_operation_done (op); op = NULL; - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 1), &delay_task, - NULL); + delay_task_id = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_SECONDS, 1), &delay_task, + NULL); break; - case MASTER_SLAVE2_PEERS_CONNECTED: - GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type); - GNUNET_assert (event->details.peer_stop.peer == slave2_peer); + case SLAVE2_SLAVE3_PEERS_CONNECTED: + FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type); + FAIL_TEST (event->details.peer_stop.peer == slave2_peer); GNUNET_TESTBED_operation_done (op); result = SLAVE2_PEER_STOP_SUCCESS; op = GNUNET_TESTBED_peer_destroy (slave1_peer); - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != op); break; case SLAVE2_PEER_STOP_SUCCESS: check_operation_success (event); GNUNET_TESTBED_operation_done (op); result = SLAVE1_PEER_DESTROY_SUCCESS; op = GNUNET_TESTBED_peer_destroy (slave2_peer); - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != op); break; case SLAVE1_PEER_DESTROY_SUCCESS: check_operation_success (event); GNUNET_TESTBED_operation_done (op); op = NULL; result = SLAVE2_PEER_DESTROY_SUCCESS; - slave3 = GNUNET_TESTBED_host_create_with_id (3, "127.0.0.1", NULL, 0); - rh = GNUNET_TESTBED_register_host (mc, slave3, ®istration_cont, NULL); + op = GNUNET_TESTBED_get_slave_config (NULL, mc, slave3); + FAIL_TEST (NULL != op); + break; + case SLAVE2_PEER_DESTROY_SUCCESS: + FAIL_TEST (NULL != event); + FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type); + FAIL_TEST (event->op == op); + FAIL_TEST (NULL == event->op_cls); + FAIL_TEST (NULL == event->details.operation_finished.emsg); + cfg3 = GNUNET_CONFIGURATION_dup (event->details.operation_finished.generic); + GNUNET_TESTBED_operation_done (op); + result = SLAVE3_GET_CONFIG_SUCCESS; + op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, slave, GNUNET_NO); break; case SLAVE3_REGISTERED: check_operation_success (event); GNUNET_TESTBED_operation_done (op); op = NULL; result = SLAVE3_STARTED; - op = GNUNET_TESTBED_get_slave_config (NULL, mc, slave3); - GNUNET_assert (NULL != op); - break; - case SLAVE3_STARTED: - GNUNET_assert (NULL != event); - GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type); - GNUNET_assert (event->details.operation_finished.operation == op); - GNUNET_assert (NULL == event->details.operation_finished.op_cls); - GNUNET_assert (NULL == event->details.operation_finished.emsg); - cfg3 = GNUNET_CONFIGURATION_dup (event->details.operation_finished.generic); - GNUNET_TESTBED_operation_done (op); - result = SLAVE3_GET_CONFIG_SUCCESS; - op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, slave, cfg3, GNUNET_NO); + op = GNUNET_TESTBED_peer_create (mc, slave3, cfg, peer_create_cb, NULL); + FAIL_TEST (NULL != op); break; case SLAVE3_GET_CONFIG_SUCCESS: result = SLAVE3_LINK_SUCCESS; GNUNET_TESTBED_operation_done (op); + op = GNUNET_TESTBED_peer_destroy (master_peer); + break; + case SLAVE3_LINK_SUCCESS: + check_operation_success (event); + result = MASTER_PEER_DESTROY_SUCCESS; + GNUNET_TESTBED_operation_done (op); + op = GNUNET_TESTBED_peer_destroy (slave3_peer); + break; + case MASTER_PEER_DESTROY_SUCCESS: + result = SUCCESS; + GNUNET_TESTBED_operation_done (op); + op = NULL; GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 3), - &do_shutdown, NULL); + (GNUNET_TIME_UNIT_SECONDS, 1), &do_shutdown, + NULL); break; default: - GNUNET_assert (0); + FAIL_TEST (0); } } @@ -552,29 +667,29 @@ registration_cont (void *cls, const char *emsg) switch (result) { case MASTER_PEER_START_SUCCESS: - GNUNET_assert (NULL == emsg); - GNUNET_assert (NULL != mc); + FAIL_TEST (NULL == emsg); + FAIL_TEST (NULL != mc); result = SLAVE1_REGISTERED; - slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, 0); - GNUNET_assert (NULL != slave2); + slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, cfg, 0); + FAIL_TEST (NULL != slave2); rh = GNUNET_TESTBED_register_host (mc, slave2, ®istration_cont, NULL); - GNUNET_assert (NULL != rh); + FAIL_TEST (NULL != rh); break; case SLAVE1_REGISTERED: - GNUNET_assert (NULL == emsg); - GNUNET_assert (NULL != mc); + FAIL_TEST (NULL == emsg); + FAIL_TEST (NULL != mc); result = SLAVE2_REGISTERED; - GNUNET_assert (NULL != cfg); - op = GNUNET_TESTBED_controller_link (NULL, mc, slave, NULL, cfg, GNUNET_YES); - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != cfg); + op = GNUNET_TESTBED_controller_link (NULL, mc, slave, NULL, GNUNET_YES); + FAIL_TEST (NULL != op); break; - case SLAVE2_PEER_DESTROY_SUCCESS: - GNUNET_assert (NULL == emsg); - GNUNET_assert (NULL != mc); - GNUNET_assert (NULL == op); + case MASTER_SLAVE2_PEERS_CONNECTED: + FAIL_TEST (NULL == emsg); + FAIL_TEST (NULL != mc); + FAIL_TEST (NULL == op); result = SLAVE3_REGISTERED; - op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, cfg, GNUNET_YES); - GNUNET_assert (NULL != op); + op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, GNUNET_YES); + FAIL_TEST (NULL != op); break; default: GNUNET_break (0); @@ -598,20 +713,20 @@ status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, switch (result) { case INIT: - GNUNET_assert (GNUNET_OK == status); + FAIL_TEST (GNUNET_OK == status); event_mask = 0; event_mask |= (1L << GNUNET_TESTBED_ET_PEER_START); event_mask |= (1L << GNUNET_TESTBED_ET_PEER_STOP); event_mask |= (1L << GNUNET_TESTBED_ET_CONNECT); event_mask |= (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED); - mc = GNUNET_TESTBED_controller_connect (config, host, event_mask, + mc = GNUNET_TESTBED_controller_connect (host, event_mask, &controller_cb, NULL); - GNUNET_assert (NULL != mc); + FAIL_TEST (NULL != mc); result = MASTER_STARTED; op = GNUNET_TESTBED_peer_create (mc, host, cfg, peer_create_cb, NULL); - GNUNET_assert (NULL != op); + FAIL_TEST (NULL != op); break; - default: + default: GNUNET_break (0); cp = NULL; do_abort_now (NULL); @@ -619,6 +734,38 @@ status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, } +/** + * 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 + * + * @param cls NULL + * @param host the host whose status is being reported; will be NULL if the host + * given to GNUNET_TESTBED_is_host_habitable() is NULL + * @param status GNUNET_YES if it is habitable; GNUNET_NO if not + */ +static void +host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *_host, + int status) +{ + hc_handle = NULL; + if (GNUNET_NO == status) + { + (void) PRINTF ("%s", + "Unable to run the test as this system is not configured " + "to use password less SSH logins to localhost.\n" + "Skipping test\n"); + GNUNET_SCHEDULER_cancel (abort_task); + abort_task = GNUNET_SCHEDULER_NO_TASK; + (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); + result = SKIP; + return; + } + cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, status_cb, + NULL); +} + + /** * Main run function. * @@ -631,11 +778,25 @@ static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config) { - host = GNUNET_TESTBED_host_create (NULL, NULL, 0); - GNUNET_assert (NULL != host); cfg = GNUNET_CONFIGURATION_dup (config); - cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, cfg, status_cb, - NULL); + host = GNUNET_TESTBED_host_create (NULL, NULL, cfg, 0); + FAIL_TEST (NULL != host); + if (NULL == + (hc_handle = + GNUNET_TESTBED_is_host_habitable (host, config, &host_habitable_cb, + NULL))) + { + GNUNET_TESTBED_host_destroy (host); + GNUNET_CONFIGURATION_destroy (cfg); + cfg = NULL; + host = NULL; + (void) PRINTF ("%s", + "Unable to run the test as this system is not configured " + "to use password less SSH logins to localhost.\n" + "Marking test as successful\n"); + result = SKIP; + return; + } abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5), &do_abort, @@ -643,45 +804,6 @@ run (void *cls, char *const *args, const char *cfgfile, } -/** - * Function to check if - * 1. Password-less SSH logins to given ip work - * 2. gnunet-helper-testbed is found on the PATH on the remote side - * - * @param host_str numeric representation of the host's ip - * @return GNUNET_YES if password-less SSH login to the given host works; - * GNUNET_NO if not - */ -static int -check_ssh (char *host_str) -{ - char *const remote_args[] = { - "ssh", "-o", "BatchMode=yes", "-o", "CheckHostIP=no", - "-o", "NoHostAuthenticationForLocalhost=yes", "-q", - host_str, "which", "gnunet-helper-testbed", NULL - }; - struct GNUNET_OS_Process *auxp; - enum GNUNET_OS_ProcessStatusType type; - unsigned long code; - int ret; - - auxp = - GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL, - NULL, "ssh", remote_args); - GNUNET_assert (NULL != auxp); - do - { - ret = GNUNET_OS_process_status (auxp, &type, &code); - GNUNET_assert (GNUNET_SYSERR != ret); - (void) usleep (300); - } - while (GNUNET_NO == ret); - (void) GNUNET_OS_process_wait (auxp); - GNUNET_OS_process_destroy (auxp); - return (0 != code) ? GNUNET_NO : GNUNET_YES; -} - - /** * Main function */ @@ -697,24 +819,22 @@ main (int argc, char **argv) }; int ret; - if (GNUNET_YES != check_ssh ("127.0.0.1")) - goto error_exit; result = INIT; ret = GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2, "test_testbed_api_controllerlink", "nohelp", options, &run, NULL); - if ((GNUNET_OK != ret) || (SLAVE3_LINK_SUCCESS != result)) + if (GNUNET_OK != ret) return 1; - return 0; - - error_exit: - (void) PRINTF ("%s", - "Unable to run the test as this system is not configured " - "to use password less SSH logins to localhost.\n" - "Marking test as successful\n"); - return 0; + switch (result) + { + case SUCCESS: + return 0; + case SKIP: + return 77; /* Mark test as skipped */ + default: + return 1; + } } /* end of test_testbed_api_controllerlink.c */ -