working on fs, bugfixes

1 files changed, 212 insertions, 27 deletions

diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index ea9e00c90..6014e4394 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -22,21 +22,38 @@
  * @file fs/test_fs_namespace.c
  * @brief Test for fs_namespace.c
  * @author Christian Grothoff
+ *
+ * TODO:
+ * - add timeout task
  */
-
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_arm_service.h"
 #include "gnunet_fs_service.h"
 
+#define VERBOSE GNUNET_YES
+
 #define START_ARM GNUNET_YES
 
 static struct GNUNET_SCHEDULER_Handle *sched;
 
 static struct PeerContext p1;
 
+static GNUNET_HashCode nsid;
+
+static struct GNUNET_FS_Uri *sks_expect_uri;
+
+static struct GNUNET_FS_Uri *ksk_expect_uri;
+
 static struct GNUNET_FS_Handle *fs;
 
+static struct GNUNET_FS_SearchContext *sks_search;
+
+static struct GNUNET_FS_SearchContext *ksk_search;
+
+static int update_started;
+
+static int err;
 
 struct PeerContext
 {
@@ -79,21 +96,131 @@ stop_arm (struct PeerContext *p)
 }
 
 
-#if 0
 static void
-spcb (void *cls,
-      const char *name,
-      const GNUNET_HashCode * key)
+abort_ksk_search_task (void *cls,
+                       const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
+  if (ksk_search != NULL)
+    {
+      GNUNET_FS_search_stop (ksk_search);
+      ksk_search = NULL;
+      if (sks_search == NULL)
+        GNUNET_FS_stop (fs);
+    }
 }
-#endif
 
 
+static void
+abort_sks_search_task (void *cls,
+                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_FS_Namespace *ns;
+
+  if (sks_search != NULL)
+    {
+      GNUNET_FS_search_stop (sks_search);
+      sks_search = NULL;
+      ns = GNUNET_FS_namespace_create (fs,
+                                       "testNamespace");
+      GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES));
+      if (ksk_search == NULL)
+        GNUNET_FS_stop (fs);
+    }
+}
+
 
 static void *
 progress_cb (void *cls, 
              const struct GNUNET_FS_ProgressInfo *event)
 {
+  switch (event->status)
+    {
+    case GNUNET_FS_STATUS_SEARCH_RESULT:
+      if (sks_search == event->value.search.sc)
+        {
+          fprintf (stderr,
+                   "Search result for sks received\n");
+          if (! GNUNET_FS_uri_test_equal (sks_expect_uri,
+                                          event->value.search.specifics.result.uri))
+            {
+              fprintf (stderr,
+                       "Wrong result for sks search!\n");
+              err = 1;
+            }
+          /* give system 1ms to initiate update search! */
+          GNUNET_SCHEDULER_add_delayed (sched,
+                                        GNUNET_TIME_UNIT_MILLISECONDS,
+                                        &abort_sks_search_task,
+                                        NULL);
+        }
+      else if (ksk_search == event->value.search.sc)
+        {
+          fprintf (stderr,
+                   "Search result for ksk received\n");
+          if (! GNUNET_FS_uri_test_equal (ksk_expect_uri,
+                                          event->value.search.specifics.result.uri))
+            {
+              fprintf (stderr,
+                       "Wrong result for ksk search!\n");
+              err = 1;
+            }
+          GNUNET_SCHEDULER_add_continuation (sched,
+                                             &abort_ksk_search_task,
+                                             NULL,
+                                             GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+        }
+      else 
+        {
+          fprintf (stderr,
+                   "Search result received!?\n");
+          GNUNET_break (0);
+        }
+      break;
+    case GNUNET_FS_STATUS_SEARCH_ERROR:
+      fprintf (stderr,
+               "Error searching file: %s\n",
+               event->value.search.specifics.error.message);
+      if (sks_search == event->value.search.sc)
+        GNUNET_SCHEDULER_add_continuation (sched,
+                                           &abort_sks_search_task,
+                                           NULL,
+                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+      else if (ksk_search == event->value.search.sc)
+        GNUNET_SCHEDULER_add_continuation (sched,
+                                           &abort_ksk_search_task,
+                                           NULL,
+                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+      else
+        GNUNET_break (0);
+      break;
+    case GNUNET_FS_STATUS_SEARCH_START:
+      fprintf (stderr,
+               "Search start event for `%s' received\n",
+               (const char*) event->value.search.cctx);
+      GNUNET_assert ( (NULL == event->value.search.cctx) ||
+                      (0 == strcmp ("sks_search", event->value.search.cctx)) ||
+                      (0 == strcmp ("ksk_search", event->value.search.cctx)));
+      if (NULL == event->value.search.cctx)
+        {
+          GNUNET_assert (sks_search == event->value.search.pctx);
+          update_started = GNUNET_YES;
+        }
+      GNUNET_assert (1 == event->value.search.anonymity);
+      break;
+    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+      break;
+    case GNUNET_FS_STATUS_SEARCH_STOPPED:
+      fprintf (stderr,
+               "Search stop event received\n");
+      GNUNET_assert ( (ksk_search == event->value.search.sc) ||
+                      (sks_search == event->value.search.sc));
+      break;
+    default:
+      fprintf (stderr,
+               "Unexpected event: %d\n", 
+               event->status);
+      break;
+    }
   return NULL;
 }
 
@@ -103,11 +230,39 @@ publish_cont (void *cls,
               const struct GNUNET_FS_Uri *ksk_uri,
               const char *emsg)
 {
-  struct GNUNET_FS_SearchContext *search;
-
-  GNUNET_assert (NULL == emsg);
+  char *msg;
+  struct GNUNET_FS_Uri *sks_uri;
+  char sbuf[1024];
+  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
+  
+  if (NULL != emsg)
+    {
+      fprintf (stderr, "Error publishing: %s\n", emsg);
+      err = 1;
+      GNUNET_FS_stop (fs);
+      return;
+    }  
+  GNUNET_CRYPTO_hash_to_enc (&nsid,
+                             &enc);
+  GNUNET_snprintf (sbuf,
+                   sizeof (sbuf),
+                   "gnunet://fs/sks/%s/this",
+                   &enc);
+  sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
+  if (msg != NULL)
+    {
+      fprintf (stderr, "failed to parse URI `%s': %s\n",
+               sbuf,
+               msg);
+      err = 1;
+      GNUNET_FS_stop (fs);
+      return;
+    }
   fprintf (stderr, "Starting keyword search...\n");
-  search = GNUNET_FS_search_start (fs, ksk_uri, 1, NULL);
+  ksk_search = GNUNET_FS_search_start (fs, ksk_uri, 1, "ksk_search");
+  fprintf (stderr, "Starting namespace search...\n") ;
+  sks_search = GNUNET_FS_search_start (fs, sks_uri, 1, "sks_search");
+  GNUNET_FS_uri_destroy (sks_uri);
 }
 
 
@@ -127,6 +282,7 @@ sks_cont (void *cls,
   ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
   GNUNET_assert (NULL == msg);
   fprintf (stderr, "Advertising update 'this' namespace entry under keyword...\n");
+  ksk_expect_uri = GNUNET_FS_uri_dup (uri);
   GNUNET_FS_publish_ksk (fs,
                          ksk_uri,
                          meta,
@@ -136,6 +292,7 @@ sks_cont (void *cls,
                          GNUNET_FS_PUBLISH_OPTION_NONE,
                          &publish_cont,
                          NULL);
+  GNUNET_FS_uri_destroy (ksk_uri);
   GNUNET_CONTAINER_meta_data_destroy (meta);
 }
 
@@ -149,18 +306,26 @@ adv_cont (void *cls,
   struct GNUNET_FS_Namespace *ns;
   struct GNUNET_TIME_Absolute expiration;
 
+  if (NULL != emsg)
+    {
+      fprintf (stderr, "Error publishing: %s\n", emsg);
+      err = 1;
+      GNUNET_FS_stop (fs);
+      return;
+    }
   expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
   ns = GNUNET_FS_namespace_create (fs,
                                    "testNamespace");
   meta = GNUNET_CONTAINER_meta_data_create ();
   GNUNET_assert (NULL == emsg);
   fprintf (stderr, "Advertising update 'this->next' namespace update...\n");
+  sks_expect_uri = GNUNET_FS_uri_dup (uri);
   GNUNET_FS_publish_sks (fs,
                          ns,
                          "this",
                          "next",
                          meta,
-                         uri, /* FIXME: this is non-sense (use CHK URI!) */
+                         uri, /* FIXME: this is non-sense (use CHK URI!?) */
                          expiration,
                          1, 1,
                          GNUNET_FS_PUBLISH_OPTION_NONE,
@@ -172,17 +337,43 @@ adv_cont (void *cls,
 
 
 static void
+ns_iterator (void *cls,
+             const char *name,
+             const GNUNET_HashCode *id)
+{
+  int *ok = cls;
+
+  if (0 != strcmp (name,
+                   "testNamespace"))
+    return;
+  *ok = GNUNET_YES;
+  nsid = *id;
+}
+
+
+static void
 testNamespace ()
 {
   struct GNUNET_FS_Namespace *ns;
   struct GNUNET_TIME_Absolute expiration;
   struct GNUNET_CONTAINER_MetaData *meta;
+  int ok;
 
-  expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
-  meta = GNUNET_CONTAINER_meta_data_create ();
   ns = GNUNET_FS_namespace_create (fs,
                                    "testNamespace");
+  ok = GNUNET_NO;
+  GNUNET_FS_namespace_list (fs, &ns_iterator, &ok);
+  if (GNUNET_NO == ok)
+    {
+      fprintf (stderr, "namespace_list failed to find namespace!\n");
+      GNUNET_FS_namespace_delete (ns, GNUNET_YES);
+      GNUNET_FS_stop (fs);
+      err = 1;
+      return;
+    }
   fprintf (stderr, "Advertising namespace root...\n");
+  expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  meta = GNUNET_CONTAINER_meta_data_create ();
   GNUNET_FS_namespace_advertise (fs,
                                  ns,
                                  meta,
@@ -194,17 +385,6 @@ testNamespace ()
   GNUNET_CONTAINER_meta_data_destroy (meta);
 }
 
-#if 0
-  fprintf (stderr, "Completed namespace search...\n");
-  GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (NULL, cfg, &pid));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_FS_namespace_delete (NULL, cfg, &pid));
-  GNUNET_FS_uri_destroy (rootURI);
-  GNUNET_FS_uri_destroy (advURI);
-  GNUNET_assert (match == 1);
-  return 0;
-}
-#endif
-
 
 static void
 run (void *cls,
@@ -214,7 +394,7 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   sched = s;
-  setup_peer (&p1, "test_fs_download_data.conf");
+  setup_peer (&p1, "test_fs_namespace_data.conf");
   fs = GNUNET_FS_start (sched,
                         cfg,
                         "test-fs-namespace",
@@ -253,10 +433,15 @@ main (int argc, char *argv[])
                       argvx, "test-fs-namespace",
                       "nohelp", options, &run, NULL);
   stop_arm (&p1);
+  if (GNUNET_YES != update_started)
+    {
+      fprintf (stderr,
+               "Update search never started!\n");
+      err = 1;
+    }
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/");
-  return 0;
+  return err;
 }
 
 
-
 /* end of test_fs_namespace.c */