Merge branch 'master' of gnunet.org:gnunet

[oweals/gnunet.git] / src / fs / test_fs_namespace.c

diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index d0db8dfcf43484cba3960948bce37c6d1f5be196..b8325d8d86cc6cf4258899950bf02db1571b056d 100644 (file)
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2005, 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2005-2013 GNUnet e.V.

 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published

-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your

      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -14,8 +14,8 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the

-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.

 */
 
 /**
 */
 
 /**


@@ -23,157 +23,282 @@
  * @brief Test for fs_namespace.c
  * @author Christian Grothoff
  */
  * @brief Test for fs_namespace.c
  * @author Christian Grothoff
  */

-

 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "platform.h"
 #include "gnunet_util_lib.h"

-#include "gnunet_arm_service.h"
+#include "gnunet_testing_lib.h"

 #include "gnunet_fs_service.h"
 
 #include "gnunet_fs_service.h"
 

-#define START_ARM GNUNET_YES

 
 

-static struct GNUNET_SCHEDULER_Handle *sched;
+static struct GNUNET_CRYPTO_EcdsaPublicKey nsid;
+
+static struct GNUNET_FS_Uri *sks_expect_uri;

 
 

-static struct PeerContext p1;
+static struct GNUNET_FS_Uri *ksk_expect_uri;

 
 static struct GNUNET_FS_Handle *fs;
 
 
 static struct GNUNET_FS_Handle *fs;
 

+static struct GNUNET_FS_SearchContext *sks_search;

 
 

-struct PeerContext
-{
-  struct GNUNET_CONFIGURATION_Handle *cfg;
-#if START_ARM
-  pid_t arm_pid;
-#endif
-};
+static struct GNUNET_FS_SearchContext *ksk_search;

 
 

+static struct GNUNET_SCHEDULER_Task * kill_task;

 
 

-static void *
-progress_cb (void *cls, 
-            const struct GNUNET_FS_ProgressInfo *event)
+static int update_started;
+
+static int err;
+
+
+static void
+abort_ksk_search_task (void *cls)

 {
 {

-  return NULL;
+  if (ksk_search != NULL)
+  {
+    GNUNET_FS_search_stop (ksk_search);
+    ksk_search = NULL;
+    if (sks_search == NULL)
+    {
+      GNUNET_FS_stop (fs);
+      if (NULL != kill_task)
+        GNUNET_SCHEDULER_cancel (kill_task);
+    }
+  }

 }
 
 
 static void
 }
 
 
 static void

-setup_peer (struct PeerContext *p, const char *cfgname)
+abort_sks_search_task (void *cls)

 {
 {

-  p->cfg = GNUNET_CONFIGURATION_create ();
-#if START_ARM
-  p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm",
-                                        "gnunet-service-arm",
-#if VERBOSE
-                                        "-L", "DEBUG",
-#endif
-                                        "-c", cfgname, NULL);
-#endif
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
+  if (sks_search == NULL)
+    return;
+  GNUNET_FS_search_stop (sks_search);
+  sks_search = NULL;
+  if (ksk_search == NULL)
+  {
+    GNUNET_FS_stop (fs);
+    if (NULL != kill_task)
+      GNUNET_SCHEDULER_cancel (kill_task);
+  }

 }
 
 
 static void
 }
 
 
 static void

-stop_arm (struct PeerContext *p)
+do_timeout (void *cls)
+{
+  err = 1;
+  FPRINTF (stderr, "%s",  "Operation timed out\n");
+  kill_task = NULL;
+  abort_sks_search_task (NULL);
+  abort_ksk_search_task (NULL);
+}
+
+
+static void *
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)

 {
 {

-#if START_ARM
-  if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "ARM process %u stopped\n", p->arm_pid);
-#endif
-  GNUNET_CONFIGURATION_destroy (p->cfg);
+  switch (event->status)
+  {
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    if (sks_search == event->value.search.sc)
+    {
+      if (!GNUNET_FS_uri_test_equal
+          (sks_expect_uri, event->value.search.specifics.result.uri))
+      {
+        FPRINTF (stderr, "%s",  "Wrong result for sks search!\n");
+        err = 1;
+      }
+      /* give system 1ms to initiate update search! */
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                    &abort_sks_search_task, NULL);
+    }
+    else if (ksk_search == event->value.search.sc)
+    {
+      if (!GNUNET_FS_uri_test_equal
+          (ksk_expect_uri, event->value.search.specifics.result.uri))
+      {
+        FPRINTF (stderr, "%s",  "Wrong result for ksk search!\n");
+        err = 1;
+      }
+      GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
+    }
+    else
+    {
+      FPRINTF (stderr, "%s",  "Unexpected 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_now (&abort_sks_search_task, NULL);
+    else if (ksk_search == event->value.search.sc)
+      GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
+    else
+      GNUNET_break (0);
+    break;
+  case GNUNET_FS_STATUS_SEARCH_START:
+    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 (0 == strcmp ("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:
+    return NULL;
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    return NULL;
+  default:
+    FPRINTF (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
+  return event->value.search.cctx;

 }
 
 
 }
 
 

-#if 0

 static void
 static void

-spcb (void *cls,
-      const char *name,
-      const GNUNET_HashCode * key)
+publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)

 {
 {

+  char *msg;
+  struct GNUNET_FS_Uri *sks_uri;
+  char sbuf[1024];
+  char buf[1024];
+  char *ret;
+
+  if (NULL != emsg)
+  {
+    FPRINTF (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf));
+  GNUNET_assert (NULL != ret);
+  ret[0] = '\0';
+  GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf);
+  sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
+  if (NULL == sks_uri)
+  {
+    FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    GNUNET_free_non_null (msg);
+    return;
+  }
+  ksk_search =
+      GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                              "ksk_search");
+  sks_search =
+      GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                              "sks_search");
+  GNUNET_FS_uri_destroy (sks_uri);

 }
 }

-#endif

 
 
 static void
 
 
 static void

-publish_cont (void *cls,
-             const struct GNUNET_FS_Uri *uri,
-             const char *emsg)
+sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)

 {
 {

-  struct GNUNET_FS_SearchContext *search;
+  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_FS_Uri *ksk_uri;
+  char *msg;
+  struct GNUNET_FS_BlockOptions bo;
+
+  if (NULL == uri)
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  msg = NULL;
+  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
+  GNUNET_assert (NULL == msg);
+  ksk_expect_uri = GNUNET_FS_uri_dup (uri);
+  bo.content_priority = 1;
+  bo.anonymity_level = 1;
+  bo.replication_level = 0;
+  bo.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
+  GNUNET_FS_uri_destroy (ksk_uri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+}

 
 

-  GNUNET_assert (NULL == emsg);
-  fprintf (stderr, "Starting namespace search...\n");
-  search = GNUNET_FS_search_start (fs, uri, 1, "ns-search");
+
+static void
+adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
+{
+  struct GNUNET_CONTAINER_MetaData *meta;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
+  struct GNUNET_FS_BlockOptions bo;
+
+  if (NULL != emsg)
+  {
+    FPRINTF (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  ns = GNUNET_CRYPTO_ecdsa_key_create ();
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  sks_expect_uri = GNUNET_FS_uri_dup (uri);
+  bo.content_priority = 1;
+  bo.anonymity_level = 1;
+  bo.replication_level = 0;
+  bo.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid);
+  GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,
+                         &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free (ns);

 }
 
 
 static void
 testNamespace ()
 {
 }
 
 
 static void
 testNamespace ()
 {

-  struct GNUNET_FS_Namespace *ns;
-  struct GNUNET_FS_Uri *adv;
-  struct GNUNET_FS_Uri *rootUri;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
+  struct GNUNET_FS_BlockOptions bo;

   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_CONTAINER_MetaData *meta;

-  struct GNUNET_TIME_Absolute expiration;
+  struct GNUNET_FS_Uri *ksk_uri;
+  struct GNUNET_FS_Uri *sks_uri;

 
 

-  expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  ns = GNUNET_CRYPTO_ecdsa_key_create ();

   meta = GNUNET_CONTAINER_meta_data_create ();
   meta = GNUNET_CONTAINER_meta_data_create ();

-  adv = GNUNET_FS_uri_ksk_create ("testNamespace", NULL);
-  ns = GNUNET_FS_namespace_create (fs,
-                                  "testNamespace");
-  rootUri = GNUNET_FS_namespace_advertise (fs,
-                                          ns,
-                                          meta,
-                                          1, 1,
-                                          expiration,
-                                          adv,
-                                          "root");
-  GNUNET_assert (NULL != rootUri);
-  GNUNET_FS_publish_sks (fs,
-                        ns,
-                        "this",
-                        "next",
-                        meta,
-                        rootUri,
-                        expiration,
-                        1, 1,
-                        GNUNET_FS_PUBLISH_OPTION_NONE,
-                        &publish_cont,
-                        NULL);
+  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
+  bo.content_priority = 1;
+  bo.anonymity_level = 1;
+  bo.replication_level = 0;
+  bo.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");
+  GNUNET_FS_publish_ksk (fs,
+                        ksk_uri, meta, sks_uri,
+                        &bo, GNUNET_FS_PUBLISH_OPTION_NONE,
+                        &adv_cont, NULL);
+  GNUNET_FS_uri_destroy (sks_uri);
+  kill_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
+                                    NULL);
+  GNUNET_FS_uri_destroy (ksk_uri);

   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_CONTAINER_meta_data_destroy (meta);

+  GNUNET_free (ns);

 }
 
 }
 

-#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,
 
 static void
 run (void *cls,

-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)

 {
 {

-  sched = s;
-  setup_peer (&p1, "test_fs_download_data.conf");
-  fs = GNUNET_FS_start (sched,
-                       cfg,
-                       "test-fs-namespace",
-                       &progress_cb,
-                       NULL,
-                       GNUNET_FS_FLAGS_NONE,
-                       GNUNET_FS_OPTIONS_END);
+  fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);

   testNamespace ();
 }
 
   testNamespace ();
 }
 


@@ -181,34 +306,12 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
 int
 main (int argc, char *argv[])
 {

-  char *const argvx[] = { 
-    "test-fs-namespace",
-    "-c",
-    "test_fs_namespace_data.conf",
-#if VERBOSE
-    "-L", "DEBUG",
-#endif
-    NULL
-  };
-  struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
-
-  GNUNET_log_setup ("test_fs_namespace", 
-#if VERBOSE
-                   "DEBUG",
-#else
-                   "WARNING",
-#endif
-                   NULL);
-  GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-namespace",
-                     "nohelp", options, &run, NULL);
-  stop_arm (&p1);
-  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/");
-  return 0;
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace",
+                                   "test_fs_namespace_data.conf",
+                                   &run, NULL))
+    return 1;
+  return err;

 }
 
 
 }
 
 

-

 /* end of test_fs_namespace.c */
 /* end of test_fs_namespace.c */