/** * Task to register all hosts available in the global host list * * @param cls NULL * @param tc the scheduler task context */ static void register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct DLLOperation *dll_op; static unsigned int reg_host; unsigned int slave; register_hosts_task = GNUNET_SCHEDULER_NO_TASK; if (reg_host == num_hosts - 1) { LOG (GNUNET_ERROR_TYPE_DEBUG, "All hosts successfully registered\n"); /* Start slaves */ state = STATE_SLAVES_STARTING; for (slave = 1; slave < num_hosts; slave++) { dll_op = GNUNET_malloc (sizeof (struct DLLOperation)); dll_op->op = GNUNET_TESTBED_controller_link (dll_op, mc, hosts[slave], hosts[0], cfg, GNUNET_YES); GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op); } return; } reg_handle = GNUNET_TESTBED_register_host (mc, hosts[++reg_host], host_registration_completion, NULL); }
/** * Callback to signal successfull startup of the controller process * * @param cls the closure from GNUNET_TESTBED_controller_start() * @param cfg the configuration with which the controller has been started; * NULL if status is not GNUNET_OK * @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 status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, int status) { uint64_t event_mask; if (GNUNET_OK != status) { GNUNET_break (0); cp1 = NULL; abort_test (); return; } 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); switch (result) { case INIT: controller1 = GNUNET_TESTBED_controller_connect (host, event_mask, &controller_cb, NULL); if (NULL == controller1) { GNUNET_break (0); abort_test (); return; } result = CONTROLLER1_UP; neighbour1 = GNUNET_TESTBED_host_create ("127.0.0.1", NULL, cfg, 0); if (NULL == neighbour1) { GNUNET_break (0); abort_test (); return; } reg_handle = GNUNET_TESTBED_register_host (controller1, neighbour1, ®istration_comp, neighbour1); if (NULL == reg_handle) { GNUNET_break (0); abort_test (); return; } break; default: GNUNET_break (0); abort_test (); return; } }
/** * Attempts to register the next host in the host registration queue * * @param slave the slave controller whose host registration queue is checked * for host registrations */ static void register_next_host (struct Slave *slave) { struct HostRegistration *hr; hr = slave->hr_dll_head; GNUNET_assert (NULL != hr); GNUNET_assert (NULL == slave->rhandle); LOG (GNUNET_ERROR_TYPE_DEBUG, "Registering host %u at %u\n", GNUNET_TESTBED_host_get_id_ (hr->host), GNUNET_TESTBED_host_get_id_ (GST_host_list[slave->host_id])); slave->rhandle = GNUNET_TESTBED_register_host (slave->controller, hr->host, hr_completion, slave); }
/** * 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_comp (void *cls, const char *emsg) { reg_handle = NULL; if (cls == neighbour1) { neighbour2 = GNUNET_TESTBED_host_create ("127.0.0.1", NULL, cfg, 0); if (NULL == neighbour2) { GNUNET_break (0); abort_test (); return; } reg_handle = GNUNET_TESTBED_register_host (controller1, neighbour2, ®istration_comp, neighbour2); if (NULL == reg_handle) { GNUNET_break (0); abort_test (); return; } return; } if (cls != neighbour2) { GNUNET_break (0); abort_test (); return; } peer1.operation = GNUNET_TESTBED_peer_create (controller1, host, cfg, &peer_create_cb, &peer1); if (NULL == peer1.operation) { GNUNET_break (0); abort_test (); return; } }
/** * Task for inserting delay between tests * * @param * @return */ static void delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { delay_task_id = NULL; switch (result) { 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: 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: FAIL_TEST (0); } }
/** * 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) { rh = NULL; switch (result) { case MASTER_PEER_START_SUCCESS: GNUNET_assert (NULL == emsg); GNUNET_assert (NULL != mc); result = SLAVE1_REGISTERED; slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, 0); GNUNET_assert (NULL != slave2); rh = GNUNET_TESTBED_register_host (mc, slave2, ®istration_cont, NULL); GNUNET_assert (NULL != rh); break; case SLAVE1_REGISTERED: GNUNET_assert (NULL == emsg); GNUNET_assert (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); break; case SLAVE2_PEER_DESTROY_SUCCESS: GNUNET_assert (NULL == emsg); GNUNET_assert (NULL != mc); GNUNET_assert (NULL == op); result = SLAVE3_REGISTERED; op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, cfg, GNUNET_YES); GNUNET_assert (NULL != op); break; default: GNUNET_break (0); do_abort_now (NULL); } }
/* Start slaves */ for (slave = 0; slave < rc->num_hosts; slave++) { rcop = GNUNET_new (struct RunContextOperation); rcop->rc = rc; rcop->op = GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave], rc->h, GNUNET_YES); GNUNET_assert (NULL != rcop->op); insert_rcop (rc, rcop); } rc->reg_hosts = 0; return; } rc->reg_handle = GNUNET_TESTBED_register_host (rc->c, rc->hosts[rc->reg_hosts], host_registration_completion, rc); rc->reg_hosts++; } /** * Callback to signal successfull startup of the controller process * * @param cls the closure from GNUNET_TESTBED_controller_start() * @param cfg the configuration with which the controller has been started; * NULL if status is not GNUNET_OK * @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 controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
/** * Signature of the event handler function called by the * respective event controller. * * @param cls closure * @param event information about the event */ static void controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event) { switch (result) { case SLAVE2_REGISTERED: check_operation_success (event); GNUNET_TESTBED_operation_done (op); op = NULL; result = SLAVE1_LINK_SUCCESS; GNUNET_assert (NULL != slave2); GNUNET_assert (NULL != slave); op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL); GNUNET_assert (NULL != op); break; case SLAVE1_PEER_START_SUCCESS: check_operation_success (event); GNUNET_TESTBED_operation_done (op); result = SLAVE2_LINK_SUCCESS; op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL); GNUNET_assert (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); 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); rh = GNUNET_TESTBED_register_host (mc, slave, ®istration_cont, NULL); GNUNET_assert (NULL != rh); break; case SLAVE1_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); GNUNET_TESTBED_operation_done (op); result = SLAVE1_PEER_START_SUCCESS; op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, cfg, GNUNET_YES); break; case SLAVE2_PEER_CREATE_SUCCESS: GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type); GNUNET_assert (event->details.peer_stop.peer == slave1_peer); GNUNET_TESTBED_operation_done (op); result = SLAVE1_PEER_STOP_SUCCESS; op = GNUNET_TESTBED_peer_start (NULL, slave2_peer, NULL, NULL); GNUNET_assert (NULL != op); 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); 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); 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); break; case MASTER_SLAVE2_PEERS_CONNECTED: GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type); GNUNET_assert (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); 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); 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); 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); 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 = SUCCESS; GNUNET_TESTBED_operation_done (op); op = NULL; GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3), &do_shutdown, NULL); break; default: GNUNET_assert (0); } }