stuff

[oweals/gnunet.git] / src / transport / test_transport_ats.c

diff --git a/src/transport/test_transport_ats.c b/src/transport/test_transport_ats.c
index 41d1ff0d60ebdf96b61dc5703b9324bf725b58b6..bf7bc0fe5ab43a5cb4986e5ed8c1b6e612bdfe45 100644 (file)
--- a/src/transport/test_transport_ats.c
+++ b/src/transport/test_transport_ats.c
@@ -22,49 +22,165 @@
  * @brief testcase for ats functionality without starting peers
  */
 #include "platform.h"
-#include "transport_ats.h"
+#include "gnunet-service-transport_ats.h"
 #include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
 
 #define VERBOSE GNUNET_YES
 
-struct GNUNET_CONFIGURATION_Handle *cfg;
-
 static struct ATS_Handle * ats;
 
+static struct GNUNET_CONFIGURATION_Handle * cfg;
+
+static struct TransportConfiguration *tc;
+
+
+static void 
+ats_result_cb ()
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "ATS Result callback\n");
+}
+
+struct TransportConfiguration
+{
+  int peers;
+  int mechanisms;
+
+  struct ATS_peer * p_head;
+  struct ATS_peer * p_tail;
+
+  struct ATS_mechanism * m_head;
+  struct ATS_mechanism * m_tail;
+};
+
+
+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");
+
+ (*p) = tc->p_head;
+ (*c_p) = tc->mechanisms;
+ (*m) = tc->m_head;
+ (*c_m) = tc->mechanisms;
+}
+
 
-int init_ats (void)
+static
+int run_ats ()
 {
   int ret = 0;
+  ats_calculate_bandwidth_distribution (ats);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Running ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
+  return ret;
+}
+
 
-  //ats = ats_init(cfg);
+static int
+init_ats ()
+{
+  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);
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Initializing ATS: %s \n", (ret==0)? "SUCCESFULL": "FAILED");
+              "Initializing ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
   return ret;
 }
 
 
-int shutdown_ats (void)
+static int 
+shutdown_ats ()
 {
   int ret = 0;
-
-  //ats_delete_problem (ats);
-  //ats_shutdown (ats);
+  ats_delete_problem (ats);
+  ats_shutdown (ats);
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Shutdown ATS: %s \n", (ret==0)? "SUCCESFULL": "FAILED");
+              "Shutdown ATS: %s \n", (ret==0)? "SUCCESSFUL": "FAILED");
   return ret;
 }
 
+
 /* To make compiler happy */
-void dummy(void)
+void 
+dummy()
 {
   struct ATS_quality_metric * q = qm;
   q = NULL;
   struct ATS_ressource * r = ressources;
   r = NULL;
+  q++; 
+  r++;
 }
 
+
+static void 
+iterate_peer_values (void *cls,
+                    const char *section,
+                    const char *option,
+                    const char *value)
+{
+  if (strcmp (option, "f") == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\t %s %s\n", option, value);
+}
+
+static void
+iterate_mech_values (void *cls,
+                    const char *section,
+                    const char *option,
+                    const char *value)
+{
+  if (strcmp (option, "f") == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "\t %s %s\n", option, value);
+}
+
+static void 
+iterate_sections (void *cls,
+                 const char *section)
+{
+  struct TransportConfiguration * tc = cls;
+  /* Peer definition */
+  if (99 == strlen(section))
+    {
+      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++;
+    }
+  if (10 == strlen(section))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Mechanism '%s`\n",section);
+      GNUNET_CONFIGURATION_iterate_section_values(cfg, section, iterate_mech_values, NULL);
+      tc->peers++;
+    }
+}
+
+
+static struct TransportConfiguration * 
+load_transport_configuration (char * filename)
+{
+  struct TransportConfiguration * ret = GNUNET_malloc(sizeof (struct TransportConfiguration));
+
+  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[])
 {
@@ -77,26 +193,11 @@ main (int argc, char *argv[])
                     "INFO",
 #endif
                     NULL);
-#if !HAVE_LIBGLPK
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "HAVE_LIBGLPK not set, exiting testcase\n");
-#endif
-
-#if !HAVE_LIBGLPK
-  return ret;
-#endif
-
-
-  cfg = GNUNET_CONFIGURATION_create();
-  GNUNET_CONFIGURATION_load(cfg, "test_transport_ats_1addr.conf");
-
-  /* Testing */
+  tc = load_transport_configuration ("test_transport_ats.data");
   ats = NULL;
   ret += init_ats ();
+  ret += run_ats ();
   ret += shutdown_ats ();
-
-  /* Shutdown */
-  GNUNET_CONFIGURATION_destroy(cfg);
   return ret;
 
 }