2 This file is part of GNUnet.
3 (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
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.
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.
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.
22 * @file fs/fs_test_lib.c
23 * @brief library routines for testing FS publishing and downloading;
24 * this code is limited to flat files
25 * and no keywords (those functions can be tested with
26 * single-peer setups; this is for testing routing).
27 * @author Christian Grothoff
31 #include "fs_test_lib.h"
34 #define CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS
38 * Handle for a publishing operation started for testing FS.
40 struct TestPublishOperation
44 * Handle for the operation to connect to the peer's 'fs' service.
46 struct GNUNET_TESTBED_Operation *fs_op;
49 * Handle to the file sharing context using this daemon.
51 struct GNUNET_FS_Handle *fs;
54 * Function to call when upload is done.
56 GNUNET_FS_TEST_UriContinuation publish_cont;
59 * Closure for publish_cont.
61 void *publish_cont_cls;
64 * Task to abort publishing (timeout).
66 GNUNET_SCHEDULER_TaskIdentifier publish_timeout_task;
69 * Seed for file generation.
71 uint32_t publish_seed;
74 * Context for current publishing operation.
76 struct GNUNET_FS_PublishContext *publish_context;
81 struct GNUNET_FS_Uri *publish_uri;
84 * Name of the temporary file used, or NULL for none.
86 char *publish_tmp_file;
94 * Anonymity level used.
99 * Verbosity level of the current operation.
101 unsigned int verbose;
104 * Are we testing indexing? (YES: index, NO: insert, SYSERR: simulate)
111 * Handle for a download operation started for testing FS.
113 struct TestDownloadOperation
117 * Handle for the operation to connect to the peer's 'fs' service.
119 struct GNUNET_TESTBED_Operation *fs_op;
122 * Handle to the file sharing context using this daemon.
124 struct GNUNET_FS_Handle *fs;
127 * Handle to the daemon via testing.
129 struct GNUNET_TESTING_Daemon *daemon;
132 * Function to call when download is done.
134 GNUNET_SCHEDULER_Task download_cont;
137 * Closure for download_cont.
139 void *download_cont_cls;
144 struct GNUNET_FS_Uri *uri;
147 * Task to abort downloading (timeout).
149 GNUNET_SCHEDULER_TaskIdentifier download_timeout_task;
152 * Context for current download operation.
154 struct GNUNET_FS_DownloadContext *download_context;
162 * Anonymity level used.
167 * Seed for download verification.
169 uint32_t download_seed;
172 * Verbosity level of the current operation.
174 unsigned int verbose;
180 * Task scheduled to report on the completion of our publish operation.
182 * @param cls the publish operation context
183 * @param tc scheduler context (unused)
186 report_uri (void *cls,
187 const struct GNUNET_SCHEDULER_TaskContext *tc)
189 struct TestPublishOperation *po = cls;
191 GNUNET_FS_publish_stop (po->publish_context);
192 GNUNET_TESTBED_operation_done (po->fs_op);
193 po->publish_cont (po->publish_cont_cls,
195 (GNUNET_YES == po->do_index)
196 ? po->publish_tmp_file
198 GNUNET_FS_uri_destroy (po->publish_uri);
199 if ( (GNUNET_YES != po->do_index) &&
200 (NULL != po->publish_tmp_file) )
201 (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
202 GNUNET_free_non_null (po->publish_tmp_file);
208 * Task scheduled to run when publish operation times out.
210 * @param cls the publish operation context
211 * @param tc scheduler context (unused)
214 publish_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
216 struct TestPublishOperation *po = cls;
218 po->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
219 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
220 "Timeout while trying to publish data\n");
221 GNUNET_TESTBED_operation_done (po->fs_op);
222 GNUNET_FS_publish_stop (po->publish_context);
223 po->publish_cont (po->publish_cont_cls, NULL, NULL);
224 (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
225 GNUNET_free_non_null (po->publish_tmp_file);
231 * Progress callback for file-sharing events while publishing.
233 * @param cls the publish operation context
234 * @param info information about the event
237 publish_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
239 struct TestPublishOperation *po = cls;
241 switch (info->status)
243 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
244 GNUNET_SCHEDULER_cancel (po->publish_timeout_task);
245 po->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
247 GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
248 GNUNET_SCHEDULER_add_continuation (&report_uri, po,
249 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
251 case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
253 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
254 (unsigned long long) info->value.publish.completed,
255 (unsigned long long) info->value.publish.size);
257 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
259 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
261 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
262 (unsigned long long) info->value.download.completed,
263 (unsigned long long) info->value.download.size);
273 * Generate test data for publishing test.
275 * @param cls pointer to uint32_t with publishing seed
276 * @param offset offset to generate data for
277 * @param max maximum number of bytes to generate
278 * @param buf where to write generated data
279 * @param emsg where to store error message (unused)
280 * @return number of bytes written to buf
283 file_generator (void *cls,
289 uint32_t *publish_seed = cls;
298 for (pos = 0; pos < 8; pos++)
299 cbuf[pos] = (uint8_t) (offset >> pos * 8);
300 for (pos = 8; pos < max; pos++)
302 mod = (255 - (offset / 1024 / 32));
305 cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod);
312 * Connect adapter for publishing operation.
314 * @param cls the 'struct TestPublishOperation'
315 * @param cfg configuration of the peer to connect to; will be available until
316 * GNUNET_TESTBED_operation_done() is called on the operation returned
317 * from GNUNET_TESTBED_service_connect()
318 * @return service handle to return in 'op_result', NULL on error
321 publish_connect_adapter (void *cls,
322 const struct GNUNET_CONFIGURATION_Handle *cfg)
324 struct TestPublishOperation *po = cls;
326 return GNUNET_FS_start (cfg,
328 &publish_progress_cb, po,
329 GNUNET_FS_FLAGS_NONE,
330 GNUNET_FS_OPTIONS_END);
335 * Adapter function called to destroy connection to file-sharing service.
337 * @param cls the 'struct GNUNET_FS_Handle'
338 * @param op_result unused (different for publish/download!)
341 fs_disconnect_adapter (void *cls,
344 struct GNUNET_FS_Handle *fs = op_result;
351 * Callback to be called when testbed has connected to the fs service
353 * @param cls the 'struct TestPublishOperation'
354 * @param op the operation that has been finished
355 * @param ca_result the 'struct GNUNET_FS_Handle ' (NULL on error)
356 * @param emsg error message in case the operation has failed; will be NULL if
357 * operation has executed successfully.
360 publish_fs_connect_complete_cb (void *cls,
361 struct GNUNET_TESTBED_Operation *op,
365 struct TestPublishOperation *po = cls;
366 struct GNUNET_FS_FileInformation *fi;
367 struct GNUNET_DISK_FileHandle *fh;
370 char buf[DBLOCK_SIZE];
372 struct GNUNET_FS_BlockOptions bo;
374 if (NULL == ca_result)
376 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to FS for publishing: %s\n", emsg);
377 po->publish_cont (po->publish_cont_cls,
379 GNUNET_TESTBED_operation_done (po->fs_op);
385 bo.expiration_time = GNUNET_TIME_relative_to_absolute (CONTENT_LIFETIME);
386 bo.anonymity_level = po->anonymity;
387 bo.content_priority = 42;
388 bo.replication_level = 1;
389 if (GNUNET_YES == po->do_index)
391 po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
392 GNUNET_assert (po->publish_tmp_file != NULL);
393 fh = GNUNET_DISK_file_open (po->publish_tmp_file,
394 GNUNET_DISK_OPEN_WRITE |
395 GNUNET_DISK_OPEN_CREATE,
396 GNUNET_DISK_PERM_USER_READ |
397 GNUNET_DISK_PERM_USER_WRITE);
398 GNUNET_assert (NULL != fh);
400 while (off < po->size)
402 bsize = GNUNET_MIN (sizeof (buf), po->size - off);
404 GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize, buf, &em));
405 GNUNET_assert (em == NULL);
406 GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize));
409 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
410 fi = GNUNET_FS_file_information_create_from_file (po->fs, po,
411 po->publish_tmp_file,
412 NULL, NULL, po->do_index,
414 GNUNET_assert (NULL != fi);
418 fi = GNUNET_FS_file_information_create_from_reader (po->fs, po,
420 &file_generator, &po->publish_seed,
423 GNUNET_assert (NULL != fi);
425 po->publish_context =
426 GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL,
427 GNUNET_FS_PUBLISH_OPTION_NONE);
432 * Publish a file at the given peer.
434 * @param peer where to publish
435 * @param timeout if this operation cannot be completed within the
436 * given period, call the continuation with an error code
437 * @param anonymity option for publication
438 * @param do_index GNUNET_YES for index, GNUNET_NO for insertion,
439 * GNUNET_SYSERR for simulation
440 * @param size size of the file to publish
441 * @param seed seed to use for file generation
442 * @param verbose how verbose to be in reporting
443 * @param cont function to call when done
444 * @param cont_cls closure for cont
447 GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer,
448 struct GNUNET_TIME_Relative timeout, uint32_t anonymity,
449 int do_index, uint64_t size, uint32_t seed,
450 unsigned int verbose,
451 GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
453 struct TestPublishOperation *po;
455 po = GNUNET_malloc (sizeof (struct TestPublishOperation));
456 po->publish_cont = cont;
457 po->publish_cont_cls = cont_cls;
458 po->publish_seed = seed;
459 po->anonymity = anonymity;
461 po->verbose = verbose;
462 po->do_index = do_index;
463 po->fs_op = GNUNET_TESTBED_service_connect (po,
466 &publish_fs_connect_complete_cb,
468 &publish_connect_adapter,
469 &fs_disconnect_adapter,
471 po->publish_timeout_task =
472 GNUNET_SCHEDULER_add_delayed (timeout, &publish_timeout, po);
476 /* ************************** download ************************ */
480 * Task scheduled to run when download operation times out.
482 * @param cls the download operation context
483 * @param tc scheduler context (unused)
486 download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
488 struct TestDownloadOperation *dop = cls;
490 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
491 "Timeout while trying to download file\n");
492 dop->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
493 GNUNET_FS_download_stop (dop->download_context, GNUNET_YES);
494 GNUNET_SCHEDULER_add_continuation (dop->download_cont,
495 dop->download_cont_cls,
496 GNUNET_SCHEDULER_REASON_TIMEOUT);
497 GNUNET_TESTBED_operation_done (dop->fs_op);
498 GNUNET_FS_uri_destroy (dop->uri);
504 * Task scheduled to report on the completion of our download operation.
506 * @param cls the download operation context
507 * @param tc scheduler context (unused)
510 report_success (void *cls,
511 const struct GNUNET_SCHEDULER_TaskContext *tc)
513 struct TestDownloadOperation *dop = cls;
515 GNUNET_FS_download_stop (dop->download_context, GNUNET_YES);
516 GNUNET_SCHEDULER_add_continuation (dop->download_cont,
517 dop->download_cont_cls,
518 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
519 GNUNET_TESTBED_operation_done (dop->fs_op);
520 GNUNET_FS_uri_destroy (dop->uri);
526 * Progress callback for file-sharing events while downloading.
528 * @param cls the download operation context
529 * @param info information about the event
532 download_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
534 struct TestDownloadOperation *dop = cls;
536 switch (info->status)
538 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
540 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
541 (unsigned long long) info->value.download.completed,
542 (unsigned long long) info->value.download.size);
544 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
545 GNUNET_SCHEDULER_cancel (dop->download_timeout_task);
546 dop->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
547 GNUNET_SCHEDULER_add_continuation (&report_success, dop,
548 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
550 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
551 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
553 /* FIXME: monitor data correctness during download progress */
554 /* FIXME: do performance reports given sufficient verbosity */
555 /* FIXME: advance timeout task to "immediate" on error */
564 * Connect adapter for download operation.
566 * @param cls the 'struct TestDownloadOperation'
567 * @param cfg configuration of the peer to connect to; will be available until
568 * GNUNET_TESTBED_operation_done() is called on the operation returned
569 * from GNUNET_TESTBED_service_connect()
570 * @return service handle to return in 'op_result', NULL on error
573 download_connect_adapter (void *cls,
574 const struct GNUNET_CONFIGURATION_Handle *cfg)
576 struct TestPublishOperation *po = cls;
578 return GNUNET_FS_start (cfg,
580 &download_progress_cb, po,
581 GNUNET_FS_FLAGS_NONE,
582 GNUNET_FS_OPTIONS_END);
587 * Callback to be called when testbed has connected to the fs service
589 * @param cls the 'struct TestPublishOperation'
590 * @param op the operation that has been finished
591 * @param ca_result the 'struct GNUNET_FS_Handle ' (NULL on error)
592 * @param emsg error message in case the operation has failed; will be NULL if
593 * operation has executed successfully.
596 download_fs_connect_complete_cb (void *cls,
597 struct GNUNET_TESTBED_Operation *op,
601 struct TestDownloadOperation *dop = cls;
604 GNUNET_assert (NULL != dop->fs);
605 dop->download_context =
606 GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
607 dop->anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE,
613 * Perform test download.
615 * @param peer which peer to download from
616 * @param timeout if this operation cannot be completed within the
617 * given period, call the continuation with an error code
618 * @param anonymity option for download
619 * @param seed used for file validation
620 * @param uri URI of file to download (CHK/LOC only)
621 * @param verbose how verbose to be in reporting
622 * @param cont function to call when done
623 * @param cont_cls closure for cont
626 GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer *peer,
627 struct GNUNET_TIME_Relative timeout,
628 uint32_t anonymity, uint32_t seed,
629 const struct GNUNET_FS_Uri *uri, unsigned int verbose,
630 GNUNET_SCHEDULER_Task cont, void *cont_cls)
632 struct TestDownloadOperation *dop;
634 dop = GNUNET_malloc (sizeof (struct TestDownloadOperation));
635 dop->uri = GNUNET_FS_uri_dup (uri);
636 dop->size = GNUNET_FS_uri_chk_get_file_size (uri);
637 dop->verbose = verbose;
638 dop->anonymity = anonymity;
639 dop->download_cont = cont;
640 dop->download_cont_cls = cont_cls;
641 dop->download_seed = seed;
643 dop->fs_op = GNUNET_TESTBED_service_connect (dop,
646 &download_fs_connect_complete_cb,
648 &download_connect_adapter,
649 &fs_disconnect_adapter,
651 dop->download_timeout_task =
652 GNUNET_SCHEDULER_add_delayed (timeout, &download_timeout, dop);
656 /* end of fs_test_lib.c */