Imported Upstream version 0.9.5a

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;
 }