src/fs/test_fs_search.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2004-2013 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20 /**
  21  * @file fs/test_fs_search.c
  22  * @brief simple testcase for simple publish + search operation
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_testing_lib.h"
  28 #include "gnunet_fs_service.h"
  29
  30
  31 /**
  32  * File-size we use for testing.
  33  */
  34 #define FILESIZE 1024
  35
  36 /**
  37  * How long until we give up on transmitting the message?
  38  */
  39 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
  40
  41 /**
  42  * How long should our test-content live?
  43  */
  44 #define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
  45
  46
  47 static struct GNUNET_TIME_Absolute start;
  48
  49 static struct GNUNET_FS_Handle *fs;
  50
  51 static struct GNUNET_FS_SearchContext *search;
  52
  53 static struct GNUNET_FS_PublishContext *publish;
  54
  55 static struct GNUNET_SCHEDULER_Task * timeout_task;
  56
  57 static int err;
  58
  59
  60 static void
  61 abort_publish_task(void *cls)
  62 {
  63   if (NULL != publish)
  64     {
  65       GNUNET_FS_publish_stop(publish);
  66       publish = NULL;
  67     }
  68   if (NULL != timeout_task)
  69     {
  70       GNUNET_SCHEDULER_cancel(timeout_task);
  71       timeout_task = NULL;
  72     }
  73 }
  74
  75
  76 static void
  77 abort_error(void *cls)
  78 {
  79   fprintf(stderr,
  80           "Timeout\n");
  81   timeout_task = NULL;
  82   if (NULL != search)
  83     {
  84       GNUNET_FS_search_stop(search);
  85       search = NULL;
  86     }
  87   if (NULL != publish)
  88     {
  89       GNUNET_FS_publish_stop(publish);
  90       publish = NULL;
  91     }
  92   err = 1;
  93 }
  94
  95
  96 static void
  97 abort_search_task(void *cls)
  98 {
  99   if (NULL != search)
 100     {
 101       GNUNET_FS_search_stop(search);
 102       search = NULL;
 103     }
 104 }
 105
 106
 107 static void *
 108 progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
 109 {
 110   const char *keywords[] = {
 111     "down_foo"
 112   };
 113   struct GNUNET_FS_Uri *kuri;
 114
 115   switch (event->status)
 116     {
 117     case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 118       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 119                  "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
 120                  (unsigned long long)event->value.publish.completed,
 121                  (unsigned long long)event->value.publish.size,
 122                  event->value.publish.specifics.progress.depth,
 123                  (unsigned long long)event->value.publish.specifics.
 124                  progress.offset);
 125       break;
 126
 127     case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
 128       break;
 129
 130     case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
 131       kuri = GNUNET_FS_uri_ksk_create_from_args(1, keywords);
 132       start = GNUNET_TIME_absolute_get();
 133       search =
 134         GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
 135                                "search");
 136       GNUNET_FS_uri_destroy(kuri);
 137       GNUNET_assert(search != NULL);
 138       break;
 139
 140     case GNUNET_FS_STATUS_SEARCH_RESULT:
 141       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 142                  "Search complete.\n");
 143       GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
 144       break;
 145
 146     case GNUNET_FS_STATUS_PUBLISH_ERROR:
 147       fprintf(stderr, "Error publishing file: %s\n",
 148               event->value.publish.specifics.error.message);
 149       GNUNET_break(0);
 150       GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
 151       break;
 152
 153     case GNUNET_FS_STATUS_SEARCH_ERROR:
 154       fprintf(stderr, "Error searching file: %s\n",
 155               event->value.search.specifics.error.message);
 156       GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
 157       break;
 158
 159     case GNUNET_FS_STATUS_PUBLISH_START:
 160       GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
 161       GNUNET_assert(NULL == event->value.publish.pctx);
 162       GNUNET_assert(FILESIZE == event->value.publish.size);
 163       GNUNET_assert(0 == event->value.publish.completed);
 164       GNUNET_assert(1 == event->value.publish.anonymity);
 165       break;
 166
 167     case GNUNET_FS_STATUS_PUBLISH_STOPPED:
 168       GNUNET_assert(publish == event->value.publish.pc);
 169       GNUNET_assert(FILESIZE == event->value.publish.size);
 170       GNUNET_assert(1 == event->value.publish.anonymity);
 171       GNUNET_FS_stop(fs);
 172       fs = NULL;
 173       break;
 174
 175     case GNUNET_FS_STATUS_SEARCH_START:
 176       GNUNET_assert(search == NULL);
 177       GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
 178       GNUNET_assert(1 == event->value.search.anonymity);
 179       break;
 180
 181     case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
 182       break;
 183
 184     case GNUNET_FS_STATUS_SEARCH_STOPPED:
 185       GNUNET_assert(search == event->value.search.sc);
 186       GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
 187       break;
 188
 189     default:
 190       fprintf(stderr, "Unexpected event: %d\n", event->status);
 191       break;
 192     }
 193   return NULL;
 194 }
 195
 196
 197 static void
 198 run(void *cls,
 199     const struct GNUNET_CONFIGURATION_Handle *cfg,
 200     struct GNUNET_TESTING_Peer *peer)
 201 {
 202   const char *keywords[] = {
 203     "down_foo",
 204     "down_bar"
 205   };
 206   char *buf;
 207   struct GNUNET_CONTAINER_MetaData *meta;
 208   struct GNUNET_FS_Uri *kuri;
 209   struct GNUNET_FS_BlockOptions bo;
 210   struct GNUNET_FS_FileInformation *fi;
 211   size_t i;
 212
 213   fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL,
 214                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
 215   GNUNET_assert(NULL != fs);
 216   buf = GNUNET_malloc(FILESIZE);
 217   for (i = 0; i < FILESIZE; i++)
 218     buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
 219   meta = GNUNET_CONTAINER_meta_data_create();
 220   kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
 221   bo.content_priority = 42;
 222   bo.anonymity_level = 1;
 223   bo.replication_level = 0;
 224   bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
 225   fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
 226                                                    FILESIZE, buf, kuri, meta,
 227                                                    GNUNET_NO, &bo);
 228   GNUNET_FS_uri_destroy(kuri);
 229   GNUNET_CONTAINER_meta_data_destroy(meta);
 230   GNUNET_assert(NULL != fi);
 231   start = GNUNET_TIME_absolute_get();
 232   publish =
 233     GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
 234                             GNUNET_FS_PUBLISH_OPTION_NONE);
 235   GNUNET_assert(publish != NULL);
 236   timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
 237                                               &abort_error, NULL);
 238 }
 239
 240
 241 int
 242 main(int argc, char *argv[])
 243 {
 244   if (0 != GNUNET_TESTING_peer_run("test-fs-search",
 245                                    "test_fs_search_data.conf",
 246                                    &run, NULL))
 247     return 1;
 248   return err;
 249 }
 250
 251 /* end of test_fs_search.c */