-do not test for prereq done, almost always set now

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

diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index f6fb2a1f2e64d18c469d4e17b74c9bf961e28749..198a8154e8ad25cadda944ccbb060cd6d786d9bd 100644 (file)
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2004, 2005, 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2004, 2005, 2006, 2008, 2009, 2011 Christian Grothoff (and other contributing authors)

 
      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


@@ -20,7 +20,7 @@
 
 /**
  * @file fs/test_fs_download.c
 
 /**
  * @file fs/test_fs_download.c

- * @brief simple testcase for download
+ * @brief simple testcase for simple publish + download operation

  * @author Christian Grothoff
  */
 
  * @author Christian Grothoff
  */
 


@@ -28,36 +28,38 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_arm_service.h"
 #include "gnunet_fs_service.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_arm_service.h"
 #include "gnunet_fs_service.h"

+#include <gauger.h>

 
 

-#define VERBOSE GNUNET_YES
+#define VERBOSE GNUNET_NO

 
 #define START_ARM GNUNET_YES
 
 
 #define START_ARM GNUNET_YES
 

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

 #define FILESIZE (1024 * 1024 * 2)
 
 /**
  * How long until we give up on transmitting the message?
  */
 #define FILESIZE (1024 * 1024 * 2)
 
 /**
  * How long until we give up on transmitting the message?
  */

-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)

 
 /**
  * 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)
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;

-  struct GNUNET_PeerIdentity id;   

 #if START_ARM
 #if START_ARM

-  pid_t arm_pid;
+  struct GNUNET_OS_Process *arm_proc;

 #endif
 };
 
 static struct PeerContext p1;
 
 #endif
 };
 
 static struct PeerContext p1;
 

-
-static struct GNUNET_SCHEDULER_Handle *sched;
+static struct GNUNET_TIME_Absolute start;

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


@@ -65,123 +67,174 @@ static struct GNUNET_FS_DownloadContext *download;
 
 static struct GNUNET_FS_PublishContext *publish;
 
 
 static struct GNUNET_FS_PublishContext *publish;
 

+static GNUNET_SCHEDULER_TaskIdentifier timeout_kill;
+

 static char *fn;
 
 static char *fn;
 

+static int err;
+
+static void
+timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (download != NULL)
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
+  else if (publish != NULL)
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
+  timeout_kill = GNUNET_SCHEDULER_NO_TASK;
+  err = 1;
+}

 
 static void
 
 static void

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

 {
 {

-  GNUNET_FS_download_stop (download, GNUNET_YES);
-  download = NULL;
+  if (publish != NULL)
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }

 }
 
 }
 

+static void
+stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_FS_stop (fs);
+  fs = NULL;
+}

 
 static void
 
 static void

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

 {
 {

-  GNUNET_FS_publish_stop (publish);
-  publish = NULL;
+  uint64_t size;
+
+  if (download != NULL)
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES, GNUNET_NO));
+  GNUNET_assert (size == FILESIZE);
+  GNUNET_DISK_directory_remove (fn);
+  GNUNET_free (fn);
+  fn = NULL;
+  GNUNET_SCHEDULER_cancel (timeout_kill);
+  timeout_kill = GNUNET_SCHEDULER_NO_TASK;

 }
 
 
 static void *
 }
 
 
 static void *

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

 {
 
   switch (event->status)
 {
 
   switch (event->status)

-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-#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_COMPLETED:
-#if VERBOSE
-      printf ("Publish complete.\n");
-#endif
-      GNUNET_SCHEDULER_add_continuation (sched,
-                                        GNUNET_NO,
-                                        &abort_publish_task,
-                                        NULL,
-                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      fn = GNUNET_DISK_mktemp ("gnunet-download-test-dstXXXXXX");
-      download = GNUNET_FS_download_start (fs,
-                                          event->value.publish.specifics.completed.chk_uri,
-                                          NULL,
-                                          fn,
-                                          0,
-                                          FILESIZE,
-                                          1,
-                                          GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                                          NULL);
-      GNUNET_assert (download != NULL);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:

 #if VERBOSE
 #if VERBOSE

-      printf ("Download complete.\n");
+    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
 #endif

-      GNUNET_SCHEDULER_add_continuation (sched,
-                                        GNUNET_NO,
-                                        &abort_download_task,
-                                        NULL,
-                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    printf ("Publishing complete, %llu kb/s.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Publishing speed (insertion)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL), "kb/s");
+    fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
+    start = GNUNET_TIME_absolute_get ();
+    download =
+        GNUNET_FS_download_start (fs,
+                                  event->value.publish.specifics.
+                                  completed.chk_uri, NULL, fn, NULL, 0,
+                                  FILESIZE, 1, GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                                  "download", NULL);
+    GNUNET_assert (download != NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    printf ("Download complete,  %llu kb/s.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Local download speed (inserted)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL), "kb/s");
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    GNUNET_assert (download == event->value.download.dc);

 #if VERBOSE
 #if VERBOSE

-      printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n",
-              (unsigned long long) event->value.download.completed,
-              (unsigned long long) event->value.download.size,
-             event->value.download.specifics.progress.depth,
-             (unsigned long long) event->value.download.specifics.progress.offset);
+    printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n",
+            (unsigned long long) event->value.download.completed,
+            (unsigned long long) event->value.download.size,
+            event->value.download.specifics.progress.depth,
+            (unsigned long long) event->value.download.specifics.
+            progress.offset);

 #endif
 #endif

-      break;
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf (stderr,
-              "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break (0);
-      GNUNET_SCHEDULER_add_continuation (sched,
-                                        GNUNET_NO,
-                                        &abort_publish_task,
-                                        NULL,
-                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      fprintf (stderr,
-              "Error downloading file: %s\n",
-              event->value.download.specifics.error.message);
-      GNUNET_SCHEDULER_add_continuation (sched,
-                                        GNUNET_NO,
-                                        &abort_download_task,
-                                        NULL,
-                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      /* FIXME: add checks here... */
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      /* FIXME: add checks here... */
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-      /* FIXME: add checks here... */
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      /* FIXME: add checks here... */
-      GNUNET_FS_stop (fs);
-      fs = NULL;
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-             event->status);
-      break;
-    }
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    FPRINTF (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    FPRINTF (stderr, "Error downloading file: %s\n",
+             event->value.download.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == 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);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_SCHEDULER_add_now (&stop_fs_task, NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
+    GNUNET_assert (NULL == event->value.download.pctx);
+    GNUNET_assert (NULL != event->value.download.uri);
+    GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
+    GNUNET_assert (FILESIZE == event->value.download.size);
+    GNUNET_assert (0 == event->value.download.completed);
+    GNUNET_assert (1 == event->value.download.anonymity);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    GNUNET_assert (download == event->value.download.dc);
+    GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }

   return NULL;
 }
 
   return NULL;
 }
 


@@ -191,16 +244,15 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM

-  p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm",
-                                        "gnunet-service-arm",
+  p->arm_proc =
+    GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
+                               "gnunet-service-arm",

 #if VERBOSE
 #if VERBOSE

-                                        "-L", "DEBUG",
+                               "-L", "DEBUG",

 #endif
 #endif

-                                        "-c", cfgname, NULL);
-  sleep (1);                    /* allow ARM to start */
+                               "-c", cfgname, NULL);

 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));

-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);

 }
 
 
 }
 
 


@@ -208,22 +260,24 @@ static void
 stop_arm (struct PeerContext *p)
 {
 #if START_ARM
 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);
+  if (NULL != p->arm_proc)
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }

 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 
 
 static void
 #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, char *const *args, const char *cfgfile,

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


@@ -235,39 +289,33 @@ run (void *cls,
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
   struct GNUNET_FS_Uri *kuri;
   struct GNUNET_FS_FileInformation *fi;
   size_t i;

+  struct GNUNET_FS_BlockOptions bo;

 
 

-  sched = s;

   setup_peer (&p1, "test_fs_download_data.conf");
   setup_peer (&p1, "test_fs_download_data.conf");

-  fs = GNUNET_FS_start (sched,
-                       cfg,
-                       "test-fs-download",
-                       &progress_cb,
-                       NULL,
-                       GNUNET_FS_FLAGS_NONE,
-                       GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+  fs = GNUNET_FS_start (cfg, "test-fs-download", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);

   buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   meta = GNUNET_CONTAINER_meta_data_create ();
   kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
   meta = GNUNET_CONTAINER_meta_data_create ();
   kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);

-  fi = GNUNET_FS_file_information_create_from_data ("file-to-publish",
-                                                   FILESIZE,
-                                                   buf,
-                                                   kuri,
-                                                   meta,
-                                                   GNUNET_NO,
-                                                   1,
-                                                   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);
+  fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                    FILESIZE, buf, kuri, meta,
+                                                    GNUNET_NO, &bo);

   GNUNET_FS_uri_destroy (kuri);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_assert (NULL != fi);
   GNUNET_FS_uri_destroy (kuri);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_assert (NULL != fi);

-  publish = GNUNET_FS_publish_start (fs,
-                                   "publish-context",
-                                   fi,
-                                   NULL, NULL, NULL,
-                                   GNUNET_FS_PUBLISH_OPTION_NONE);
+  timeout_kill =
+      GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL);
+  start = GNUNET_TIME_absolute_get ();
+  publish =
+      GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                               GNUNET_FS_PUBLISH_OPTION_NONE);

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


@@ -275,7 +323,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
 int
 main (int argc, char *argv[])
 {

-  char *const argvx[] = { 
+  char *const argvx[] = {

     "test-fs-download",
     "-c",
     "test_fs_download_data.conf",
     "test-fs-download",
     "-c",
     "test_fs_download_data.conf",


@@ -288,18 +336,18 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
     GNUNET_GETOPT_OPTION_END
   };
 

-  GNUNET_log_setup ("test_fs_download", 
+  GNUNET_log_setup ("test_fs_download",

 #if VERBOSE
 #if VERBOSE

-                   "DEBUG",
+                    "DEBUG",

 #else
 #else

-                   "WARNING",
+                    "WARNING",

 #endif
 #endif

-                   NULL);
-  GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-download",
-                     "nohelp", options, &run, NULL);
+                    NULL);
+  GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx,
+                      "test-fs-download", "nohelp", options, &run, NULL);

   stop_arm (&p1);
   stop_arm (&p1);

-  return 0;
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
+  return err;

 }
 
 /* end of test_fs_download.c */
 }
 
 /* end of test_fs_download.c */