diff options
Diffstat (limited to 'src/dht/test_dht_topo.c')
| -rw-r--r-- | src/dht/test_dht_topo.c | 769 |
1 files changed, 299 insertions, 470 deletions
diff --git a/src/dht/test_dht_topo.c b/src/dht/test_dht_topo.c index f51f3a6..c9036d2 100644 --- a/src/dht/test_dht_topo.c +++ b/src/dht/test_dht_topo.c @@ -19,535 +19,384 @@ */ /** * @file dht/test_dht_topo.c - * + * @author Christian Grothoff * @brief Test for the dht service: store and retrieve in various topologies. - * Each peer stores it own ID in the DHT and then a different peer tries to - * retrieve that key from it. The GET starts after a first round of PUTS has - * been made. Periodically, each peer stores its ID into the DHT. If after - * a timeout no result has been returned, the test fails. + * Each peer stores a value from the DHT and then each peer tries to get each + * value from each other peer. */ #include "platform.h" -#include "gnunet_testing_lib.h" +#include "gnunet_util_lib.h" #include "gnunet_dht_service.h" - -#define REMOVE_DIR GNUNET_YES +#include "dht_test_lib.h" /** - * DIFFERENT TESTS TO RUN + * How long until we give up on fetching the data? */ -#define LINE 0 -#define TORUS 1 +#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) /** - * How long until we give up on connecting the peers? + * How frequently do we execute the PUTs? */ -#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1500) - -#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) - #define PUT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) -/** - * Result of the test. - */ -static int ok; /** - * Total number of peers in the test. + * Information we keep for each GET operation. */ -static unsigned long long num_peers; +struct GetOperation +{ + /** + * DLL. + */ + struct GetOperation *next; -/** - * Global configuration file - */ -static struct GNUNET_CONFIGURATION_Handle *testing_cfg; + /** + * DLL. + */ + struct GetOperation *prev; -/** - * Total number of currently running peers. - */ -static unsigned long long peers_running; + /** + * Handle for the operation. + */ + struct GNUNET_DHT_GetHandle *get; + +}; -/** - * Total number of connections in the whole network. - */ -static unsigned int total_connections; /** - * The currently running peer group. + * Result of the test. */ -static struct GNUNET_TESTING_PeerGroup *pg; +static int ok = 1; /** - * File to report results to. + * Task to do DHT_puts */ -static struct GNUNET_DISK_FileHandle *output_file; +static GNUNET_SCHEDULER_TaskIdentifier put_task; /** - * File to log connection info, statistics to. + * Task to time out / regular shutdown. */ -static struct GNUNET_DISK_FileHandle *data_file; +static GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** - * Task called to disconnect peers. + * Head of list of active GET operations. */ -static GNUNET_SCHEDULER_TaskIdentifier disconnect_task; +static struct GetOperation *get_head; /** - * Task To perform tests + * Tail of list of active GET operations. */ -static GNUNET_SCHEDULER_TaskIdentifier test_task; +static struct GetOperation *get_tail; /** - * Task to do DHT_puts - */ -static GNUNET_SCHEDULER_TaskIdentifier put_task; + * Array of the testbed's peers. + */ +static struct GNUNET_TESTBED_Peer **my_peers; /** - * Task called to shutdown test. + * Number of peers to run. */ -static GNUNET_SCHEDULER_TaskIdentifier shutdown_handle; - -static char *topology_file; - -static struct GNUNET_DHT_Handle **hs; - -static struct GNUNET_DHT_GetHandle *get_h; - -static struct GNUNET_DHT_GetHandle *get_h_2; - -static struct GNUNET_DHT_GetHandle *get_h_far; - -static int found_1; +static unsigned int NUM_PEERS; -static int found_2; - -static int found_far; /** - * Which topology are we to run + * Statistics we print out. */ -static int test_topology; +static struct +{ + const char *subsystem; + const char *name; + unsigned long long total; +} stats[] = { + {"core", "# bytes decrypted", 0}, + {"core", "# bytes encrypted", 0}, + {"core", "# type maps received", 0}, + {"core", "# session keys confirmed via PONG", 0}, + {"core", "# peers connected", 0}, + {"core", "# key exchanges initiated", 0}, + {"core", "# send requests dropped (disconnected)", 0}, + {"core", "# transmissions delayed due to corking", 0}, + {"core", "# messages discarded (expired prior to transmission)", 0}, + {"core", "# messages discarded (disconnected)", 0}, + {"core", "# discarded CORE_SEND requests", 0}, + {"core", "# discarded lower priority CORE_SEND requests", 0}, + {"transport", "# bytes received via TCP", 0}, + {"transport", "# bytes transmitted via TCP", 0}, + {"dht", "# PUT messages queued for transmission", 0}, + {"dht", "# P2P PUT requests received", 0}, + {"dht", "# GET messages queued for transmission", 0}, + {"dht", "# P2P GET requests received", 0}, + {"dht", "# RESULT messages queued for transmission", 0}, + {"dht", "# P2P RESULTS received", 0}, + {"dht", "# Queued messages discarded (peer disconnected)", 0}, + {"dht", "# Peers excluded from routing due to Bloomfilter", 0}, + {"dht", "# Peer selection failed", 0}, + {"dht", "# FIND PEER requests ignored due to Bloomfilter", 0}, + {"dht", "# FIND PEER requests ignored due to lack of HELLO", 0}, + {"dht", "# P2P FIND PEER requests processed", 0}, + {"dht", "# P2P GET requests ONLY routed", 0}, + {"dht", "# Preference updates given to core", 0}, + {"dht", "# REPLIES ignored for CLIENTS (no match)", 0}, + {"dht", "# GET requests from clients injected", 0}, + {"dht", "# GET requests received from clients", 0}, + {"dht", "# GET STOP requests received from clients", 0}, + {"dht", "# ITEMS stored in datacache", 0}, + {"dht", "# Good RESULTS found in datacache", 0}, + {"dht", "# GET requests given to datacache", 0}, + {NULL, NULL, 0} +}; /** - * Check whether peers successfully shut down. + * Function called once we're done processing stats. + * + * @param cls the test context + * @param op the stats operation + * @param emsg error message on failure */ static void -shutdown_callback (void *cls, const char *emsg) +stats_finished (void *cls, + struct GNUNET_TESTBED_Operation *op, + const char *emsg) { - if (emsg != NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Shutdown of peers failed!\n"); - ok++; - } - else + struct GNUNET_DHT_TEST_Context *ctx = cls; + unsigned int i; + + if (NULL != op) + GNUNET_TESTBED_operation_done (op); // needed? + if (NULL != emsg) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "All peers successfully shut down!\n"); + fprintf (stderr, _("Gathering statistics failed: %s\n"), + emsg); + GNUNET_SCHEDULER_cancel (put_task); + GNUNET_DHT_TEST_cleanup (ctx); + return; } - GNUNET_CONFIGURATION_destroy (testing_cfg); + for (i = 0; NULL != stats[i].name; i++) + FPRINTF (stderr, + "%6s/%60s = %12llu\n", + stats[i].subsystem, + stats[i].name, + stats[i].total); + GNUNET_SCHEDULER_cancel (put_task); + GNUNET_DHT_TEST_cleanup (ctx); } -static void -shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +/** + * Function called to process statistic values from all peers. + * + * @param cls closure + * @param peer the peer the statistic belong to + * @param subsystem name of subsystem that created the statistic + * @param name the name of the datum + * @param value the current value + * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not + * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration + */ +static int +handle_stats (void *cls, + const struct GNUNET_TESTBED_Peer *peer, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Ending test.\n"); - - if (disconnect_task != GNUNET_SCHEDULER_NO_TASK) - { - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = GNUNET_SCHEDULER_NO_TASK; - } + unsigned int i; - if (data_file != NULL) - GNUNET_DISK_file_close (data_file); - GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); + for (i = 0; NULL != stats[i].name; i++) + if ( (0 == strcasecmp (subsystem, + stats[i].subsystem)) && + (0 == strcasecmp (name, + stats[i].name)) ) + stats[i].total += value; + return GNUNET_OK; } +/** + * Task run on success or timeout to clean up. + * Terminates active get operations and shuts down + * the testbed. + * + * @param cls the 'struct GNUNET_DHT_TestContext' + * @param tc scheduler context + */ static void -disconnect_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +shutdown_task (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - unsigned int i; + struct GNUNET_DHT_TEST_Context *ctx = cls; + struct GetOperation *get_op; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "disconnecting peers\n"); - disconnect_task = GNUNET_SCHEDULER_NO_TASK; - GNUNET_SCHEDULER_cancel (put_task); - if (NULL != get_h) - GNUNET_DHT_get_stop (get_h); - if (NULL != get_h_2) - GNUNET_DHT_get_stop (get_h_2); - if (NULL != get_h_far) - GNUNET_DHT_get_stop (get_h_far); - for (i = 0; i < num_peers; i++) + while (NULL != (get_op = get_tail)) { - GNUNET_DHT_disconnect (hs[i]); + GNUNET_DHT_get_stop (get_op->get); + GNUNET_CONTAINER_DLL_remove (get_head, + get_tail, + get_op); + GNUNET_free (get_op); } - GNUNET_SCHEDULER_cancel (shutdown_handle); - shutdown_handle = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); + (void) GNUNET_TESTBED_get_statistics (NUM_PEERS, + my_peers, + &handle_stats, + &stats_finished, + ctx); } +/** + * Iterator called on each result obtained for a DHT + * operation that expects a reply + * + * @param cls closure with our 'struct GetOperation' + * @param exp when will this value expire + * @param key key of the result + * @param get_path peers on reply path (or NULL if not recorded) + * @param get_path_length number of entries in get_path + * @param put_path peers on the PUT path (or NULL if not recorded) + * @param put_path_length number of entries in get_path + * @param type type of the result + * @param size number of bytes in data + * @param data pointer to the result data + */ static void -dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp, - const GNUNET_HashCode * key, - const struct GNUNET_PeerIdentity *get_path, - unsigned int get_path_length, - const struct GNUNET_PeerIdentity *put_path, - unsigned int put_path_length, enum GNUNET_BLOCK_Type type, - size_t size, const void *data) +dht_get_handler (void *cls, struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode * key, + const struct GNUNET_PeerIdentity *get_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int put_path_length, enum GNUNET_BLOCK_Type type, + size_t size, const void *data) { - int i; + struct GetOperation *get_op = cls; + struct GNUNET_HashCode want; + struct GNUNET_DHT_TestContext *ctx; - if (sizeof (GNUNET_HashCode) == size) + if (sizeof (struct GNUNET_HashCode) != size) { - const GNUNET_HashCode *h = data; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Contents: %s\n", - GNUNET_h2s_full (h)); - - } - else - { - GNUNET_break(0); - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "PATH: (get %u, put %u)\n", - get_path_length, put_path_length); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " LOCAL\n"); - for (i = get_path_length - 1; i >= 0; i--) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " %s\n", - GNUNET_i2s (&get_path[i])); + GNUNET_break (0); + return; } - for (i = put_path_length - 1; i >= 0; i--) + GNUNET_CRYPTO_hash (key, sizeof (*key), &want); + if (0 != memcmp (&want, data, sizeof (want))) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " %s\n", - GNUNET_i2s (&put_path[i])); + GNUNET_break (0); + return; } - switch ((long)cls) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Get successful\n"); +#if 0 { - case 1: - found_1++; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "FOUND 1!\n"); - break; - case 2: - found_2++; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "FOUND 2!\n"); - break; - case 3: - found_far++; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "FOUND FAR!\n"); - break; - default: - GNUNET_break(0); + int i; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "PATH: (get %u, put %u)\n", + get_path_length, put_path_length); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " LOCAL\n"); + for (i = get_path_length - 1; i >= 0; i--) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " %s\n", + GNUNET_i2s (&get_path[i])); + for (i = put_path_length - 1; i >= 0; i--) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " %s\n", + GNUNET_i2s (&put_path[i])); } - if ( (TORUS == test_topology) && - ( (found_1 == 0) || (found_2 == 0) || (found_far == 0)) ) +#endif + GNUNET_DHT_get_stop (get_op->get); + GNUNET_CONTAINER_DLL_remove (get_head, + get_tail, + get_op); + GNUNET_free (get_op); + if (NULL != get_head) return; + /* all DHT GET operations successful; terminate! */ ok = 0; - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_peers, NULL); + ctx = GNUNET_SCHEDULER_cancel (timeout_task); + timeout_task = GNUNET_SCHEDULER_add_now (&shutdown_task, ctx); } -static void -do_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct GNUNET_TESTING_Daemon *d; - struct GNUNET_TESTING_Daemon *d2; - struct GNUNET_TESTING_Daemon *d_far; - struct GNUNET_TESTING_Daemon *o; - struct GNUNET_TESTING_Daemon *aux; - const char *id_aux; - const char *id_origin = "FC74"; - const char *id_near = "9P6V"; - const char *id_near2 = "2GDS"; - const char *id_far = "KPST"; - unsigned int i; - - d = d2 = d_far = o = NULL; - found_1 = found_2 = found_far = 0; - if (LINE == test_topology) - { - o = GNUNET_TESTING_daemon_get (pg, 0); - d = GNUNET_TESTING_daemon_get (pg, 4); - } - else if (TORUS == test_topology) - { - for (i = 0; i < num_peers; i++) - { - aux = GNUNET_TESTING_daemon_get (pg, i); - id_aux = GNUNET_i2s (&aux->id); - if (strcmp (id_aux, id_origin) == 0) - o = aux; - if (strcmp (id_aux, id_far) == 0) - d_far = aux; - if (strcmp (id_aux, id_near) == 0) - d = aux; - if (strcmp (id_aux, id_near2) == 0) - d2 = aux; - } - if ((NULL == o) || (NULL == d) || (NULL == d2) || (NULL == d_far)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Peers not found (hostkey file changed?)\n"); - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_peers, NULL); - return; - } - } - else - { - GNUNET_assert (0); - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test_task\nfrom %s\n", - GNUNET_h2s_full (&o->id.hashPubKey)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " looking for %s\n", - GNUNET_h2s_full (&d->id.hashPubKey)); - get_h = GNUNET_DHT_get_start (hs[0], - GNUNET_BLOCK_TYPE_TEST, /* type */ - &d->id.hashPubKey, /*key to search */ - 4U, /* replication level */ - GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, NULL, /* xquery */ - 0, /* xquery bits */ - &dht_get_id_handler, (void *)1); - if (TORUS == test_topology) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " looking for %s\n", - GNUNET_h2s_full (&d2->id.hashPubKey)); - get_h_2 = GNUNET_DHT_get_start (hs[0], - GNUNET_BLOCK_TYPE_TEST, /* type */ - &d2->id.hashPubKey, /*key to search */ - 4U, /* replication level */ - GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, NULL, /* xquery */ - 0, /* xquery bits */ - &dht_get_id_handler, (void *)2); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " looking for %s\n", - GNUNET_h2s_full (&d_far->id.hashPubKey)); - get_h_far = GNUNET_DHT_get_start (hs[0], - GNUNET_BLOCK_TYPE_TEST, /* type */ - &d_far->id.hashPubKey, /*key to search */ - 4U, /* replication level */ - GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, NULL, /* xquery */ - 0, /* xquery bits */ - &dht_get_id_handler, (void *)3); - } - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = - GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &disconnect_peers, NULL); -} - /** - * Task to put the id of each peer into teh DHT. + * Task to put the id of each peer into the DHT. * - * @param cls Closure (unused) + * @param cls array with NUM_PEERS DHT handles * @param tc Task context - * */ static void -put_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +do_puts (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct GNUNET_TESTING_Daemon *d; + struct GNUNET_DHT_Handle **hs = cls; + struct GNUNET_HashCode key; + struct GNUNET_HashCode value; unsigned int i; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "putting id's in DHT\n"); - for (i = 0; i < num_peers; i++) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Putting values into DHT\n"); + for (i = 0; i < NUM_PEERS; i++) { - d = GNUNET_TESTING_daemon_get (pg, i); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " putting into DHT: %s\n", - GNUNET_h2s_full (&d->id.hashPubKey)); - GNUNET_DHT_put (hs[i], &d->id.hashPubKey, 10U, + GNUNET_CRYPTO_hash (&i, sizeof (i), &key); + GNUNET_CRYPTO_hash (&key, sizeof (key), &value); + GNUNET_DHT_put (hs[i], &key, 10U, GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, - GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity), - (const char *) &d->id, GNUNET_TIME_UNIT_FOREVER_ABS, - GNUNET_TIME_UNIT_FOREVER_REL, NULL, NULL); - + GNUNET_BLOCK_TYPE_TEST, + sizeof (value), &value, + GNUNET_TIME_UNIT_FOREVER_ABS, + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, NULL); } - put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, &put_id, NULL); - if (GNUNET_SCHEDULER_NO_TASK == test_task) - test_task = GNUNET_SCHEDULER_add_now (&do_test, NULL); + put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, + &do_puts, hs); } /** - * peergroup_ready: start test when all peers are connected - * - * @param cls closure - * @param emsg error message - * - */ -static void -peergroup_ready (void *cls, const char *emsg) -{ - struct GNUNET_TESTING_Daemon *d; - char *buf; - int buf_len; - unsigned int i; - - if (emsg != NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Peergroup callback called with error, aborting test!\n"); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Error from testing: `%s'\n", - emsg); - ok++; - GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); - return; - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Peer Group started successfully with %u connections\n", - total_connections); - if (data_file != NULL) - { - buf = NULL; - buf_len = GNUNET_asprintf (&buf, "CONNECTIONS_0: %u\n", total_connections); - if (buf_len > 0) - GNUNET_DISK_file_write (data_file, buf, buf_len); - GNUNET_free (buf); - } - peers_running = GNUNET_TESTING_daemons_running (pg); - - GNUNET_assert (peers_running == num_peers); - hs = GNUNET_malloc (num_peers * sizeof (struct GNUNET_DHT_Handle *)); - for (i = 0; i < num_peers; i++) - { - d = GNUNET_TESTING_daemon_get (pg, i); - hs[i] = GNUNET_DHT_connect (d->cfg, 32); - } - - test_task = GNUNET_SCHEDULER_NO_TASK; - put_task = GNUNET_SCHEDULER_add_now (&put_id, NULL); - disconnect_task = - GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &disconnect_peers, NULL); - -} - - -/** - * Function that will be called whenever two daemons are connected by - * the testing library. + * Main function of the test. * - * @param cls closure - * @param first peer id for first daemon - * @param second peer id for the second daemon - * @param distance distance between the connected peers - * @param first_cfg config for the first daemon - * @param second_cfg config for the second daemon - * @param first_daemon handle for the first daemon - * @param second_daemon handle for the second daemon - * @param emsg error message (NULL on success) - */ -static void -connect_cb (void *cls, const struct GNUNET_PeerIdentity *first, - const struct GNUNET_PeerIdentity *second, uint32_t distance, - const struct GNUNET_CONFIGURATION_Handle *first_cfg, - const struct GNUNET_CONFIGURATION_Handle *second_cfg, - struct GNUNET_TESTING_Daemon *first_daemon, - struct GNUNET_TESTING_Daemon *second_daemon, const char *emsg) -{ - if (emsg == NULL) - { - total_connections++; - GNUNET_PEER_intern (first); - GNUNET_PEER_intern (second); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Problem with new connection (%s)\n", emsg); - } -} - - -/** - * run: load configuration options and schedule test to run (start peergroup) - * @param cls closure - * @param args argv - * @param cfgfile configuration file name (can be NULL) - * @param cfg configuration handle + * @param cls closure (NULL) + * @param ctx argument to give to GNUNET_DHT_TEST_cleanup on test end + * @param num_peers number of peers that are running + * @param peers array of peers + * @param dhts handle to each of the DHTs of the peers */ static void -run (void *cls, char *const *args, const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, + struct GNUNET_DHT_TEST_Context *ctx, + unsigned int num_peers, + struct GNUNET_TESTBED_Peer **peers, + struct GNUNET_DHT_Handle **dhts) { - char *temp_str; - struct GNUNET_TESTING_Host *hosts; - char *data_filename; - - ok = 1; - testing_cfg = GNUNET_CONFIGURATION_dup (cfg); - - GNUNET_log_setup ("test_dht_topo", - "WARNING", - NULL); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n"); - GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing", - "use_progressbars", "YES"); - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number (testing_cfg, "testing", - "num_peers", &num_peers)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Option TESTING:NUM_PEERS is required!\n"); - return; - } - - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string (testing_cfg, "testing", - "topology_output_file", - &topology_file)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Option test_dht_topo:topology_output_file is required!\n"); - return; - } - - if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string (testing_cfg, "test_dht_topo", - "data_output_file", - &data_filename)) + unsigned int i; + unsigned int j; + struct GNUNET_HashCode key; + struct GetOperation *get_op; + + GNUNET_assert (NUM_PEERS == num_peers); + my_peers = peers; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peers setup, starting test\n"); + put_task = GNUNET_SCHEDULER_add_now (&do_puts, dhts); + for (i=0;i<num_peers;i++) { - data_file = - GNUNET_DISK_file_open (data_filename, - GNUNET_DISK_OPEN_READWRITE | - GNUNET_DISK_OPEN_CREATE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (data_file == NULL) + GNUNET_CRYPTO_hash (&i, sizeof (i), &key); + for (j=0;j<num_peers;j++) { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to open %s for output!\n", - data_filename); - GNUNET_free (data_filename); + get_op = GNUNET_malloc (sizeof (struct GetOperation)); + GNUNET_CONTAINER_DLL_insert (get_head, + get_tail, + get_op); + get_op->get = GNUNET_DHT_get_start (dhts[j], + GNUNET_BLOCK_TYPE_TEST, /* type */ + &key, /*key to search */ + 4U, /* replication level */ + GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, + NULL, /* xquery */ + 0, /* xquery bits */ + &dht_get_handler, get_op); } } - - if (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_string (cfg, "test_dht_topo", - "output_file", &temp_str)) - { - output_file = - GNUNET_DISK_file_open (temp_str, - GNUNET_DISK_OPEN_READWRITE | - GNUNET_DISK_OPEN_CREATE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (output_file == NULL) - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to open %s for output!\n", - temp_str); - } - GNUNET_free_non_null (temp_str); - - hosts = GNUNET_TESTING_hosts_load (testing_cfg); - - pg = GNUNET_TESTING_peergroup_start (testing_cfg, num_peers, TIMEOUT, - &connect_cb, &peergroup_ready, NULL, - hosts); - GNUNET_assert (pg != NULL); - shutdown_handle = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, - &shutdown_task, NULL); + timeout_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, + &shutdown_task, ctx); } @@ -557,62 +406,42 @@ run (void *cls, char *const *args, const char *cfgfile, int main (int xargc, char *xargv[]) { - static struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_OPTION_END - }; - static char *const argv_torus[] = { "test-dht-2dtorus", - "-c", - "test_dht_2dtorus.conf", - NULL - }; - static char *const argv_line[] = { "test-dht-line", - "-c", - "test_dht_line.conf", - NULL - }; - char *const *argv; - int argc; + const char *cfg_filename; + const char *test_name; - if (strstr (xargv[0], "test_dht_2dtorus") != NULL) + if (NULL != strstr (xargv[0], "test_dht_2dtorus")) { - argv = argv_torus; - argc = sizeof (argv_torus) / sizeof (char *); - test_topology = TORUS; + cfg_filename = "test_dht_2dtorus.conf"; + test_name = "test-dht-2dtorus"; + NUM_PEERS = 16; } - else if (strstr (xargv[0], "test_dht_line") != NULL) + else if (NULL != strstr (xargv[0], "test_dht_line")) { - argv = argv_line; - argc = sizeof (argv_line) / sizeof (char *); - test_topology = LINE; + cfg_filename = "test_dht_line.conf"; + test_name = "test-dht-line"; + NUM_PEERS = 5; } - else + else if (NULL != strstr (xargv[0], "test_dht_twopeer")) { - GNUNET_break (0); - return 1; + cfg_filename = "test_dht_line.conf"; + test_name = "test-dht-twopeer"; + NUM_PEERS = 2; } - GNUNET_PROGRAM_run (argc - 1, argv, - xargv[0], - gettext_noop ("Test dht in different topologies."), - options, - &run, NULL); -#if REMOVE_DIR - GNUNET_DISK_directory_remove ("/tmp/test_dht_topo"); -#endif - if (0 == found_1) + else if (NULL != strstr (xargv[0], "test_dht_multipeer")) { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "ID 1 not found!\n"); + cfg_filename = "test_dht_multipeer.conf"; + test_name = "test-dht-multipeer"; + NUM_PEERS = 10; } - if (TORUS == test_topology) + else { - if (0 == found_2) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "ID 2 not found!\n"); - } - if (0 == found_far) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "ID far not found!\n"); - } + GNUNET_break (0); + return 1; } + GNUNET_DHT_TEST_run (test_name, + cfg_filename, + NUM_PEERS, + &run, NULL); return ok; } |