src/fs/test_fs_search_with_and.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_with_and.c
  22  * @brief testcase for publishing multiple files and search with a and operator
  23  * @author Bruno Cabral - 99% based on Christian Grothoff code
  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  * Number of files for testing.
  38  */
  39 #define NUM_FILES 10
  40
  41
  42 /**
  43  * How long until we give up on transmitting the message?
  44  */
  45 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
  46
  47 /**
  48  * How long should our test-content live?
  49  */
  50 #define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
  51
  52
  53 static struct GNUNET_TIME_Absolute start;
  54
  55 static struct GNUNET_FS_Handle *fs;
  56
  57 static struct GNUNET_FS_SearchContext *search;
  58
  59 static struct GNUNET_FS_PublishContext *publish;
  60
  61 static struct GNUNET_SCHEDULER_Task * timeout_task;
  62
  63 static int err;
  64
  65 static int processed_files;
  66
  67
  68 static void
  69 abort_publish_task(void *cls)
  70 {
  71   if (NULL != publish)
  72     {
  73       GNUNET_FS_publish_stop(publish);
  74       publish = NULL;
  75     }
  76   if (NULL != timeout_task)
  77     {
  78       GNUNET_SCHEDULER_cancel(timeout_task);
  79       timeout_task = NULL;
  80     }
  81 }
  82
  83
  84 static void
  85 abort_error(void *cls)
  86 {
  87   fprintf(stderr,
  88           "Timeout\n");
  89   timeout_task = NULL;
  90   if (NULL != search)
  91     {
  92       GNUNET_FS_search_stop(search);
  93       search = NULL;
  94     }
  95   if (NULL != publish)
  96     {
  97       GNUNET_FS_publish_stop(publish);
  98       publish = NULL;
  99     }
 100   err = 1;
 101 }
 102
 103
 104 static void
 105 abort_search_task(void *cls)
 106 {
 107   if (NULL != search)
 108     {
 109       GNUNET_FS_search_stop(search);
 110       search = NULL;
 111     }
 112 }
 113
 114
 115 static void *
 116 progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
 117 {
 118   struct GNUNET_FS_Uri *kuri;
 119
 120   switch (event->status)
 121     {
 122     case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 123       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 124                  "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
 125                  (unsigned long long)event->value.publish.completed,
 126                  (unsigned long long)event->value.publish.size,
 127                  event->value.publish.specifics.progress.depth,
 128                  (unsigned long long)event->value.publish.specifics.
 129                  progress.offset);
 130       break;
 131
 132     case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
 133       break;
 134
 135     case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
 136       processed_files++;
 137       if (processed_files == NUM_FILES)
 138         {
 139           char *emsg = NULL;
 140           kuri = GNUNET_FS_uri_ksk_create("+down_foo +down_bar", &emsg);
 141           GNUNET_assert(kuri != NULL);
 142
 143           start = GNUNET_TIME_absolute_get();
 144           search =
 145             GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
 146                                    "search");
 147           GNUNET_FS_uri_destroy(kuri);
 148           GNUNET_assert(search != NULL);
 149         }
 150       break;
 151
 152     case GNUNET_FS_STATUS_SEARCH_RESULT:
 153       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 154                  "Search complete.\n");
 155       GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
 156       break;
 157
 158     case GNUNET_FS_STATUS_PUBLISH_ERROR:
 159       fprintf(stderr, "Error publishing file: %s\n",
 160               event->value.publish.specifics.error.message);
 161       GNUNET_break(0);
 162       GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
 163       break;
 164
 165     case GNUNET_FS_STATUS_SEARCH_ERROR:
 166       fprintf(stderr, "Error searching file: %s\n",
 167               event->value.search.specifics.error.message);
 168       GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
 169       break;
 170
 171     case GNUNET_FS_STATUS_PUBLISH_START:
 172       GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
 173       GNUNET_assert(NULL == event->value.publish.pctx);
 174       GNUNET_assert(FILESIZE == event->value.publish.size);
 175       GNUNET_assert(0 == event->value.publish.completed);
 176       GNUNET_assert(1 == event->value.publish.anonymity);
 177       break;
 178
 179     case GNUNET_FS_STATUS_PUBLISH_STOPPED:
 180       GNUNET_assert(publish == event->value.publish.pc);
 181       GNUNET_assert(FILESIZE == event->value.publish.size);
 182       GNUNET_assert(1 == event->value.publish.anonymity);
 183       GNUNET_FS_stop(fs);
 184       fs = NULL;
 185       break;
 186
 187     case GNUNET_FS_STATUS_SEARCH_START:
 188       GNUNET_assert(search == NULL);
 189       GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
 190       GNUNET_assert(1 == event->value.search.anonymity);
 191       break;
 192
 193     case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
 194       break;
 195
 196     case GNUNET_FS_STATUS_SEARCH_STOPPED:
 197       GNUNET_assert(search == event->value.search.sc);
 198       GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
 199       break;
 200
 201     default:
 202       fprintf(stderr, "Unexpected event: %d\n", event->status);
 203       break;
 204     }
 205   return NULL;
 206 }
 207
 208
 209 static void
 210 run(void *cls,
 211     const struct GNUNET_CONFIGURATION_Handle *cfg,
 212     struct GNUNET_TESTING_Peer *peer)
 213 {
 214   const char *keywords[] = {
 215     "down_foo",
 216     "down_bar"
 217   };
 218   char *buf;
 219   struct GNUNET_CONTAINER_MetaData *meta;
 220   struct GNUNET_FS_Uri *kuri;
 221   struct GNUNET_FS_BlockOptions bo;
 222   struct GNUNET_FS_FileInformation *fi;
 223   size_t i;
 224   size_t j;
 225
 226   fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL,
 227                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
 228   GNUNET_assert(NULL != fs);
 229
 230   processed_files = 0;
 231   for (j = 0; j < NUM_FILES; j++)
 232     {
 233       buf = GNUNET_malloc(FILESIZE);
 234       for (i = 0; i < FILESIZE; i++)
 235         buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
 236       meta = GNUNET_CONTAINER_meta_data_create();
 237       kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
 238       bo.content_priority = 42;
 239       bo.anonymity_level = 1;
 240       bo.replication_level = 0;
 241       bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
 242       fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
 243                                                        FILESIZE, buf, kuri, meta,
 244                                                        GNUNET_NO, &bo);
 245       GNUNET_FS_uri_destroy(kuri);
 246       GNUNET_CONTAINER_meta_data_destroy(meta);
 247       GNUNET_assert(NULL != fi);
 248       start = GNUNET_TIME_absolute_get();
 249       publish =
 250         GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
 251                                 GNUNET_FS_PUBLISH_OPTION_NONE);
 252       GNUNET_assert(publish != NULL);
 253     }
 254
 255
 256   timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
 257                                               &abort_error, NULL);
 258 }
 259
 260
 261 int
 262 main(int argc, char *argv[])
 263 {
 264   if (0 != GNUNET_TESTING_peer_run("test-fs-search-with-and",
 265                                    "test_fs_search_data.conf",
 266                                    &run, NULL))
 267     return 1;
 268   return err;
 269 }
 270
 271 /* end of test_fs_search.c */