src/fs/test_fs_download_persistence.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2004, 2005, 2006, 2008, 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file fs/test_fs_download_persistence.c
  23  * @brief simple testcase for persistence of simple download operation
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_arm_service.h"
  30 #include "gnunet_fs_service.h"
  31
  32 #define VERBOSE GNUNET_NO
  33
  34 #define START_ARM GNUNET_YES
  35
  36 /**
  37  * File-size we use for testing.
  38  */
  39 #define FILESIZE (1024 * 1024 * 2)
  40
  41 /**
  42  * How long until we give up on transmitting the message?
  43  */
  44 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  45
  46 /**
  47  * How long should our test-content live?
  48  */
  49 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
  50
  51 struct PeerContext
  52 {
  53   struct GNUNET_CONFIGURATION_Handle *cfg;
  54 #if START_ARM
  55   struct GNUNET_OS_Process *arm_proc;
  56 #endif
  57 };
  58
  59 static struct PeerContext p1;
  60
  61 static struct GNUNET_TIME_Absolute start;
  62
  63 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  64
  65 static struct GNUNET_FS_Handle *fs;
  66
  67 static struct GNUNET_FS_DownloadContext *download;
  68
  69 static struct GNUNET_FS_PublishContext *publish;
  70
  71 static GNUNET_SCHEDULER_TaskIdentifier timeout_kill;
  72
  73 static char *fn;
  74
  75 static int err;
  76
  77 static void
  78 timeout_kill_task (void *cls,
  79                    const struct GNUNET_SCHEDULER_TaskContext *tc)
  80 {
  81   if (download != NULL)
  82     {
  83       GNUNET_FS_download_stop (download, GNUNET_YES);
  84       download = NULL;
  85     }
  86   else if (publish != NULL)
  87     {
  88       GNUNET_FS_publish_stop (publish);
  89       publish = NULL;
  90     }
  91   timeout_kill = GNUNET_SCHEDULER_NO_TASK;
  92   err = 1;
  93 }
  94
  95 static void
  96 abort_publish_task (void *cls,
  97                      const struct GNUNET_SCHEDULER_TaskContext *tc)
  98 {
  99   if (publish != NULL)
 100     {
 101       GNUNET_FS_publish_stop (publish);
 102       publish = NULL;
 103     }
 104 }
 105
 106
 107 static void
 108 abort_download_task (void *cls,
 109                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 110 {
 111   uint64_t size;
 112
 113   if (download != NULL)
 114     {
 115       GNUNET_FS_download_stop (download, GNUNET_YES);
 116       download = NULL;
 117     }
 118   GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES));
 119   GNUNET_assert (size == FILESIZE);
 120   GNUNET_DISK_directory_remove (fn);
 121   GNUNET_free (fn);
 122   fn = NULL;
 123   GNUNET_SCHEDULER_cancel (timeout_kill);
 124   timeout_kill = GNUNET_SCHEDULER_NO_TASK;
 125 }
 126
 127
 128 static void *
 129 progress_cb (void *cls,
 130              const struct GNUNET_FS_ProgressInfo *event);
 131
 132
 133 static void
 134 restart_fs_task (void *cls,
 135                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 136 {
 137   GNUNET_FS_stop (fs);
 138   fs = GNUNET_FS_start (cfg,
 139                         "test-fs-download-persistence",
 140                         &progress_cb,
 141                         NULL,
 142                         GNUNET_FS_FLAGS_PERSISTENCE,
 143                         GNUNET_FS_OPTIONS_END);
 144 }
 145
 146
 147 /**
 148  * Consider scheduling the restart-task.
 149  * Only runs the restart task once per event
 150  * category.
 151  *
 152  * @param ev type of the event to consider
 153  */
 154 static void
 155 consider_restart (int ev)
 156 {
 157   static int prev[32];
 158   static int off;
 159   int i;
 160   for (i=0;i<off;i++)
 161     if (prev[i] == ev)
 162       return;
 163   prev[off++] = ev;
 164   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
 165                                       &restart_fs_task,
 166                                       NULL);
 167 }
 168
 169
 170 static void *
 171 progress_cb (void *cls,
 172              const struct GNUNET_FS_ProgressInfo *event)
 173 {
 174   switch (event->status)
 175     {
 176     case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 177 #if VERBOSE
 178       printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
 179               (unsigned long long) event->abs_value.publish.completed,
 180               (unsigned long long) event->abs_value.publish.size,
 181               event->abs_value.publish.specifics.progress.depth,
 182               (unsigned long long) event->abs_value.publish.specifics.progress.offset);
 183 #endif
 184       break;
 185     case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
 186       printf ("Publishing complete, %llu kbps.\n",
 187               (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
 188       fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
 189       start = GNUNET_TIME_absolute_get ();
 190       GNUNET_assert (download == NULL);
 191       GNUNET_FS_download_start (fs,
 192                                 event->value.publish.specifics.completed.chk_uri,
 193                                 NULL,
 194                                 fn, NULL,
 195                                 0,
 196                                 FILESIZE,
 197                                 1,
 198                                 GNUNET_FS_DOWNLOAD_OPTION_NONE,
 199                                 "download",
 200                                 NULL);
 201       break;
 202     case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
 203       consider_restart (event->status);
 204       printf ("Download complete,  %llu kbps.\n",
 205               (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
 206       GNUNET_SCHEDULER_add_now (&abort_download_task,
 207                                 NULL);
 208       break;
 209     case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
 210       consider_restart (event->status);
 211       GNUNET_assert (download == event->value.download.dc);
 212 #if VERBOSE
 213       printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n",
 214               (unsigned long long) event->abs_value.download.completed,
 215               (unsigned long long) event->abs_value.download.size,
 216               event->abs_value.download.specifics.progress.depth,
 217               (unsigned long long) event->abs_value.download.specifics.progress.offset);
 218 #endif
 219       break;
 220     case GNUNET_FS_STATUS_PUBLISH_ERROR:
 221       fprintf (stderr,
 222                "Error publishing file: %s\n",
 223                event->value.publish.specifics.error.message);
 224       GNUNET_break (0);
 225       GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
 226                                          NULL,
 227                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 228       break;
 229     case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
 230       fprintf (stderr,
 231                "Error downloading file: %s\n",
 232                event->value.download.specifics.error.message);
 233       GNUNET_SCHEDULER_add_now (&abort_download_task,
 234                                 NULL);
 235       break;
 236     case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
 237       GNUNET_assert (event->value.publish.pc == publish);
 238       publish = NULL;
 239       break;
 240     case GNUNET_FS_STATUS_PUBLISH_RESUME:
 241       GNUNET_assert (NULL == publish);
 242       publish = event->value.publish.pc;
 243       break;
 244     case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
 245       GNUNET_assert (event->value.download.dc == download);
 246       download = NULL;
 247       break;
 248     case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
 249       GNUNET_assert (NULL == download);
 250       download = event->value.download.dc;
 251       break;
 252     case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
 253       consider_restart (event->status);
 254       break;
 255     case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
 256       consider_restart (event->status);
 257       break;
 258     case GNUNET_FS_STATUS_PUBLISH_START:
 259       GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
 260       GNUNET_assert (NULL == event->value.publish.pctx);
 261       GNUNET_assert (FILESIZE == event->value.publish.size);
 262       GNUNET_assert (0 == event->value.publish.completed);
 263       GNUNET_assert (1 == event->value.publish.anonymity);
 264       break;
 265     case GNUNET_FS_STATUS_PUBLISH_STOPPED:
 266       GNUNET_assert (publish == event->value.publish.pc);
 267       GNUNET_assert (FILESIZE == event->value.publish.size);
 268       GNUNET_assert (1 == event->value.publish.anonymity);
 269       GNUNET_FS_stop (fs);
 270       fs = NULL;
 271       break;
 272     case GNUNET_FS_STATUS_DOWNLOAD_START:
 273       consider_restart (event->status);
 274       GNUNET_assert (download == NULL);
 275       download = event->value.download.dc;
 276       GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
 277       GNUNET_assert (NULL == event->value.download.pctx);
 278       GNUNET_assert (NULL != event->value.download.uri);
 279       GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
 280       GNUNET_assert (FILESIZE == event->value.download.size);
 281       GNUNET_assert (0 == event->value.download.completed);
 282       GNUNET_assert (1 == event->value.download.anonymity);
 283       break;
 284     case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
 285       GNUNET_assert (download == event->value.download.dc);
 286       GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
 287                                          NULL,
 288                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 289       download = NULL;
 290       break;
 291     default:
 292       printf ("Unexpected event: %d\n",
 293               event->status);
 294       break;
 295     }
 296   return NULL;
 297 }
 298
 299
 300 static void
 301 setup_peer (struct PeerContext *p, const char *cfgname)
 302 {
 303   p->cfg = GNUNET_CONFIGURATION_create ();
 304 #if START_ARM
 305   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
 306                                         "gnunet-service-arm",
 307 #if VERBOSE
 308                                         "-L", "DEBUG",
 309 #endif
 310                                         "-c", cfgname, NULL);
 311 #endif
 312   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 313 }
 314
 315
 316 static void
 317 stop_arm (struct PeerContext *p)
 318 {
 319 #if START_ARM
 320   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
 321     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 322   if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
 323     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 324   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 325               "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
 326   GNUNET_OS_process_close (p->arm_proc);
 327   p->arm_proc = NULL;
 328 #endif
 329   GNUNET_CONFIGURATION_destroy (p->cfg);
 330 }
 331
 332
 333 static void
 334 run (void *cls,
 335      char *const *args,
 336      const char *cfgfile,
 337      const struct GNUNET_CONFIGURATION_Handle *c)
 338 {
 339   const char *keywords[] = {
 340     "down_foo",
 341     "down_bar",
 342   };
 343   char *buf;
 344   struct GNUNET_CONTAINER_MetaData *meta;
 345   struct GNUNET_FS_Uri *kuri;
 346   struct GNUNET_FS_FileInformation *fi;
 347   size_t i;
 348
 349   cfg = c;
 350   setup_peer (&p1, "test_fs_download_data.conf");
 351   fs = GNUNET_FS_start (cfg,
 352                         "test-fs-download-persistence",
 353                         &progress_cb,
 354                         NULL,
 355                         GNUNET_FS_FLAGS_PERSISTENCE,
 356                         GNUNET_FS_OPTIONS_END);
 357   GNUNET_assert (NULL != fs);
 358   buf = GNUNET_malloc (FILESIZE);
 359   for (i = 0; i < FILESIZE; i++)
 360     buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
 361   meta = GNUNET_CONTAINER_meta_data_create ();
 362   kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
 363   fi = GNUNET_FS_file_information_create_from_data (fs,
 364                                                     "publish-context",
 365                                                     FILESIZE,
 366                                                     buf,
 367                                                     kuri,
 368                                                     meta,
 369                                                     GNUNET_NO,
 370                                                     1,
 371                                                     42,
 372                                                     GNUNET_TIME_relative_to_absolute (LIFETIME));
 373   GNUNET_FS_uri_destroy (kuri);
 374   GNUNET_CONTAINER_meta_data_destroy (meta);
 375   GNUNET_assert (NULL != fi);
 376   timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 377                                                &timeout_kill_task,
 378                                                NULL);
 379   start = GNUNET_TIME_absolute_get ();
 380   publish = GNUNET_FS_publish_start (fs,
 381                                     fi,
 382                                     NULL, NULL, NULL,
 383                                     GNUNET_FS_PUBLISH_OPTION_NONE);
 384   GNUNET_assert (publish != NULL);
 385 }
 386
 387
 388 int
 389 main (int argc, char *argv[])
 390 {
 391   char *const argvx[] = {
 392     "test-fs-download-persistence",
 393     "-c",
 394     "test_fs_download_data.conf",
 395 #if VERBOSE
 396     "-L", "DEBUG",
 397 #endif
 398     NULL
 399   };
 400   struct GNUNET_GETOPT_CommandLineOption options[] = {
 401     GNUNET_GETOPT_OPTION_END
 402   };
 403   GNUNET_log_setup ("test_fs_download_persistence",
 404 #if VERBOSE
 405                     "DEBUG",
 406 #else
 407                     "WARNING",
 408 #endif
 409                     NULL);
 410   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
 411   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
 412                       argvx, "test-fs-download-persistence",
 413                       "nohelp", options, &run, NULL);
 414   stop_arm (&p1);
 415   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
 416   return err;
 417 }
 418
 419 /* end of test_fs_download_persistence.c */