diff options
Diffstat (limited to 'src/stream/test_stream_2peers_halfclose.c')
| -rw-r--r-- | src/stream/test_stream_2peers_halfclose.c | 488 |
1 files changed, 293 insertions, 195 deletions
diff --git a/src/stream/test_stream_2peers_halfclose.c b/src/stream/test_stream_2peers_halfclose.c index 7997c20..95f5aa9 100644 --- a/src/stream/test_stream_2peers_halfclose.c +++ b/src/stream/test_stream_2peers_halfclose.c @@ -23,29 +23,31 @@ * @brief Testcases for Stream API halfclosed connections between 2 peers * @author Sree Harsha Totakura */ - -#include <string.h> - #include "platform.h" #include "gnunet_util_lib.h" +#include "gnunet_testbed_service.h" #include "gnunet_mesh_service.h" #include "gnunet_stream_lib.h" -#include "gnunet_testing_lib.h" -#include "gnunet_scheduler_lib.h" - -#define VERBOSE 1 /** * Number of peers */ #define NUM_PEERS 2 +#define TIME_REL_SECS(sec) \ + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec) + /** * Structure for holding peer's sockets and IO Handles */ struct PeerData { /** + * The testbed peer handle corresponding to this peer + */ + struct GNUNET_TESTBED_Peer *peer; + + /** * Peer's stream socket */ struct GNUNET_STREAM_Socket *socket; @@ -53,12 +55,12 @@ struct PeerData /** * Peer's io write handle */ - struct GNUNET_STREAM_IOWriteHandle *io_write_handle; + struct GNUNET_STREAM_WriteHandle *io_write_handle; /** * Peer's io read handle */ - struct GNUNET_STREAM_IOReadHandle *io_read_handle; + struct GNUNET_STREAM_ReadHandle *io_read_handle; /** * Peer's shutdown handle @@ -66,6 +68,11 @@ struct PeerData struct GNUNET_STREAM_ShutdownHandle *shutdown_handle; /** + * Testbed operation handle specific for this peer + */ + struct GNUNET_TESTBED_Operation *op; + + /** * Our Peer id */ struct GNUNET_PeerIdentity our_id; @@ -91,20 +98,71 @@ struct PeerData int shutdown_operation; }; -/** - * The current peer group - */ -static struct GNUNET_TESTING_PeerGroup *pg; /** - * Peer 1 daemon + * Enumeration for various tests that are to be passed in the same order as + * below */ -static struct GNUNET_TESTING_Daemon *d1; +enum Test +{ + /** + * Peer1 writing; Peer2 reading + */ + PEER1_WRITE, + + /** + * Peer1 write shutdown; Peer2 should get an error when it tries to read; + */ + PEER1_WRITE_SHUTDOWN, + + /** + * Peer1 reads; Peer2 writes (connection is halfclosed) + */ + PEER1_HALFCLOSE_READ, + + /** + * Peer1 attempts to write; Should fail with stream already shutdown error + */ + PEER1_HALFCLOSE_WRITE_FAIL, + + /** + * Peer1 read shutdown; Peer2 should get stream shutdown error during write + */ + PEER1_READ_SHUTDOWN, + + /** + * All tests successfully finished + */ + SUCCESS +}; + /** - * Peer 2 daemon + * Different states in test setup */ -static struct GNUNET_TESTING_Daemon *d2; +enum SetupState +{ + /** + * Get the identity of peer 1 + */ + PEER1_GET_IDENTITY, + + /** + * Get the identity of peer 2 + */ + PEER2_GET_IDENTITY, + + /** + * Connect to stream service of peer 2 + */ + PEER2_STREAM_CONNECT, + + /** + * Connect to stream service of peer 1 + */ + PEER1_STREAM_CONNECT + +}; /** @@ -116,51 +174,28 @@ static struct GNUNET_TESTING_Daemon *d2; */ static struct PeerData peer1; static struct PeerData peer2; -static struct GNUNET_STREAM_ListenSocket *peer2_listen_socket; -static struct GNUNET_CONFIGURATION_Handle *config; +/** + * Task for aborting the test case if it takes too long + */ static GNUNET_SCHEDULER_TaskIdentifier abort_task; + +/** + * Task for reading from stream + */ static GNUNET_SCHEDULER_TaskIdentifier read_task; static char *data = "ABCD"; -static int result; /** - * Enumeration for various tests that are to be passed in the same order as - * below + * Handle to testbed operation */ -enum Test - { - /** - * Peer1 writing; Peer2 reading - */ - PEER1_WRITE, - - /** - * Peer1 write shutdown; Peer2 should get an error when it tries to read; - */ - PEER1_WRITE_SHUTDOWN, - - /** - * Peer1 reads; Peer2 writes (connection is halfclosed) - */ - PEER1_HALFCLOSE_READ, - - /** - * Peer1 attempts to write; Should fail with stream already shutdown error - */ - PEER1_HALFCLOSE_WRITE_FAIL, - - /** - * Peer1 read shutdown; Peer2 should get stream shutdown error during write - */ - PEER1_READ_SHUTDOWN, - - /** - * All tests successfully finished - */ - SUCCESS - }; +struct GNUNET_TESTBED_Operation *op; + +/** + * Final testing result + */ +static int result; /** * Current running test @@ -168,6 +203,12 @@ enum Test enum Test current_test; /** + * State is test setup + */ +enum SetupState setup_state; + + +/** * Input processor * * @param cls the closure from GNUNET_STREAM_write/read @@ -213,6 +254,7 @@ stream_read_task (void *cls, case PEER1_WRITE_SHUTDOWN: GNUNET_assert (&peer2 == peer); GNUNET_assert (NULL == peer->io_read_handle); + peer2.test_ok = GNUNET_YES; transition (); /* to PEER1_HALFCLOSE_READ */ break; default: @@ -274,51 +316,19 @@ stream_write_task (void *cls, /** - * Check whether peers successfully shut down. - */ -static void -peergroup_shutdown_callback (void *cls, const char *emsg) -{ - if (emsg != NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Shutdown of peers failed!\n"); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "All peers successfully shut down!\n"); - } - GNUNET_CONFIGURATION_destroy (config); -} - - -/** * Close sockets and stop testing deamons nicely */ static void do_close (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - if (NULL != peer1.socket) - GNUNET_STREAM_close (peer1.socket); if (NULL != peer2.socket) GNUNET_STREAM_close (peer2.socket); - if (NULL != peer2_listen_socket) - GNUNET_STREAM_listen_close (peer2_listen_socket); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: shutdown\n"); - if (0 != abort_task) - { + if (GNUNET_SCHEDULER_NO_TASK != abort_task) GNUNET_SCHEDULER_cancel (abort_task); - } - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Wait\n"); - - GNUNET_TESTING_daemons_stop (pg, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 5), - &peergroup_shutdown_callback, - NULL); + if (NULL != peer2.op) + GNUNET_TESTBED_operation_done (peer2.op); + else + GNUNET_SCHEDULER_shutdown (); /* For shutting down testbed */ } @@ -600,8 +610,8 @@ input_processor (void *cls, } break; case PEER1_WRITE_SHUTDOWN: - GNUNET_assert (GNUNET_STREAM_SHUTDOWN == status); - peer2.test_ok = GNUNET_YES; + GNUNET_assert (0); /* This callback will not be called when stream + is shutdown */ break; case PEER1_HALFCLOSE_WRITE_FAIL: case PEER1_READ_SHUTDOWN: @@ -642,15 +652,19 @@ stream_listen_cb (void *cls, struct GNUNET_STREAM_Socket *socket, const struct GNUNET_PeerIdentity *initiator) { - GNUNET_assert (NULL != socket); - GNUNET_assert (NULL != initiator); + if ((NULL == socket) || (NULL == initiator)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Binding error\n"); + if (GNUNET_SCHEDULER_NO_TASK != abort_task) + GNUNET_SCHEDULER_cancel (abort_task); + abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); + return GNUNET_OK; + } GNUNET_assert (socket != peer1.socket); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s: Peer connected: %s\n", GNUNET_i2s (&peer2.our_id), GNUNET_i2s(initiator)); - peer2.socket = socket; /* FIXME: reading should be done right now instead of a scheduled call */ read_task = GNUNET_SCHEDULER_add_now (&stream_read, (void *) socket); @@ -659,128 +673,212 @@ stream_listen_cb (void *cls, /** - * Callback to be called when testing peer group is ready - * - * @param cls NULL - * @param emsg NULL on success + * Listen success callback; connects a peer to stream as client + */ +static void +stream_connect (void); + + +/** + * Adapter function called to destroy a connection to + * a service. + * + * @param cls closure + * @param op_result service handle returned from the connect adapter */ -void -peergroup_ready (void *cls, const char *emsg) +static void +stream_da (void *cls, void *op_result) { - if (NULL != emsg) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Starting peer group failed: %s\n", emsg); - return; - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Peer group is now ready\n"); - - GNUNET_assert (2 == GNUNET_TESTING_daemons_running (pg)); - - d1 = GNUNET_TESTING_daemon_get (pg, 0); - GNUNET_assert (NULL != d1); - - d2 = GNUNET_TESTING_daemon_get (pg, 1); - GNUNET_assert (NULL != d2); + struct GNUNET_STREAM_ListenSocket *lsocket; - GNUNET_TESTING_get_peer_identity (d1->cfg, - &peer1.our_id); - GNUNET_TESTING_get_peer_identity (d2->cfg, - &peer2.our_id); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s : %s\n", - GNUNET_i2s (&peer1.our_id), - GNUNET_i2s (&d1->id)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s : %s\n", - GNUNET_i2s (&peer2.our_id), - GNUNET_i2s (&d2->id)); - - peer2_listen_socket = GNUNET_STREAM_listen (d2->cfg, - 10, /* App port */ - &stream_listen_cb, - NULL); - GNUNET_assert (NULL != peer2_listen_socket); - - /* Connect to stream library */ - peer1.socket = GNUNET_STREAM_open (d1->cfg, - &d2->id, /* Null for local peer? */ - 10, /* App port */ - &stream_open_cb, - &peer1, - GNUNET_STREAM_OPTION_END); - GNUNET_assert (NULL != peer1.socket); + if (&peer2 == cls) + { + lsocket = op_result; + GNUNET_STREAM_listen_close (lsocket); + if (NULL != peer1.op) + GNUNET_TESTBED_operation_done (peer1.op); + else + GNUNET_SCHEDULER_shutdown (); + return; + } + if (&peer1 == cls) + { + GNUNET_assert (op_result == peer1.socket); + GNUNET_STREAM_close (peer1.socket); + GNUNET_SCHEDULER_shutdown (); /* Exit point of the test */ + return; + } + GNUNET_assert (0); } /** - * Initialize framework and start test + * Adapter function called to establish a connection to + * a service. + * + * @param cls closure + * @param cfg configuration of the peer to connect to; will be available until + * GNUNET_TESTBED_operation_done() is called on the operation returned + * from GNUNET_TESTBED_service_connect() + * @return service handle to return in 'op_result', NULL on error + */ +static void * +stream_ca (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) +{ + struct GNUNET_STREAM_ListenSocket *lsocket; + + switch (setup_state) + { + case PEER2_STREAM_CONNECT: + lsocket = GNUNET_STREAM_listen (cfg, 10, &stream_listen_cb, NULL, + GNUNET_STREAM_OPTION_SIGNAL_LISTEN_SUCCESS, + &stream_connect, GNUNET_STREAM_OPTION_END); + GNUNET_assert (NULL != lsocket); + return lsocket; + case PEER1_STREAM_CONNECT: + peer1.socket = GNUNET_STREAM_open (cfg, &peer2.our_id, 10, &stream_open_cb, + &peer1, GNUNET_STREAM_OPTION_END); + GNUNET_assert (NULL != peer1.socket); + return peer1.socket; + default: + GNUNET_assert (0); + } +} + + +/** + * Listen success callback; connects a peer to stream as client */ static void -run (void *cls, char *const *args, const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +stream_connect (void) +{ + GNUNET_assert (PEER2_STREAM_CONNECT == setup_state); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stream listen open successful\n"); + peer1.op = GNUNET_TESTBED_service_connect (&peer1, peer1.peer, "stream", + NULL, NULL, + stream_ca, stream_da, &peer1); + setup_state = PEER1_STREAM_CONNECT; +} + + +/** + * 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 GNUNET_TESTING_Host *hosts; /* FIXME: free hosts (DLL) */ + GNUNET_assert (NULL == emsg); + GNUNET_assert (op == op_); + switch (setup_state) + { + case PEER1_GET_IDENTITY: + memcpy (&peer1.our_id, pinfo->result.id, + sizeof (struct GNUNET_PeerIdentity)); + GNUNET_TESTBED_operation_done (op); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 1 id: %s\n", GNUNET_i2s + (&peer1.our_id)); + op = GNUNET_TESTBED_peer_get_information (peer2.peer, + GNUNET_TESTBED_PIT_IDENTITY, + &peerinfo_cb, NULL); + setup_state = PEER2_GET_IDENTITY; + break; + case PEER2_GET_IDENTITY: + memcpy (&peer2.our_id, pinfo->result.id, + sizeof (struct GNUNET_PeerIdentity)); + GNUNET_TESTBED_operation_done (op); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer 2 id: %s\n", GNUNET_i2s + (&peer2.our_id)); + peer2.op = GNUNET_TESTBED_service_connect (&peer2, peer2.peer, "stream", + NULL, NULL, + stream_ca, stream_da, &peer2); + setup_state = PEER2_STREAM_CONNECT; + break; + default: + GNUNET_assert (0); + } +} - /* GNUNET_log_setup ("test_stream_local", */ - /* "DEBUG", */ - /* NULL); */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting test\n"); - /* Duplicate the configuration */ - config = GNUNET_CONFIGURATION_dup (cfg); +/** + * 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: + switch (setup_state) + { + case PEER1_STREAM_CONNECT: + case PEER2_STREAM_CONNECT: + GNUNET_assert (NULL == event->details.operation_finished.emsg); + break; + default: + GNUNET_assert (0); + } + break; + default: + GNUNET_assert (0); + } +} - hosts = GNUNET_TESTING_hosts_load (config); - - pg = GNUNET_TESTING_peergroup_start (config, - 2, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 3), - NULL, - &peergroup_ready, - NULL, - hosts); - GNUNET_assert (NULL != pg); - + +/** + * Signature of a main function for a testcase. + * + * @param cls closure + * @param num_peers number of peers in 'peers' + * @param peers handle to peers run in the testbed + */ +static void +test_master (void *cls, unsigned int num_peers, + struct GNUNET_TESTBED_Peer **peers) +{ + GNUNET_assert (NULL != peers); + GNUNET_assert (NULL != peers[0]); + GNUNET_assert (NULL != peers[1]); + peer1.peer = peers[0]; + peer2.peer = peers[1]; + op = GNUNET_TESTBED_peer_get_information (peer1.peer, + GNUNET_TESTBED_PIT_IDENTITY, + &peerinfo_cb, NULL); + setup_state = PEER1_GET_IDENTITY; abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 40), &do_abort, + (GNUNET_TIME_UNIT_SECONDS, 1000), &do_abort, NULL); } + /** * Main function */ int main (int argc, char **argv) { - int ret; - - char *argv2[] = { "test-stream-2peers-halfclose", - "-L", "DEBUG", - "-c", "test_stream_local.conf", - NULL}; - - struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_OPTION_END - }; - - ret = - GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2, - "test-stream-2peers-halfclose", "nohelp", options, &run, NULL); - - if (GNUNET_OK != ret) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "run failed with error code %d\n", - ret); - return 1; - } + uint64_t event_mask; + + result = GNUNET_NO; + event_mask = 0; + event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); + (void) GNUNET_TESTBED_test_run ("test_stream_2peers_halfclose", + "test_stream_local.conf", NUM_PEERS, + event_mask, + &controller_event_cb, NULL, &test_master, + NULL); if (GNUNET_SYSERR == result) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test failed\n"); return 1; - } - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "test ok\n"); return 0; } |