X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fdht%2Ftest_dht_monitor.c;h=0212c900b6a95047461402134f78a8c92a0894fe;hb=3b680a20ab2cbb98cfa658d85be7a44baaf95d2c;hp=e456ede876fe10647d1f19cce5c732c069fba944;hpb=84911487a06ec47e58c8b02e1b617805e20613e9;p=oweals%2Fgnunet.git diff --git a/src/dht/test_dht_monitor.c b/src/dht/test_dht_monitor.c index e456ede87..0212c900b 100644 --- a/src/dht/test_dht_monitor.c +++ b/src/dht/test_dht_monitor.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2011 Christian Grothoff (and other contributing authors) + Copyright (C) 2011, 2012 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -14,579 +14,401 @@ You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /** * @file dht/test_dht_monitor.c - * - * @brief Test for the dht service: store, retrieve and monitor in a 2d_torus. - * TODO: update this description - * 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. + * @brief Test for the dht monitoring API; checks that we receive "some" monitor events + * @author Christian Grothoff */ #include "platform.h" -#include "gnunet_testing_lib.h" +#include "gnunet_testbed_service.h" #include "gnunet_dht_service.h" - -#define VERBOSE GNUNET_YES - -#define REMOVE_DIR GNUNET_YES +#include "dht_test_lib.h" /** - * How long until we give up on connecting the peers? + * How long do we run the test at most? */ -#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1500) - -#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) +#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300) +/** + * How often do we run the PUTs? + */ #define PUT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10) -static int ok; /** - * Be verbose + * Information we keep for each GET operation. */ -static int verbose; +struct GetOperation +{ + /** + * DLL. + */ + struct GetOperation *next; -/** - * Total number of peers in the test. - */ -static unsigned long long num_peers; + /** + * DLL. + */ + struct GetOperation *prev; -/** - * Global configuration file - */ -static struct GNUNET_CONFIGURATION_Handle *testing_cfg; + /** + * Handle for the operation. + */ + struct GNUNET_DHT_GetHandle *get; -/** - * Total number of currently running peers. - */ -static unsigned long long peers_running; +}; -/** - * Total number of connections in the whole network. - */ -static unsigned int total_connections; /** - * The currently running peer group. + * Return value from 'main'. */ -static struct GNUNET_TESTING_PeerGroup *pg; +static int ok; /** - * File to report results to. + * Head of list of active GET operations. */ -static struct GNUNET_DISK_FileHandle *output_file; +static struct GetOperation *get_head; /** - * File to log connection info, statistics to. + * Tail of list of active GET operations. */ -static struct GNUNET_DISK_FileHandle *data_file; +static struct GetOperation *get_tail; /** - * Task called to disconnect peers. + * Array of the testbed's peers. */ -static GNUNET_SCHEDULER_TaskIdentifier disconnect_task; +static struct GNUNET_TESTBED_Peer **my_peers; /** - * Task To perform tests + * Number of peers to run. */ -static GNUNET_SCHEDULER_TaskIdentifier test_task; +static unsigned int NUM_PEERS = 3; /** - * Task to do DHT_puts + * Task called to disconnect peers. */ -static GNUNET_SCHEDULER_TaskIdentifier put_task; +static struct GNUNET_SCHEDULER_Task * timeout_task; /** - * Task called to shutdown test. + * Task to do DHT_puts */ -static GNUNET_SCHEDULER_TaskIdentifier shutdown_handle; - -static char *topology_file; - -struct GNUNET_TESTING_Daemon *d1; - -struct GNUNET_TESTING_Daemon *d2; - -struct GNUNET_DHT_Handle **hs; +static struct GNUNET_SCHEDULER_Task * put_task; -struct GNUNET_DHT_MonitorHandle **mhs; +static struct GNUNET_DHT_MonitorHandle **monitors; -struct GNUNET_DHT_GetHandle *get_h_far; +static unsigned int monitor_counter; -const char *id_origin = "FC74"; -const char *id_far = "KPST"; - -unsigned int i_origin; -unsigned int i_far; - -struct GNUNET_TESTING_Daemon *d_far; -struct GNUNET_TESTING_Daemon *o; - -unsigned int monitor_counter; - -int in_test; /** - * Check whether peers successfully shut down. + * 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' */ static void -shutdown_callback (void *cls, const char *emsg) +shutdown_task (void *cls) { - if (emsg != NULL) - { -#if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Shutdown of peers failed!\n"); -#endif - ok++; - } - else + struct GNUNET_DHT_TEST_Context *ctx = cls; + unsigned int i; + struct GetOperation *get_op; + + ok = (monitor_counter > NUM_PEERS) ? 0 : 2; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Received %u monitor events\n", + monitor_counter); + while (NULL != (get_op = get_tail)) { -#if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "test: All peers successfully shut down!\n"); -#endif + GNUNET_DHT_get_stop (get_op->get); + GNUNET_CONTAINER_DLL_remove (get_head, + get_tail, + get_op); + GNUNET_free (get_op); } + for (i=0;iget); + 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; + ctx = GNUNET_SCHEDULER_cancel (timeout_task); + timeout_task = GNUNET_SCHEDULER_add_now (&shutdown_task, ctx); } + +/** + * Task to put the id of each peer into the DHT. + * + * @param cls array with NUM_PEERS DHT handles + */ 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) +do_puts (void *cls) { - int i; + struct GNUNET_DHT_Handle **hs = cls; + struct GNUNET_HashCode key; + struct GNUNET_HashCode value; + unsigned int i; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "test: ************* FOUND!!! ***********\n"); - if (sizeof (GNUNET_HashCode) == size) - { - const GNUNET_HashCode *h = data; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Contents: %s\n", - GNUNET_h2s_full (h)); - - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: PATH: (get %u, put %u)\n", - get_path_length, put_path_length); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: LOCAL\n"); - for (i = get_path_length - 1; i >= 0; i--) + "Putting values into DHT\n"); + for (i = 0; i < NUM_PEERS; i++) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: %s\n", - GNUNET_i2s (&get_path[i])); + 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 (value), &value, + GNUNET_TIME_UNIT_FOREVER_ABS, + GNUNET_TIME_UNIT_FOREVER_REL, + NULL, NULL); } - for (i = put_path_length - 1; i >= 0; i--) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: %s\n", - GNUNET_i2s (&put_path[i])); - } - if (monitor_counter >= get_path_length + put_path_length) - { - ok = 0; - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "expected at least %u hops, got %u\n", - get_path_length + put_path_length, monitor_counter); - } - else - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "expected at least %u hops, got %u\n", - get_path_length + put_path_length, monitor_counter); - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_peers, NULL); -} - -static void -do_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - in_test = GNUNET_YES; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: test_task\n"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: looking for %s\n", - GNUNET_h2s_full (&d_far->id.hashPubKey)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: from %s\n", - GNUNET_h2s_full (&o->id.hashPubKey)); - get_h_far = GNUNET_DHT_get_start (hs[i_origin], GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */ - 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, NULL); - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = - GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &disconnect_peers, NULL); + put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, + &do_puts, hs); } -static void -put_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) -{ - struct GNUNET_TESTING_Daemon *d; - - d = GNUNET_TESTING_daemon_get (pg, i_far); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: putting into DHT: %s\n", - GNUNET_h2s_full (&d->id.hashPubKey)); - GNUNET_DHT_put (hs[i_far], &d->id.hashPubKey, 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); - - put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY, &put_id, NULL); -} - /** - * Callback called on each request going through the DHT. + * Callback called on each GET request going through the DHT. + * Prints the info about the intercepted packet and increments a counter. * * @param cls Closure. - * @param mtype Type of the DHT message monitored. - * @param exp When will this value expire. - * @param key Key of the result/request. - * @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 options Options, for instance RecordRoute, DemultiplexEverywhere. + * @param type The type of data in the request. + * @param hop_count Hop count so far. + * @param path_length number of entries in path (or 0 if not recorded). + * @param path peers on the GET path (or NULL if not recorded). * @param desired_replication_level Desired replication level. - * @param type Type of the result/request. - * @param data Pointer to the result data. - * @param size Number of bytes in data. + * @param key Key of the requested data. */ -void -monitor_dht_cb (void *cls, - uint16_t mtype, - 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, - uint32_t desired_replication_level, +static void +monitor_get_cb (void *cls, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, - const void *data, - size_t size) + uint32_t hop_count, + uint32_t desired_replication_level, + unsigned int path_length, + const struct GNUNET_PeerIdentity *path, + const struct GNUNET_HashCode * key) { - const char *s_key; - - s_key = GNUNET_h2s(key); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%u got a message of type %u for key %s\n", - cls, mtype, s_key); + unsigned int i; - if ((mtype == GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET || - mtype == GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT) && - strncmp (s_key, id_far, 4) == 0 && in_test == GNUNET_YES) - monitor_counter++; + i = (unsigned int) (long) cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "%u got a GET message for key %s\n", + i, + GNUNET_h2s (key)); + monitor_counter++; } /** - * peergroup_ready: start test when all peers are connected - * @param cls closure - * @param emsg error message + * Callback called on each PUT request going through the DHT. + * Prints the info about the intercepted packet and increments a counter. + * + * @param cls Closure. + * @param options Options, for instance RecordRoute, DemultiplexEverywhere. + * @param type The type of data in the request. + * @param hop_count Hop count so far. + * @param path_length number of entries in path (or 0 if not recorded). + * @param path peers on the PUT path (or NULL if not recorded). + * @param desired_replication_level Desired replication level. + * @param exp Expiration time of the data. + * @param key Key under which data is to be stored. + * @param data Pointer to the data carried. + * @param size Number of bytes in data. */ static void -peergroup_ready (void *cls, const char *emsg) +monitor_put_cb (void *cls, + enum GNUNET_DHT_RouteOption options, + enum GNUNET_BLOCK_Type type, + uint32_t hop_count, + uint32_t desired_replication_level, + unsigned int path_length, + const struct GNUNET_PeerIdentity *path, + struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode * key, + const void *data, + size_t size) { - struct GNUNET_TESTING_Daemon *d; - char *buf; - const char *id_aux; - int buf_len; unsigned int i; - if (emsg != NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "test: Peergroup callback called with error, aborting test!\n"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Error from testing: `%s'\n", - emsg); - ok++; - GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); - return; - } -#if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "************************************************************\n"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "test: Peer Group started successfully!\n"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Have %u connections\n", - total_connections); -#endif - - 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 *)); - mhs = GNUNET_malloc (num_peers * sizeof (struct GNUNET_DHT_MonitorHandle *)); - d_far = o = NULL; - for (i = 0; i < num_peers; i++) - { - d = GNUNET_TESTING_daemon_get (pg, i); - hs[i] = GNUNET_DHT_connect (d->cfg, 32); - mhs[i] = GNUNET_DHT_monitor_start(hs[i], GNUNET_BLOCK_TYPE_ANY, NULL, - &monitor_dht_cb, (void *)(long)i); - id_aux = GNUNET_i2s (&d->id); - if (strcmp (id_aux, id_origin) == 0) - { - o = d; - i_origin = i; - } - if (strcmp (id_aux, id_far) == 0) - { - i_far = i; - d_far = d; - } - } - - if ((NULL == o) || (NULL == d_far)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "test: Peers not found (hostkey file changed?)\n"); - GNUNET_SCHEDULER_cancel (disconnect_task); - disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_peers, NULL); - return; - } - monitor_counter = 0; - put_task = GNUNET_SCHEDULER_add_now (&put_id, NULL); - test_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_SECONDS, 2), &do_test, - NULL); - disconnect_task = - GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &disconnect_peers, NULL); - + i = (unsigned int) (long) cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "%u got a PUT message for key %s with %u bytes\n", + i, + GNUNET_h2s (key), + (unsigned int) size); + monitor_counter++; } /** - * Function that will be called whenever two daemons are connected by - * the testing library. + * Callback called on each GET reply going through the DHT. + * Prints the info about the intercepted packet and increments a counter. * - * @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) + * @param cls Closure. + * @param type The type of data in the result. + * @param get_path Peers on GET 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 exp Expiration time of the data. + * @param key Key of the data. + * @param data Pointer to the result data. + * @param size Number of bytes in data. */ 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) +monitor_res_cb (void *cls, + enum GNUNET_BLOCK_Type type, + const struct GNUNET_PeerIdentity *get_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int put_path_length, + struct GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode * key, + const void *data, + size_t size) { + unsigned int i; - if (emsg == NULL) - { - total_connections++; - GNUNET_PEER_intern (first); - GNUNET_PEER_intern (second); - } - else - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "test: Problem with new connection (%s)\n", emsg); - } - + i = (unsigned int) (long) cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "%u got a REPLY message for key %s with %u bytes\n", + i, + GNUNET_h2s (key), + (unsigned int) size); + monitor_counter++; } /** - * 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 + * Main function of the test. + * + * @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_monitor", -#if VERBOSE - "DEBUG", -#else - "WARNING", -#endif - NULL); - -#if VERBOSE - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Starting daemons.\n"); - GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing", - "use_progressbars", "YES"); -#endif - - 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_2d:topology_output_file is required!\n"); - return; - } + unsigned int i; + unsigned int j; + struct GNUNET_HashCode key; + struct GetOperation *get_op; - if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string (testing_cfg, "test_dht_2dtorus", - "data_output_file", - &data_filename)) + GNUNET_assert (NUM_PEERS == num_peers); + my_peers = peers; + monitors = GNUNET_malloc (num_peers * sizeof (struct GNUNET_DHT_MonitorHandle *)); + for (i = 0; i < num_peers; i++) + monitors[i] = GNUNET_DHT_monitor_start (dhts[i], + GNUNET_BLOCK_TYPE_ANY, + NULL, + &monitor_get_cb, + &monitor_res_cb, + &monitor_put_cb, + (void *)(long)i); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Peers setup, starting test\n"); + put_task = GNUNET_SCHEDULER_add_now (&do_puts, dhts); + for (i=0;iget = GNUNET_DHT_get_start (dhts[j], + GNUNET_BLOCK_TYPE_TEST, /* type */ + &key, /*key to search */ + 4U, /* replication level */ + 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_2dtorus", - "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 (TIMEOUT, + &shutdown_task, ctx); } - -/** - * test_dht_monitor command line options - */ -static struct GNUNET_GETOPT_CommandLineOption options[] = { - {'V', "verbose", NULL, - gettext_noop ("be verbose (print progress information)"), - 0, &GNUNET_GETOPT_set_one, &verbose}, - GNUNET_GETOPT_OPTION_END -}; - - /** * Main: start test */ int main (int xargc, char *xargv[]) { - char *const argv[] = { "test-dht-monitor", - "-c", - "test_dht_2dtorus.conf", // reuse 2dtorus conf file -#if VERBOSE - "-L", "DEBUG", -#endif - NULL - }; - - in_test = GNUNET_NO; - GNUNET_PROGRAM_run (sizeof (argv) / sizeof (char *) - 1, argv, - "test_dht_monitor", - gettext_noop ("Test dht monitoring in a small 2D torus."), - options, &run, NULL); -#if REMOVE_DIR - GNUNET_DISK_directory_remove ("/tmp/test_dht_monitor"); -#endif - if (0 != ok) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: FAILED!\n"); - } + GNUNET_DHT_TEST_run ("test-dht-monitor", + "test_dht_monitor.conf", + NUM_PEERS, + &run, NULL); return ok; } + /* end of test_dht_monitor.c */