[GNUnet-SVN] r24440 - gnunet/src/mesh

[gnunet]

Author: szengel
Date: 2012-10-21 17:24:38 +0200 (Sun, 21 Oct 2012)
New Revision: 24440

Modified:
   gnunet/src/mesh/gnunet-regex-profiler.c
Log:
regex profiler: loading a set of search strings from a file

Modified: gnunet/src/mesh/gnunet-regex-profiler.c
===================================================================
--- gnunet/src/mesh/gnunet-regex-profiler.c     2012-10-21 08:55:24 UTC (rev 
24439)
+++ gnunet/src/mesh/gnunet-regex-profiler.c     2012-10-21 15:24:38 UTC (rev 
24440)
@@ -232,6 +232,21 @@
 static unsigned int num_links;
 
 /**
+ * Number of timeout failures to tolerate
+ */
+static unsigned int num_cont_fails;
+
+/**
+ * Number of times we try overlay connect operations
+ */
+static unsigned int retry_links;
+
+/**
+ * Continuous failures during overlay connect operations
+ */
+static unsigned int cont_fails;
+
+/**
  * Global testing status
  */
 static int result;
@@ -241,18 +256,27 @@
  */
 enum State state;
 
-
 /**
  * Folder where policy files are stored.
  */
 static char * policy_dir;
 
 /**
- * Search string.
+ * Search strings.
  */
-static char *search_string = "GNUNETVPN0001000IPEX4110010011001111001101000";
+static char **search_strings;
 
 /**
+ * Number of search strings.
+ */
+static int num_search_strings;
+
+/**
+ * Number of peers found with search strings.
+ */
+static unsigned int peers_found;
+
+/**
  * Search task identifier
  */
 static GNUNET_SCHEDULER_TaskIdentifier search_task;
@@ -262,8 +286,18 @@
  */
 static GNUNET_SCHEDULER_TaskIdentifier search_timeout_task;
 
+/**
+ * Search timeout in seconds.
+ */
+static long search_timeout_sec;
 
 /**
+ * Search wait time in minutes.
+ */
+static long search_wait_min;
+
+
+/**
  * Shutdown nicely
  *
  * @param cls NULL
@@ -274,8 +308,19 @@
 {
   struct DLLOperation *dll_op;
   unsigned int nhost;
-  int peer_cnt;
-
+  unsigned int peer_cnt;
+  unsigned int search_str_cnt;
+ 
+  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
+  {
+    if (NULL != peers[peer_cnt].op_handle)
+      GNUNET_TESTBED_operation_cancel (peers[peer_cnt].op_handle);
+  }
+  for (search_str_cnt = 0; search_str_cnt < num_search_strings; 
search_str_cnt++)
+  {
+    GNUNET_free (search_strings[search_str_cnt]);
+  }
+  GNUNET_free (search_strings);
   if (GNUNET_SCHEDULER_NO_TASK != abort_task)
     GNUNET_SCHEDULER_cancel (abort_task);
   if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
@@ -294,11 +339,6 @@
     GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
     GNUNET_free (dll_op);
   }
-  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
-  {
-    if (NULL != peers[peer_cnt].op_handle)
-      GNUNET_TESTBED_operation_cancel (peers[peer_cnt].op_handle);
-  }
   if (NULL != mc)
     GNUNET_TESTBED_controller_disconnect (mc);
   if (NULL != mc_proc)
@@ -404,12 +444,17 @@
                            const struct GNUNET_ATS_Information * atsi)
 {
   //  struct Peer *peer = (struct Peer *)cls;
+  const char * search_str = (const char *)cls;
 
-  GNUNET_SCHEDULER_cancel (search_timeout_task);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mesh peer connect handler.\n");
+  printf ("String %s successfully matched\n", search_str);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mesh peer connect handler.\n");
-  printf ("\nString successfully matched\n");
-  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+  if (++peers_found == num_search_strings)
+  {
+    printf ("\nAll strings successfully matched!\n");
+    GNUNET_SCHEDULER_cancel (search_timeout_task);
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+  }
 }
 
 
@@ -425,7 +470,8 @@
 {
   long sec = (long)cls;
 
-  printf ("Searching for string did not succeed after %ld seconds\n", sec);
+  printf ("Searching for all strings did not succeed after %ld seconds\n", 
sec);
+  printf ("Found %i of %i strings\n", peers_found, num_search_strings);
 
   GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
 }
@@ -441,21 +487,28 @@
 do_connect_by_string (void *cls,
                       const struct GNUNET_SCHEDULER_TaskContext * tc)
 {
-  printf ("Searching for string \"%s\"\n", search_string);
+  unsigned int search_cnt;
+  struct Peer *peer;
 
-  peers[0].mesh_tunnel_handle = GNUNET_MESH_tunnel_create 
(peers[0].mesh_handle,
-                                                           NULL,
-                                                           
&mesh_peer_connect_handler,
-                                                           
&mesh_peer_disconnect_handler,
-                                                           &peers[0]);
+  for (search_cnt = 0; search_cnt < num_search_strings; search_cnt++)
+  {
+    peer = &peers[search_cnt % num_peers];
 
+    printf ("Searching for string \"%s\"\n", search_strings[search_cnt]);
 
-  GNUNET_MESH_peer_request_connect_by_string (peers[0].mesh_tunnel_handle,
-                                              search_string);
+    peer->mesh_tunnel_handle = GNUNET_MESH_tunnel_create (peer->mesh_handle,
+                                                         NULL,
+                                                         
&mesh_peer_connect_handler,
+                                                         
&mesh_peer_disconnect_handler,
+                                                         
search_strings[search_cnt]);
+    GNUNET_MESH_peer_request_connect_by_string (peer->mesh_tunnel_handle,
+                                               search_strings[search_cnt]);
+      
+  }
 
   search_timeout_task = GNUNET_SCHEDULER_add_delayed 
(GNUNET_TIME_relative_multiply
-                                                     
(GNUNET_TIME_UNIT_SECONDS, 30),
-                                                     
&do_connect_by_string_timeout, (void *)(long)30);
+                                                     
(GNUNET_TIME_UNIT_SECONDS, search_timeout_sec),
+                                                     
&do_connect_by_string_timeout, (void *)search_timeout_sec);
 }
 
 
@@ -535,10 +588,10 @@
 
   if (++connected_mesh_handles == num_peers)
   {
-    printf ("\nAll mesh handles connected.\n");
+    printf ("\nAll mesh handles connected.\nWaiting to search.\n");
 
     search_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                                (GNUNET_TIME_UNIT_SECONDS, 10),
+                                                (GNUNET_TIME_UNIT_MINUTES, 
search_wait_min),
                                                 &do_connect_by_string, NULL);
   }
 }
@@ -833,8 +886,13 @@
       {
         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _("An operation has failed while linking\n"));
-        GNUNET_SCHEDULER_cancel (abort_task);
-        abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
+       retry_links++;
+       if (++cont_fails > num_cont_fails)
+       {
+         printf ("\nAborting due to very high failure rate");
+         GNUNET_SCHEDULER_cancel (abort_task);
+         abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
+       }
       }
       break;
     case GNUNET_TESTBED_ET_CONNECT:
@@ -991,7 +1049,76 @@
                                              &do_abort, NULL);
 }
 
+/**
+ * Load search strings from given filename. One search string per line.
+ *
+ * @param filename filename of the file containing the search strings.
+ * @param strings set of strings loaded from file. Caller needs to free this 
+ *                if number returned is greater than zero.
+ * @return number of strings found in the file. GNUNET_SYSERR on error.
+ */
+static int
+load_search_strings (const char *filename, char ***strings)
+{
+  char *data;
+  char *buf;
+  uint64_t filesize;
+  unsigned int offset;
+  int str_cnt;
+  unsigned int i;
 
+  if (NULL == filename)
+  {
+    return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Could not find search strings file %s\n", filename);
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &filesize, GNUNET_YES, 
GNUNET_YES))
+    filesize = 0;
+  if (0 == filesize)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Search strings file %s is 
empty.\n", filename);
+    return GNUNET_SYSERR;
+  }
+  data = GNUNET_malloc (filesize);
+  if (filesize != GNUNET_DISK_fn_read (filename, data, filesize))
+  {
+    GNUNET_free (data);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not read search strings file 
%s.\n",
+         filename);
+    return GNUNET_SYSERR;
+  }
+  buf = data;
+  offset = 0;
+  str_cnt = 0;
+  while (offset < (filesize - 1))
+  {
+    offset++;
+    if (((data[offset] == '\n')) && (buf != &data[offset]))
+    {
+      data[offset] = '\0';
+      str_cnt++;
+      buf = &data[offset + 1];
+    }
+    else if ((data[offset] == '\n') || (data[offset] == '\0'))
+      buf = &data[offset + 1];
+  }
+  *strings = GNUNET_malloc (sizeof (char *) * str_cnt);
+  offset = 0;
+  for (i = 0; i < str_cnt; i++)
+  {
+    (*strings)[i] = GNUNET_strdup (&data[offset]);
+    offset += strlen ((*strings)[i]) + 1;
+  }
+  free (data);
+  return str_cnt;
+}
+
 /**
  * Main function that will be run by the scheduler.
  *
@@ -1050,7 +1177,22 @@
     return;
   }
   policy_dir = args[1];
-
+  if (GNUNET_YES != GNUNET_DISK_file_test (args[2]))
+  {
+    fprintf (stderr, _("No search strings file given. Exiting.\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+  num_search_strings = load_search_strings (args[2], &search_strings);
+  if (0 >= num_search_strings || NULL == search_strings)
+  {
+    fprintf (stderr, _("Error loading search strings. Exiting.\n"));
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+  unsigned int i;
+  for (i = 0; i < num_search_strings; i++)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "search string: %s\n", 
search_strings[i]);
   cfg = GNUNET_CONFIGURATION_dup (config);
   mc_proc =
       GNUNET_TESTBED_controller_start (GNUNET_TESTBED_host_get_hostname
@@ -1080,6 +1222,15 @@
     { 'n', "num-links", "COUNT",
       gettext_noop ("create COUNT number of random links"),
       GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_links },
+    { 'e', "num-errors", "COUNT",
+      gettext_noop ("tolerate COUNT number of continious timeout failures"),
+      GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_cont_fails },
+    { 't', "matching-timeout", "TIMEOUT",
+      gettext_noop ("wait TIMEOUT seconds before considering a string match as 
failed"),
+      GNUNET_YES, &GNUNET_GETOPT_set_uint, &search_timeout_sec },
+    { 's', "search-wait", "WAIT",
+      gettext_noop ("wait WAIT minutes before starting string search"),
+      GNUNET_YES, &GNUNET_GETOPT_set_uint, &search_wait_min },
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
@@ -1089,7 +1240,7 @@
 
   result = GNUNET_SYSERR;
   ret =
-      GNUNET_PROGRAM_run (argc, argv, "gnunet-regex-profiler [OPTIONS] 
hosts-file policy-dir",
+      GNUNET_PROGRAM_run (argc, argv, "gnunet-regex-profiler [OPTIONS] 
hosts-file policy-dir search-strings-file",
                           _("Profiler for regex/mesh"),
                           options, &run, NULL);
   if (GNUNET_OK != ret)