/**
* Release the connection to the neighbour. The actual connection will be
* closed if connections to other neighbour are waiting (to maintain a bound on
* the total number of connections that are open).
*
* @param n the neighbour whose connection can be closed
*/
void
GST_neighbour_release_connection (struct Neighbour *n)
{
GNUNET_assert (0 == n->inactive);
GNUNET_assert (0 < n->reference_cnt);
n->reference_cnt--;
if (0 == n->reference_cnt)
{
n->inactive = 1;
GNUNET_TESTBED_operation_inactivate_ (n->conn_op);
}
}
/**
* Function to cancel an operation (release all associated resources). This can
* be because of a call to "GNUNET_TESTBED_operation_cancel" (before the
* operation generated an event) or AFTER the operation generated an event due
* to a call to "GNUNET_TESTBED_operation_done". Thus it is not guaranteed that
* a callback to the 'OperationStart' preceeds the call to 'OperationRelease'.
* Implementations of this function are expected to clean up whatever state is
* in 'cls' and release all resources associated with the operation.
*/
static void
release_cb (void *cls)
{
switch (result)
{
case TEST_OP1_STARTED:
GNUNET_assert (&op1 == cls);
result = TEST_OP1_RELEASED;
op1 = NULL;
step_task =
GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP2_STARTED:
GNUNET_assert (&op2 == cls);
result = TEST_OP2_RELEASED;
GNUNET_assert (NULL == step_task);
break;
case TEST_OP3_STARTED:
GNUNET_assert (&op3 == cls);
result = TEST_OP3_RELEASED;
GNUNET_assert (NULL == step_task);
break;
case TEST_OP4_STARTED:
GNUNET_assert (&op4 == cls);
result = TEST_OP4_RELEASED;
GNUNET_assert (NULL == step_task);
op5 = GNUNET_TESTBED_operation_create_ (&op5, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op5, 1);
GNUNET_TESTBED_operation_begin_wait_ (op5);
op6 = GNUNET_TESTBED_operation_create_ (&op6, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op6, 1);
GNUNET_TESTBED_operation_begin_wait_ (op6);
op7 = GNUNET_TESTBED_operation_create_ (&op7, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op7, 1);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op7, 1);
GNUNET_TESTBED_operation_begin_wait_ (op7);
break;
case TEST_OP5_6_7_STARTED:
result = TEST_OP5_RELEASED;
op5 = NULL;
GNUNET_TESTBED_operation_release_ (op6);
break;
case TEST_OP5_RELEASED:
op6 = NULL;
result = TEST_OP6_RELEASED;
GNUNET_TESTBED_operation_inactivate_ (op7);
step_task = GNUNET_SCHEDULER_add_now (&step, NULL);
break;
case TEST_OP8_WAITING:
GNUNET_assert (&op7 == cls);
op7 = NULL;
result = TEST_OP7_RELEASED;
break;
case TEST_OP8_ACTIVE:
result = TEST_OP8_RELEASED;
op8 = NULL;
break;
case TEST_OP9_STARTED:
GNUNET_assert (&op9 == cls);
result = TEST_OP9_RELEASED;
GNUNET_TESTBED_operation_queue_destroy_ (q1);
GNUNET_TESTBED_operation_queue_destroy_ (q2);
q1 = NULL;
q2 = NULL;
break;
default:
GNUNET_assert (0);
}
}
/**
* Task to simulate artificial delay and change the test stage
*
* @param cls NULL
*/
static void
step (void *cls)
{
GNUNET_assert (NULL != step_task);
step_task = NULL;
switch (result)
{
case TEST_OP1_STARTED:
GNUNET_TESTBED_operation_release_ (op1);
GNUNET_TESTBED_operation_queue_reset_max_active_ (q1, 0);
op3 = GNUNET_TESTBED_operation_create_ (&op3, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op3, 2);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op3, 2);
GNUNET_TESTBED_operation_begin_wait_ (op3);
op4 = GNUNET_TESTBED_operation_create_ (&op4, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op4, 2);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op4, 2);
GNUNET_TESTBED_operation_begin_wait_ (op4);
break;
case TEST_OP1_RELEASED:
result = TEST_PAUSE;
GNUNET_TESTBED_operation_queue_reset_max_active_ (q1, 2);
break;
case TEST_OP2_STARTED:
GNUNET_TESTBED_operation_release_ (op2);
break;
case TEST_OP3_STARTED:
GNUNET_TESTBED_operation_release_ (op3);
break;
case TEST_OP4_STARTED:
GNUNET_TESTBED_operation_release_ (op4);
break;
case TEST_OP6_RELEASED:
op8 = GNUNET_TESTBED_operation_create_ (&op8, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op8, 2);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op8, 2);
result = TEST_OP8_WAITING;
GNUNET_TESTBED_operation_begin_wait_ (op8);
break;
case TEST_OP8_STARTED:
GNUNET_TESTBED_operation_inactivate_ (op8);
result = TEST_OP8_INACTIVE_1;
step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP8_INACTIVE_1:
GNUNET_TESTBED_operation_activate_ (op8);
result = TEST_OP8_ACTIVE;
op9 = GNUNET_TESTBED_operation_create_ (&op9, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op9, 1);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op9, 1);
GNUNET_TESTBED_operation_begin_wait_ (op9);
step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP8_ACTIVE:
GNUNET_TESTBED_operation_inactivate_ (op8);
/* op8 should be released by now due to above call */
GNUNET_assert (TEST_OP8_RELEASED == result);
break;
case TEST_OP9_STARTED:
GNUNET_TESTBED_operation_release_ (op9);
break;
default:
GNUNET_assert (0);
}
}