-towards block plugin for mesh

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

diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index 20e65aeace78ebb40062f13cbc42d1ead8cc6419..47a604c1dde5c9c4bc2c20d6548b03479af18512 100644 (file)
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -4,7 +4,7 @@
 
      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


@@ -17,23 +17,17 @@
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
 */
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
 */

-

 /**
  * @file fs/test_fs_publish.c
  * @brief simple testcase for publish operation (indexing, listing
  *        indexed, directory structure)
  * @author Christian Grothoff
  */
 /**
  * @file fs/test_fs_publish.c
  * @brief simple testcase for publish operation (indexing, listing
  *        indexed, directory structure)
  * @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-new.h"

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

-#define VERBOSE GNUNET_NO
-
-#define START_ARM GNUNET_YES
-

 /**
  * File-size we use for testing.
  */
 /**
  * File-size we use for testing.
  */


@@ -46,38 +40,25 @@
 
 /**
  * How long should our test-content live?
 
 /**
  * How long should our test-content live?

- */ 
+ */

 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 

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

 
 static struct GNUNET_TIME_Absolute start;
 
 
 static struct GNUNET_TIME_Absolute start;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
-

 static struct GNUNET_FS_Handle *fs;
 
 static struct GNUNET_FS_PublishContext *publish;
 
 static struct GNUNET_FS_Handle *fs;
 
 static struct GNUNET_FS_PublishContext *publish;
 

-static struct GNUNET_FS_PublishContext *publish;
-

 static char *fn1;
 
 static char *fn2;
 
 static int err;
 
 static char *fn1;
 
 static char *fn2;
 
 static int err;
 

+

 static void
 static void

-abort_publish_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;


@@ -91,134 +72,88 @@ abort_publish_task (void *cls,
 
 
 static void *
 
 
 static void *

-progress_cb (void *cls, 
-            const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)

 {
   void *ret;
 
   ret = NULL;
   switch (event->status)
 {
   void *ret;
 
   ret = NULL;
   switch (event->status)

+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    ret = event->value.publish.cctx;
+    printf ("Publish complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024));
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    ret = event->value.publish.cctx;
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+               (unsigned long long) event->value.publish.completed,
+               (unsigned long long) event->value.publish.size,
+               event->value.publish.specifics.progress.depth,
+               (unsigned long long) event->value.publish.specifics.
+               progress.offset);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    ret = event->value.publish.cctx;
+    FPRINTF (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    err = 1;
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+    {
+      FPRINTF (stderr, "Scheduling abort task for error on `%s'\n",
+               (const char *) event->value.publish.cctx);
+      GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    }
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    ret = event->value.publish.cctx;
+    if (0 == strcmp ("publish-context1", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (1 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context2", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (2 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))

     {
     {

-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      ret = event->value.publish.cctx;
-      printf ("Publish complete,  %llu kbps.\n",
-             (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).value) / 1024));
-      if (0 == strcmp ("list_indexed-context-dir", 
-                      event->value.publish.cctx))      
-       GNUNET_SCHEDULER_add_continuation (sched,
-                                          &abort_publish_task,
-                                          NULL,
-                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      ret = event->value.publish.cctx;
-      GNUNET_assert (publish == event->value.publish.sc);
-#if VERBOSE
-      printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-              (unsigned long long) event->value.publish.completed,
-              (unsigned long long) event->value.publish.size,
-             event->value.publish.specifics.progress.depth,
-             (unsigned long long) event->value.publish.specifics.progress.offset);
-#endif
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      ret = event->value.publish.cctx;
-      fprintf (stderr,
-              "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      err = 1;
-      if (0 == strcmp ("list_indexed-context-dir", 
-                      event->value.publish.cctx))              
-       GNUNET_SCHEDULER_add_continuation (sched,
-                                          &abort_publish_task,
-                                          NULL,
-                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      ret = event->value.publish.cctx;
-      if (0 == strcmp ("publish-context1", 
-                      event->value.publish.cctx))
-       {
-         GNUNET_assert (0 == strcmp ("publish-context-dir", 
-                                     event->value.publish.pctx));
-         GNUNET_assert (FILESIZE == event->value.publish.size);
-         GNUNET_assert (0 == event->value.publish.completed);
-         GNUNET_assert (1 == event->value.publish.anonymity);
-       }
-      else if (0 == strcmp ("publish-context2", 
-                           event->value.publish.cctx))
-       {
-         GNUNET_assert (0 == strcmp ("publish-context-dir", 
-                                     event->value.publish.pctx));
-         GNUNET_assert (FILESIZE == event->value.publish.size);
-         GNUNET_assert (0 == event->value.publish.completed);
-         GNUNET_assert (2 == event->value.publish.anonymity);
-       }
-      else if (0 == strcmp ("publish-context-dir", 
-                           event->value.publish.cctx))
-       {
-         GNUNET_assert (0 == event->value.publish.completed);
-         GNUNET_assert (3 == event->value.publish.anonymity);
-       }
-      else
-       GNUNET_assert (0);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      if (0 == strcmp ("list_indexed-context-dir", 
-                      event->value.publish.cctx))      
-       {
-         GNUNET_assert (publish == event->value.publish.sc);
-         GNUNET_SCHEDULER_add_continuation (sched,
-                                            &abort_publish_task,
-                                            NULL,
-                                            GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-       }
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-             event->status);
-      break;
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (3 == event->value.publish.anonymity);

     }
     }

+    else
+      GNUNET_assert (0);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+      GNUNET_assert (publish == event->value.publish.pc);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }

   return ret;
 }
 
 
 static void
   return ret;
 }
 
 
 static void

-setup_peer (struct PeerContext *p, const char *cfgname)
-{
-  p->cfg = GNUNET_CONFIGURATION_create ();
-#if START_ARM
-  p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "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));
-}
-
-
-static void
-stop_arm (struct PeerContext *p)
-{
-#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);
-}
-
-
-static void
-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile,
+run (void *cls, 

      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {


@@ -232,26 +167,19 @@ run (void *cls,
   struct GNUNET_FS_FileInformation *fi2;
   struct GNUNET_FS_FileInformation *fidir;
   size_t i;
   struct GNUNET_FS_FileInformation *fi2;
   struct GNUNET_FS_FileInformation *fidir;
   size_t i;

+  struct GNUNET_FS_BlockOptions bo;

 
 

-  sched = s;
-  setup_peer (&p1, "test_fs_publish_data.conf");
-  fs = GNUNET_FS_start (sched,
-                       cfg,
-                       "test-fs-publish",
-                       &progress_cb,
-                       NULL,
-                       GNUNET_FS_FLAGS_NONE,
-                       GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+  fs = GNUNET_FS_start (cfg, "test-fs-publish", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);

   fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
   buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   GNUNET_assert (FILESIZE ==
   fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
   buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   GNUNET_assert (FILESIZE ==

-                GNUNET_DISK_fn_write (fn1,
-                                      buf,
-                                      FILESIZE,
-                                      GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE));
+                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ |
+                                       GNUNET_DISK_PERM_USER_WRITE));

   GNUNET_free (buf);
 
   fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
   GNUNET_free (buf);
 
   fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");


@@ -259,49 +187,42 @@ run (void *cls,
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   GNUNET_assert (FILESIZE ==
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   GNUNET_assert (FILESIZE ==

-                GNUNET_DISK_fn_write (fn2,
-                                      buf,
-                                      FILESIZE,
-                                      GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE));
+                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ |
+                                       GNUNET_DISK_PERM_USER_WRITE));

   GNUNET_free (buf);
 
   meta = GNUNET_CONTAINER_meta_data_create ();
   kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   GNUNET_free (buf);
 
   meta = GNUNET_CONTAINER_meta_data_create ();
   kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);

-  fi1 = GNUNET_FS_file_information_create_from_file (fs,
-                                                    "publish-context1",
-                                                    fn1,
-                                                    kuri,
-                                                    meta,
-                                                    GNUNET_YES,
-                                                    1,
-                                                    42,
-                                                    GNUNET_TIME_relative_to_absolute (LIFETIME)); 
-  fi2 = GNUNET_FS_file_information_create_from_file (fs,
-                                                    "publish-context2",
-                                                    fn2,
-                                                    kuri,
-                                                    meta,
-                                                    GNUNET_YES,
-                                                    2,
-                                                    42,
-                                                    GNUNET_TIME_relative_to_absolute (LIFETIME)); 
-  fidir = GNUNET_FS_file_information_create_empty_directory (fs,
-                                                            "publish-context-dir",
-                                                            kuri,
-                                                            meta,
-                                                            3,
-                                                            42,
-                                                            GNUNET_TIME_relative_to_absolute (LIFETIME)); 
+  bo.content_priority = 42;
+  bo.anonymity_level = 1;
+  bo.replication_level = 0;
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+
+  fi1 =
+      GNUNET_FS_file_information_create_from_file (fs, "publish-context1", fn1,
+                                                   kuri, meta, GNUNET_YES, &bo);
+
+  GNUNET_assert (NULL != fi1);
+  bo.anonymity_level = 2;
+  fi2 =
+      GNUNET_FS_file_information_create_from_file (fs, "publish-context2", fn2,
+                                                   kuri, meta, GNUNET_YES, &bo);
+  GNUNET_assert (NULL != fi2);
+  bo.anonymity_level = 3;
+  fidir =
+      GNUNET_FS_file_information_create_empty_directory (fs,
+                                                         "publish-context-dir",
+                                                         kuri, meta, &bo, NULL);

   GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
   GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
   GNUNET_FS_uri_destroy (kuri);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_assert (NULL != fidir);
   start = GNUNET_TIME_absolute_get ();
   GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
   GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
   GNUNET_FS_uri_destroy (kuri);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_assert (NULL != fidir);
   start = GNUNET_TIME_absolute_get ();

-  publish = GNUNET_FS_publish_start (fs,
-                                    fidir,
-                                    NULL, NULL, NULL,
-                                    GNUNET_FS_PUBLISH_OPTION_NONE);
+  publish =
+      GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
+                               GNUNET_FS_PUBLISH_OPTION_NONE);

   GNUNET_assert (publish != NULL);
 }
 
   GNUNET_assert (publish != NULL);
 }
 


@@ -309,35 +230,10 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
 int
 main (int argc, char *argv[])
 {

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

   return err;
 }
 
   return err;
 }