2 This file is part of GNUnet.
3 Copyright (C) 2012 Christian Grothoff
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.
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.
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/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file fs/gnunet-daemon-fsprofiler.c
23 * @brief daemon that publishes and downloads (random) files
24 * @author Christian Grothoff
27 * - how to signal driver that we're done?
30 #include "gnunet_fs_service.h"
31 #include "gnunet_statistics_service.h"
34 * We use 'patterns' of the form (x,y,t) to specify desired download/publish
35 * activities of a peer. They are stored in a DLL.
50 * Execution context for the pattern (FS-handle to the operation).
55 * Secondary execution context for the pattern (FS-handle to the operation).
60 * When did the operation start?
62 struct GNUNET_TIME_Absolute start_time;
65 * With how much delay should this operation be started?
67 struct GNUNET_TIME_Relative delay;
70 * Task to run the operation.
72 struct GNUNET_SCHEDULER_Task *task;
75 * Secondary task to run the operation.
77 struct GNUNET_SCHEDULER_Task *stask;
92 * Return value from 'main'.
94 static int global_ret;
97 * Configuration we use.
99 static const struct GNUNET_CONFIGURATION_Handle *cfg;
102 * Handle to the statistics service.
104 static struct GNUNET_STATISTICS_Handle *stats_handle;
109 static struct GNUNET_FS_Handle *fs_handle;
112 * Unique number for this peer in the testbed.
114 static unsigned long long my_peerid;
117 * Desired anonymity level.
119 static unsigned long long anonymity_level;
122 * Desired replication level.
124 static unsigned long long replication_level;
127 * String describing which publishing operations this peer should
128 * perform. The format is "(SIZE,SEED,TIME)*", for example:
129 * "(1,5,0)(7,3,13)" means to publish a file with 1 byte and
130 * seed/keyword 5 immediately and another file with 7 bytes and
131 * seed/keyword 3 after 13 ms.
133 static char *publish_pattern;
136 * Head of the DLL of publish patterns.
138 static struct Pattern *publish_head;
141 * Tail of the DLL of publish patterns.
143 static struct Pattern *publish_tail;
146 * String describing which download operations this peer should
147 * perform. The format is "(KEYWORD,SIZE,DELAY)*"; for example,
148 * "(1,7,3)(3,8,8)" means to download one file of 7 bytes under
149 * keyword "1" starting the search after 3 ms; and another one of 8
150 * bytes under keyword '3' starting after 8 ms. The file size is
151 * used to determine which search result(s) should be used or ignored.
153 static char *download_pattern;
156 * Head of the DLL of publish patterns.
158 static struct Pattern *download_head;
161 * Tail of the DLL of publish patterns.
163 static struct Pattern *download_tail;
167 * Parse a pattern string and store the corresponding
168 * 'struct Pattern' in the given head/tail.
170 * @param head where to store the head
171 * @param tail where to store the tail
172 * @param pattern pattern to parse
173 * @return GNUNET_OK on success
176 parse_pattern (struct Pattern **head,
177 struct Pattern **tail,
181 unsigned long long x;
182 unsigned long long y;
183 unsigned long long t;
185 while (3 == sscanf (pattern,
189 p = GNUNET_new (struct Pattern);
192 p->delay.rel_value_us = (uint64_t) t;
193 GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
194 pattern = strstr (pattern, ")");
195 GNUNET_assert (NULL != pattern);
198 return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
203 * Create a KSK URI from a number.
205 * @param kval the number
206 * @return corresponding KSK URI
208 static struct GNUNET_FS_Uri *
209 make_keywords (uint64_t kval)
213 GNUNET_snprintf (kw, sizeof(kw),
214 "%llu", (unsigned long long) kval);
215 return GNUNET_FS_uri_ksk_create (kw, NULL);
220 * Create a file of the given length with a deterministic amount
221 * of data to be published under keyword 'kval'.
223 * @param length number of bytes in the file
224 * @param kval keyword value and seed for the data of the file
225 * @param ctx context to pass to 'fi'
226 * @return file information handle for the file
228 static struct GNUNET_FS_FileInformation *
229 make_file (uint64_t length,
233 struct GNUNET_FS_FileInformation *fi;
234 struct GNUNET_FS_BlockOptions bo;
236 struct GNUNET_FS_Uri *keywords;
237 unsigned long long i;
240 data = NULL; /* to make compilers happy */
242 (NULL == (data = GNUNET_malloc_large ((size_t) length))))
244 /* initialize data with 'unique' data only depending on 'kval' and 'size',
245 making sure that blocks do not repeat */
246 for (i = 0; i < length; i += 8)
248 xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
249 GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof(uint64_t)));
251 bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS);
252 bo.anonymity_level = (uint32_t) anonymity_level;
253 bo.content_priority = 128;
254 bo.replication_level = (uint32_t) replication_level;
255 keywords = make_keywords (kval);
256 fi = GNUNET_FS_file_information_create_from_data (fs_handle,
260 NULL, GNUNET_NO, &bo);
261 GNUNET_FS_uri_destroy (keywords);
267 * Task run during shutdown.
272 shutdown_task (void *cls)
276 while (NULL != (p = publish_head))
279 GNUNET_SCHEDULER_cancel (p->task);
281 GNUNET_FS_publish_stop (p->ctx);
282 GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
285 while (NULL != (p = download_head))
288 GNUNET_SCHEDULER_cancel (p->task);
289 if (NULL != p->stask)
290 GNUNET_SCHEDULER_cancel (p->stask);
292 GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
294 GNUNET_FS_search_stop (p->sctx);
295 GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
298 if (NULL != fs_handle)
300 GNUNET_FS_stop (fs_handle);
303 if (NULL != stats_handle)
305 GNUNET_STATISTICS_destroy (stats_handle, GNUNET_YES);
312 * Task run when a publish operation should be stopped.
314 * @param cls the 'struct Pattern' of the publish operation to stop
317 publish_stop_task (void *cls)
319 struct Pattern *p = cls;
322 GNUNET_FS_publish_stop (p->ctx);
327 * Task run when a download operation should be stopped.
329 * @param cls the 'struct Pattern' of the download operation to stop
332 download_stop_task (void *cls)
334 struct Pattern *p = cls;
337 GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
342 * Task run when a download operation should be stopped.
344 * @param cls the 'struct Pattern' of the download operation to stop
347 search_stop_task (void *cls)
349 struct Pattern *p = cls;
352 GNUNET_FS_search_stop (p->sctx);
357 * Notification of FS to a client about the progress of an
358 * operation. Callbacks of this type will be used for uploads,
359 * downloads and searches. Some of the arguments depend a bit
360 * in their meaning on the context in which the callback is used.
363 * @param info details about the event, specifying the event type
364 * and various bits about the event
365 * @return client-context (for the next progress call
366 * for this operation; should be set to NULL for
367 * SUSPEND and STOPPED events). The value returned
368 * will be passed to future callbacks in the respective
369 * field in the GNUNET_FS_ProgressInfo struct.
372 progress_cb (void *cls,
373 const struct GNUNET_FS_ProgressInfo *info)
376 const struct GNUNET_FS_Uri *uri;
378 switch (info->status)
380 case GNUNET_FS_STATUS_PUBLISH_START:
381 case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
382 p = info->value.publish.cctx;
385 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
386 p = info->value.publish.cctx;
389 case GNUNET_FS_STATUS_PUBLISH_ERROR:
390 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
391 "Publishing failed\n");
392 GNUNET_STATISTICS_update (stats_handle,
393 "# failed publish operations", 1, GNUNET_NO);
394 p = info->value.publish.cctx;
395 p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
398 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
399 p = info->value.publish.cctx;
400 GNUNET_STATISTICS_update (stats_handle,
401 "# publishing time (ms)",
402 (long long) GNUNET_TIME_absolute_get_duration (
403 p->start_time).rel_value_us / 1000LL,
405 p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
408 case GNUNET_FS_STATUS_PUBLISH_STOPPED:
409 p = info->value.publish.cctx;
411 GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
415 case GNUNET_FS_STATUS_DOWNLOAD_START:
416 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
417 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
418 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
419 p = info->value.download.cctx;
422 case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
423 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
424 "Download failed\n");
425 GNUNET_STATISTICS_update (stats_handle,
426 "# failed downloads", 1, GNUNET_NO);
427 p = info->value.download.cctx;
428 p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
431 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
432 p = info->value.download.cctx;
433 GNUNET_STATISTICS_update (stats_handle,
434 "# download time (ms)",
435 (long long) GNUNET_TIME_absolute_get_duration (
436 p->start_time).rel_value_us / 1000LL,
438 p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
441 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
442 p = info->value.download.cctx;
446 GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
451 case GNUNET_FS_STATUS_SEARCH_START:
452 case GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE:
453 p = info->value.search.cctx;
456 case GNUNET_FS_STATUS_SEARCH_RESULT:
457 p = info->value.search.cctx;
458 uri = info->value.search.specifics.result.uri;
459 if (GNUNET_YES != GNUNET_FS_uri_test_chk (uri))
460 return NULL; /* not what we want */
461 if (p->y != GNUNET_FS_uri_chk_get_file_size (uri))
462 return NULL; /* not what we want */
463 GNUNET_STATISTICS_update (stats_handle,
464 "# search time (ms)",
465 (long long) GNUNET_TIME_absolute_get_duration (
466 p->start_time).rel_value_us / 1000LL,
468 p->start_time = GNUNET_TIME_absolute_get ();
469 p->ctx = GNUNET_FS_download_start (fs_handle, uri,
471 0, GNUNET_FS_uri_chk_get_file_size (uri),
473 GNUNET_FS_DOWNLOAD_NO_TEMPORARIES,
476 p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
479 case GNUNET_FS_STATUS_SEARCH_UPDATE:
480 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
481 return NULL; /* don't care */
483 case GNUNET_FS_STATUS_SEARCH_ERROR:
484 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
486 GNUNET_STATISTICS_update (stats_handle,
487 "# failed searches", 1, GNUNET_NO);
488 p = info->value.search.cctx;
489 p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
492 case GNUNET_FS_STATUS_SEARCH_STOPPED:
493 p = info->value.search.cctx;
497 GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
503 /* unexpected event during profiling */
511 * Start publish operation.
513 * @param cls the 'struct Pattern' specifying the operation to perform
516 start_publish (void *cls)
518 struct Pattern *p = cls;
519 struct GNUNET_FS_FileInformation *fi;
522 fi = make_file (p->x, p->y, p);
523 p->start_time = GNUNET_TIME_absolute_get ();
524 p->ctx = GNUNET_FS_publish_start (fs_handle,
527 GNUNET_FS_PUBLISH_OPTION_NONE);
532 * Start download operation.
534 * @param cls the 'struct Pattern' specifying the operation to perform
537 start_download (void *cls)
539 struct Pattern *p = cls;
540 struct GNUNET_FS_Uri *keywords;
543 keywords = make_keywords (p->x);
544 p->start_time = GNUNET_TIME_absolute_get ();
545 p->sctx = GNUNET_FS_search_start (fs_handle, keywords,
547 GNUNET_FS_SEARCH_OPTION_NONE,
553 * @brief Main function that will be run by the scheduler.
556 * @param args remaining command-line arguments
557 * @param cfgfile name of the configuration file used (for saving, can be NULL!)
558 * @param cfg_ configuration
561 run (void *cls, char *const *args GNUNET_UNUSED,
562 const char *cfgfile GNUNET_UNUSED,
563 const struct GNUNET_CONFIGURATION_Handle *cfg_)
569 /* Scheduled the task to clean up when shutdown is called */
570 GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
574 GNUNET_CONFIGURATION_get_value_number (cfg,
578 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
579 "TESTBED", "PEERID");
580 global_ret = GNUNET_SYSERR;
581 GNUNET_SCHEDULER_shutdown ();
585 GNUNET_CONFIGURATION_get_value_number (cfg,
586 "FSPROFILER", "ANONYMITY_LEVEL",
590 GNUNET_CONFIGURATION_get_value_number (cfg,
591 "FSPROFILER", "REPLICATION_LEVEL",
593 replication_level = 1;
594 GNUNET_snprintf (myoptname, sizeof(myoptname),
595 "DOWNLOAD-PATTERN-%u", my_peerid);
597 GNUNET_CONFIGURATION_get_value_string (cfg,
598 "FSPROFILER", myoptname,
600 download_pattern = GNUNET_strdup ("");
601 GNUNET_snprintf (myoptname, sizeof(myoptname),
602 "PUBLISH-PATTERN-%u", my_peerid);
604 GNUNET_CONFIGURATION_get_value_string (cfg,
605 "FSPROFILER", myoptname,
607 publish_pattern = GNUNET_strdup ("");
609 parse_pattern (&download_head,
611 download_pattern)) ||
613 parse_pattern (&publish_head,
617 GNUNET_SCHEDULER_shutdown ();
621 stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
623 GNUNET_FS_start (cfg,
626 GNUNET_FS_FLAGS_NONE,
627 GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, 1,
628 GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, 1,
629 GNUNET_FS_OPTIONS_END);
630 if (NULL == fs_handle)
632 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
633 "Could not acquire FS handle. Exiting.\n");
634 global_ret = GNUNET_SYSERR;
635 GNUNET_SCHEDULER_shutdown ();
638 for (p = publish_head; NULL != p; p = p->next)
639 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
641 for (p = download_head; NULL != p; p = p->next)
642 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
648 * Program that performs various "random" FS activities.
650 * @param argc number of arguments from the command line
651 * @param argv command line arguments
652 * @return 0 ok, 1 on error
655 main (int argc, char *const *argv)
657 static const struct GNUNET_GETOPT_CommandLineOption options[] = {
658 GNUNET_GETOPT_OPTION_END
661 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
664 GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
667 "Daemon to use file-sharing to measure its performance."),
668 options, &run, NULL)) ? global_ret : 1;
671 /* end of gnunet-daemon-fsprofiler.c */