X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Ftest_transport_ats.c;h=fe8b6e87b22722b78ba4bb1bb11b1f8904d06a77;hb=ecc8c4da9b35b704b62ff0dc905dcd0a61f1886a;hp=314d781728172e8ee6c67fedc9929c09f3829735;hpb=187f3ee1b6edac986b7bc46c62c86a138290b147;p=oweals%2Fgnunet.git

diff --git a/src/transport/test_transport_ats.c b/src/transport/test_transport_ats.c
index 314d78172..fe8b6e87b 100644
--- a/src/transport/test_transport_ats.c
+++ b/src/transport/test_transport_ats.c
@@ -19,726 +19,172 @@
 */
 /**
  * @file testing/test_transport_ats.c
- * @brief testcase for ats functionality
+ * @brief testcase for ats functionality without starting peers
  */
 #include "platform.h"
-#include "gnunet_testing_lib.h"
-#include "gnunet_transport_service.h"
-#include "gnunet_scheduler_lib.h"
-#include "gauger.h"
+#include "gnunet-service-transport_ats.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
 
-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES
 
-#define NUM_PEERS 11
-#define MEASUREMENTS 5
+static struct ATS_Handle * ats;
 
-#define DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
-#define SEND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+static struct GNUNET_CONFIGURATION_Handle * cfg;
 
-#define ATS_NEW 0
-#define ATS_Q_UPDATED 1
-#define ATS_C_UPDATED 2
-#define ATS_QC_UPDATED 3
-#define ATS_UNMODIFIED 4
+static struct TransportConfiguration *tc;
 
-static int ok;
 
-static int peers_left;
-
-static int failed_peers;
-
-static int measurement_started = GNUNET_NO;
-static char * config_file;
-
-static struct GNUNET_TESTING_PeerGroup *pg;
-
-static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
-static GNUNET_SCHEDULER_TaskIdentifier stats_task;
-static GNUNET_SCHEDULER_TaskIdentifier send_task;
-struct GNUNET_TESTING_Daemon * master_deamon;
-struct GNUNET_TESTING_Daemon * ping_deamon;
-
-struct GNUNET_STATISTICS_Handle * stats;
-
-struct TEST_result
+static void 
+ats_result_cb ()
 {
-  uint64_t timestamp;
-  uint64_t duration;
-  uint64_t mechs;
-  uint64_t peers;
-  uint64_t solution;
-  uint64_t state;
-};
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "ATS Result callback\n");
+}
 
-struct TestMessage
+struct TransportConfiguration
 {
-  struct GNUNET_MessageHeader header;
-  uint32_t num;
-};
-
-
-static int count;
-static int c_new;
-static int c_unmodified;
-static int c_modified;
-static int connected;
-static int peers;
+  int peers;
+  int mechanisms;
 
-static int force_q_updates;
-static int force_rebuild;
-static int send_msg;
-static int machine_parsable;
+  struct ATS_peer * p_head;
+  struct ATS_peer * p_tail;
 
-static struct TEST_result results_new       [MEASUREMENTS+1];
-static struct TEST_result results_modified  [MEASUREMENTS+1];
-static struct TEST_result results_unmodified[MEASUREMENTS+1];
-static struct TEST_result current;
+  struct ATS_mechanism * m_head;
+  struct ATS_mechanism * m_tail;
+};
 
-static struct GNUNET_STATISTICS_GetHandle * s_solution;
-static struct GNUNET_STATISTICS_GetHandle * s_time;
-static struct GNUNET_STATISTICS_GetHandle * s_peers;
-static struct GNUNET_STATISTICS_GetHandle * s_mechs;
-static struct GNUNET_STATISTICS_GetHandle * s_duration;
-static struct GNUNET_STATISTICS_GetHandle * s_invalid;
-static struct GNUNET_STATISTICS_GetHandle * s_state;
 
-struct GNUNET_TRANSPORT_TransmitHandle * t;
-struct GNUNET_TRANSPORT_Handle * th;
+static void 
+create_ats_information (struct ATS_peer **p, int * c_p,
+			struct ATS_mechanism ** m, int * c_m)
+{ 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "ATS needs addresses\n");
 
-/**
- * Check whether peers successfully shut down.
- */
-static void
-shutdown_callback (void *cls, const char *emsg)
-{
-  if (emsg != NULL)
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Shutdown of peers failed!\n");
-#endif
-      if (ok == 0)
-        ok = 666;
-    }
-  else
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers successfully shut down!\n");
-      	if (stats != NULL)
-      		GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-      	stats = NULL;
-#endif
-    }
+ (*p) = tc->p_head;
+ (*c_p) = tc->mechanisms;
+ (*m) = tc->m_head;
+ (*c_m) = tc->mechanisms;
 }
 
-static void
-shutdown_peers()
-{
-  if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(shutdown_task);
-      shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(stats_task);
-      stats_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (send_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
-  if (t != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  GNUNET_TRANSPORT_disconnect(th);  
-  if (s_time != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_time);
-      s_time = NULL;
-    }
-  if (s_peers != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_peers);
-      s_peers = NULL;
-    }
-  if (s_mechs != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_mechs);
-      s_mechs = NULL;
-    }
-  if (s_solution != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_solution);
-      s_solution = NULL;
-    }
-  if (s_duration != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_duration);
-      s_duration = NULL;
-    }
-  if (s_invalid != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_invalid);
-      s_invalid = NULL;
-    }
-  if (s_state != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_state);
-      s_state = NULL;
-    }
-  GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
-}
 
-static void 
-evaluate_measurements()
+static
+int run_ats ()
 {
-  int c;
-  //int mechs = 0;
-  double average[3];
-  double stddev[3];
-  //char * output;
-  c = 1;
-  
-  //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
-  
-  average[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      average[0] += (double) results_new[c].duration;
-    }
-  average[0] /= c_new;
-  
-  stddev[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      stddev[0] += (results_new[c].duration - average[0]) * (results_new[c].duration - average[0]);
-    }
-  stddev[0] /= c_new;
-  stddev[0] = sqrt (stddev[0]);
-  if (!machine_parsable)
-    fprintf (stderr,
-	     "new, %i measurements, average: %f stddev: %f\n",
-	     c_new, average[0], stddev[0]);
-  
-  average[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      average[1] += (double) results_modified[c].duration;
-    }
-  average[1] /= c_modified;
-  
-  stddev[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      stddev[1] += (results_modified[c].duration - average[1]) * (results_modified[c].duration - average[1]);
-    }
-  stddev[1] /= c_modified;
-  stddev[1] = sqrt (stddev[1]);
-  if (!machine_parsable) 
-    fprintf (stderr,
-	     "modified, %i measurements, average: %f stddev: %f\n",
-	     c_modified, average[1], stddev[1]);
-  
-  average[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      average[2] += (double) results_unmodified[c].duration;
-    }
-  average[2] /= c_unmodified;
-  stddev[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      stddev[2] += (results_unmodified[c].duration - average[2]) * (results_unmodified[c].duration - average[2]);
-    }
-  stddev[2] /= c_unmodified;
-  stddev[2] = sqrt (stddev[2]);
-  
-  if (!machine_parsable) 
-    fprintf (stderr,
-	     "unmodified, %i measurements, average: %f stddev: %f\n",
-	     c_unmodified, average[2], stddev[2]);
-  
-  if (machine_parsable)
-    fprintf (stderr,
-	     "peers,%i,mechs,%llu,"
-	     "new,%i,%f,%f,"
-	     "mod,%i,%f,%f,"
-	     "unmod,%i,%f,%f\n",
-	     peers-1, (unsigned long long) results_unmodified[0].mechs,
-	     c_new, average[0], stddev[0],
-	     c_modified, average[1], stddev[1],
-	     c_unmodified, average[2], stddev[2]);
-  shutdown_peers();
+  int ret = 0;
+  ats_calculate_bandwidth_distribution (ats);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Running ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+  return ret;
 }
 
 
-static int 
-stats_cb (void *cls,
-	  const char *subsystem,
-	  const char *name,
-	  uint64_t value,
-	  int is_persistent)
+static int
+init_ats ()
 {
-  static int printed = GNUNET_NO;
-  //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
-  if (0 == strcmp (name,"ATS invalid solutions"))
-    {
-      if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-	{
-	  GNUNET_SCHEDULER_cancel(stats_task);
-	  stats_task = GNUNET_SCHEDULER_NO_TASK;
-	}
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n", value);
-      shutdown_peers();
-      return GNUNET_SYSERR;
-    }
-  
-  if (0 == strcmp (name,"ATS solution"))
-    {
-      s_solution = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS peers"))
-    {
-      s_peers = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS mechanisms"))
-    {
-      s_mechs = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS duration"))
-    {
-      s_duration = NULL;
-    }
-  if (0 == strcmp (name,"ATS timestamp"))
-    {
-      s_time = NULL;
-    }
-  if (0 == strcmp (name,"ATS state"))
-    {
-      s_state = NULL;
-    }
-  
-  if ( (measurement_started == GNUNET_NO) && 
-       (0 == strcmp (name, "ATS peers")) && 
-       (value == peers-1) )
-    {
-      measurement_started = GNUNET_YES;
-      count = 1;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "All %llu peers connected\n", 
-		  value);
-#if !VERBOSE
-      if (! machine_parsable)	
-	fprintf(stderr, "%i", count);
-#endif
-    }
-  
-  if (measurement_started == GNUNET_YES)
-    {
-      // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
-      if (0 == strcmp (name,"ATS timestamp"))
-	{
-	  if (current.timestamp == 0)
-	    {
-	      printed = GNUNET_NO;
-	      current.timestamp = value;
-	    }
-	  if (current.timestamp == value)
-	    {
-	      printed = GNUNET_YES;
-	    }
-	  if (current.timestamp != value)
-	    {
-	      if (current.state == ATS_NEW)
-		{
-		  if (c_new < MEASUREMENTS)
-		    {
-		      results_new[c_new] = current;
-		      c_new++;
-		    }
-		  else
-		    {
-		      force_rebuild = GNUNET_NO;
-		      force_q_updates = GNUNET_NO;
-		      send_msg = GNUNET_NO;
-		    }
-		}
-	      if (current.state == ATS_UNMODIFIED)
-		{
-		  if (c_unmodified < MEASUREMENTS)
-		    {
-		      results_unmodified[c_unmodified] = current;
-		      c_unmodified++;
-		    }
-		  
-		}
-	      if (current.state == ATS_Q_UPDATED)
-		{
-		  if (c_modified < MEASUREMENTS)
-		    {
-		      results_modified[c_modified] = current;
-		      c_modified++;
-		    }
-		  else
-		    {
-		      force_q_updates = GNUNET_NO;
-		      force_rebuild = GNUNET_YES;
-		    }
-		}
-	      count ++;
-#if VERBOSE
-	      fprintf (stderr,
-		       "(new: %i / modified: %i / unmodified: %i) of %i \n", 
-		       c_new, c_modified, c_unmodified , MEASUREMENTS);
-#endif
-	      if ((c_modified >= MEASUREMENTS) && (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS))
-		{
-#if !VERBOSE
-		  if (!machine_parsable)
-		    fprintf(stdout, "\n");
-#endif
-		  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-		    {
-		      GNUNET_SCHEDULER_cancel(stats_task);
-		      stats_task = GNUNET_SCHEDULER_NO_TASK;
-		    }
-		  evaluate_measurements();
-		  return GNUNET_SYSERR;
-		}
-	      
-	      printed = GNUNET_NO;
-	      current.timestamp = value;
-#if !VERBOSE
-	      if (! machine_parsable)
-		fprintf(stderr, "..%i", count);
-#endif
-	      return GNUNET_OK;
-	    }
-	}
-      
-      if (0 == strcmp (name,"ATS solution"))
-	{
-	  current.solution = value;
-	  if (printed == GNUNET_NO)
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS peers"))
-	{
-	  current.peers = value;
-	  if (printed == GNUNET_NO)
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS mechanisms"))
-	{
-	  current.mechs = value;
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS duration"))
-	{
-	  current.duration = value;
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      if (0 == strcmp (name,"ATS state"))
-	{
-	  current.state = value;
-	  char * cont;
-	  if (value == ATS_NEW)
-	    cont = "NEW";
-	  if (value == ATS_C_UPDATED)
-	    cont = "C_UPDATED";
-	  if (value == ATS_Q_UPDATED)
-	    cont = "Q_UPDATED";
-	  if (value == ATS_QC_UPDATED)
-	    cont = "QC_UPDATED";
-	  if (value == ATS_UNMODIFIED)
-	    cont = "UNMODIFIED";
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-			"[%i] ATS state: %s\n", count, cont);
-	}
-    }
-  return GNUNET_OK;
-}
-
+  int ret = 0;
+  ats = ats_init(1.0, 1.0, 1.0, 50000, 5, 10, ATS_MAX_EXEC_DURATION,
+                create_ats_information,
+                ats_result_cb);
+  //GNUNET_assert (ats != NULL);
 
-static void
-stats_get_task (void *cls,
-		const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  stats_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-  
-  s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp", TIMEOUT, NULL, &stats_cb, NULL);
-  s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution", TIMEOUT, NULL, &stats_cb, NULL);
-  s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration", TIMEOUT, NULL, &stats_cb, NULL);
-  s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers", TIMEOUT, NULL, &stats_cb, NULL);
-  s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms", TIMEOUT, NULL, &stats_cb, NULL);
-  s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions", TIMEOUT, NULL, &stats_cb, NULL);
-  s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL, &stats_cb, NULL);
-  
-  stats_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
-					    &stats_get_task, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Initializing ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+  return ret;
 }
 
 
-static void
-delay (void *cls,
-       const struct GNUNET_SCHEDULER_TaskContext *tc)
+static int 
+shutdown_ats ()
 {
-  shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-	      "Delay over\n");
-#endif
-  shutdown_peers ();
+  int ret = 0;
+  ats_delete_problem (ats);
+  ats_shutdown (ats);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Shutdown ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+  return ret;
 }
 
-static void
-connect_peers()
-{
-  shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
-}
 
-static size_t 
-send_dummy_data_task (void *cls, size_t size, void *buf)
+/* To make compiler happy */
+void 
+dummy()
 {
-  int s = sizeof (struct TestMessage);
-  struct TestMessage hdr;
-  
-  hdr.header.size = htons (s);
-  hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
-  if (force_rebuild)
-    hdr.num = htonl (1);
-  if (force_q_updates)
-    hdr.num = htonl (2);
-  memcpy (buf,&hdr, s);
-  // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
-  t  = NULL;
-  return s;
+  struct ATS_quality_metric * q = qm;
+  q = NULL;
+  struct ATS_ressource * r = ressources;
+  r = NULL;
+  q++; 
+  r++;
 }
 
 
 static void 
-send_task_f (void *cls,
-	     const struct GNUNET_SCHEDULER_TaskContext *tc)
+iterate_peer_values (void *cls,
+		     const char *section,
+		     const char *option,
+		     const char *value)
 {
-  send_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-  
-  if (t!=NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i to %s\n", size, GNUNET_i2s(&master_deamon->id));
-  if (send_msg == GNUNET_YES)
-    t = GNUNET_TRANSPORT_notify_transmit_ready(th, 
-					       &master_deamon->id, 
-					       sizeof (struct TestMessage), 0, 
-					       SEND_TIMEOUT, 
-					       &send_dummy_data_task, NULL);
-  send_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000), 
-					   &send_task_f, NULL);
+  if (strcmp (option, "f") == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\t %s %s\n", option, value);
 }
 
 static void
-notify_connect (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                uint32_t ats_count)
+iterate_mech_values (void *cls,
+		     const char *section,
+		     const char *option,
+		     const char *value)
 {
-  send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
-}
-
-static void
-notify_disconnect (void *cls,
-		   const struct GNUNET_PeerIdentity *peer)
-{
-  if (GNUNET_SCHEDULER_NO_TASK != send_task)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Disconnect event before transmission request could be scheduled!\n");
-      GNUNET_SCHEDULER_cancel (send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (NULL != t)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Disconnect event before transmission request could be completed!\n");
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
-      t = NULL;
-    }
+  if (strcmp (option, "f") == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\t %s %s\n", option, value);
 }
 
 static void 
-daemon_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)
+iterate_sections (void *cls,
+		  const char *section)
 {
-  char * firstc =  strdup(GNUNET_i2s(first));
-  char * secondc =  strdup(GNUNET_i2s(second));
-  connected++;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-	      "Connected peers `%s'<->`%s' (%i/%i)\n", 
-	      firstc, secondc, connected, peers-1);
-  GNUNET_free(firstc);
-  GNUNET_free(secondc);
-  
-  if ( ( (first_daemon == ping_deamon) || 
-	 (second_daemon == ping_deamon) ) && 
-       (master_deamon != NULL) && 
-       (ping_deamon != NULL) )
+  struct TransportConfiguration * tc = cls;
+  /* Peer definition */
+  if (99 == strlen(section))
     {
-      th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
-				     &ping_deamon->id, 
-				     NULL, NULL,
-				     &notify_connect, 
-				     &notify_disconnect);
-      force_q_updates = GNUNET_YES;
-      send_msg = GNUNET_YES;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer '%s`\n", section);
+      GNUNET_HashCode h;
+      int res =GNUNET_CRYPTO_hash_from_string(section, &h);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "HASH '%s` %i\n", GNUNET_h2s (&h), res);
+      GNUNET_CONFIGURATION_iterate_section_values(cfg, section, iterate_peer_values, NULL);
+      tc->peers++;
     }
-}
-
-
-
-static void
-daemon_start_cb (void *cls,
-		 const struct GNUNET_PeerIdentity *id,
-		 const struct GNUNET_CONFIGURATION_Handle *cfg,
-		 struct GNUNET_TESTING_Daemon *d, const char *emsg)
-{
-  if (id == NULL)
+  if (10 == strlen(section))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Start callback called with error (too long starting peers), aborting test!\n");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Error from testing: `%s'\n");
-      failed_peers++;
-      if (failed_peers == peers_left)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Too many peers failed, ending test!\n");
-          ok = 1;
-      	shutdown_peers ();
-        }
-      return;
-    }
-  peers_left--;
-
-  if (master_deamon == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Master peer `%s' '%s'\n",
-		  GNUNET_i2s(id), d->cfgfile);      
-      master_deamon = d;
-      stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
-      GNUNET_assert (stats != NULL);
-      stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
-    }
-  else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Connecting peer `%s'\n", 
-		  GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
-      GNUNET_TESTING_daemons_connect(d, master_deamon, TIMEOUT, 0, GNUNET_YES,&daemon_connect_cb, NULL);
-    }
-  
-  if (peers_left == 0)
-    {
-      if (ping_deamon == NULL)
-	{
-	  ping_deamon = d;
-	  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		      "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
-	}
-      
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers started successfully!\n");
-      connect_peers();
-      ok = 0;
-    }
-  else if (failed_peers == peers_left)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Too many peers failed, ending test!\n");
-      shutdown_peers();
-      ok = 1;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Mechanism '%s`\n",section);
+      GNUNET_CONFIGURATION_iterate_section_values(cfg, section, iterate_mech_values, NULL);
+      tc->peers++;
     }
 }
 
 
-static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+static struct TransportConfiguration * 
+load_transport_configuration (char * filename)
 {
-  ok = 1;
-  measurement_started = GNUNET_NO;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
-#endif
-  peers_left = peers;
-  pg = GNUNET_TESTING_daemons_start (cfg,
-                                     peers_left, /* Total number of peers */
-                                     peers_left, /* Number of outstanding connections */
-                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
-                                     TIMEOUT,
-                                     NULL, NULL,
-                                     &daemon_start_cb, NULL, NULL, NULL, NULL);
-  GNUNET_assert (pg != NULL);
-}
+  struct TransportConfiguration * ret = GNUNET_malloc(sizeof (struct TransportConfiguration));
 
-
-static int
-check ()
-{
-  char *const argv[] = { "test-testing",
-    "-c",
-    config_file,
-#if VERBOSE
-    "-L", "DEBUG",
-#endif
-    NULL
-  };
-  struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
-  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-ats", "nohelp",
-                      options, &run, &ok);
-  return ok;
+  cfg = GNUNET_CONFIGURATION_create();
+  GNUNET_assert (GNUNET_OK ==
+		 GNUNET_CONFIGURATION_load(cfg, filename));
+  GNUNET_CONFIGURATION_iterate_sections (cfg, iterate_sections, ret);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  cfg = NULL;
+  return ret;
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  int ret;
+  int ret = 0;
 
   GNUNET_log_setup ("test-transport-ats",
 #if VERBOSE
@@ -747,53 +193,13 @@ main (int argc, char *argv[])
                     "INFO",
 #endif
                     NULL);
-
-#if !HAVE_LIBGLPK
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-	      "GLPK not installed, exiting testcase\n");
-  return 0;
-#endif
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
-  machine_parsable = GNUNET_NO;
-  peers = NUM_PEERS;
-  config_file = "test_transport_ats_4addr.conf";
-
-  int c = 0;
-  if (argc >= 2)
-    {
-      for (c=0; c<argc; c++)
-	{
-	  /* set peers */
-	  if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
-	    {
-	      peers = atoi(argv[c+1]);
-	      peers++;
-	    }
-	  /* set machine parsable */
-	  if (strcmp(argv[c], "-m") == 0)
-	    {
-	      machine_parsable = GNUNET_YES;
-	    }
-	  /* set config file */
-	  if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
-	    {
-	      config_file = argv[c+1];
-	    }
-	 }
-    }
-
-
-
-  ret = check ();
-  /**
-   * Still need to remove the base testing directory here,
-   * because group starts will create subdirectories under this
-   * main dir.  However, we no longer need to sleep, as the
-   * shutdown sequence won't return until everything is cleaned
-   * up.
-   */
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
+  tc = load_transport_configuration ("test.ats");
+  ats = NULL;
+  ret += init_ats ();
+  ret += run_ats ();
+  ret += shutdown_ats ();
   return ret;
+
 }
 
 /* end of test_transport_ats.c*/