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
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., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
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 */
241 if ( (0 != length) &&
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 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;
384 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
385 p = info->value.publish.cctx;
387 case GNUNET_FS_STATUS_PUBLISH_ERROR:
388 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
389 "Publishing failed\n");
390 GNUNET_STATISTICS_update (stats_handle,
391 "# failed publish operations", 1, GNUNET_NO);
392 p = info->value.publish.cctx;
393 p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
395 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
396 p = info->value.publish.cctx;
397 GNUNET_STATISTICS_update (stats_handle,
398 "# publishing time (ms)",
399 (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL,
401 p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
403 case GNUNET_FS_STATUS_PUBLISH_STOPPED:
404 p = info->value.publish.cctx;
406 GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
409 case GNUNET_FS_STATUS_DOWNLOAD_START:
410 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
411 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
412 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
413 p = info->value.download.cctx;
415 case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
416 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
417 "Download failed\n");
418 GNUNET_STATISTICS_update (stats_handle,
419 "# failed downloads", 1, GNUNET_NO);
420 p = info->value.download.cctx;
421 p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
423 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
424 p = info->value.download.cctx;
425 GNUNET_STATISTICS_update (stats_handle,
426 "# download time (ms)",
427 (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL,
429 p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
431 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
432 p = info->value.download.cctx;
436 GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
440 case GNUNET_FS_STATUS_SEARCH_START:
441 case GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE:
442 p = info->value.search.cctx;
444 case GNUNET_FS_STATUS_SEARCH_RESULT:
445 p = info->value.search.cctx;
446 uri = info->value.search.specifics.result.uri;
447 if (GNUNET_YES != GNUNET_FS_uri_test_chk (uri))
448 return NULL; /* not what we want */
449 if (p->y != GNUNET_FS_uri_chk_get_file_size (uri))
450 return NULL; /* not what we want */
451 GNUNET_STATISTICS_update (stats_handle,
452 "# search time (ms)",
453 (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL,
455 p->start_time = GNUNET_TIME_absolute_get ();
456 p->ctx = GNUNET_FS_download_start (fs_handle, uri,
458 0, GNUNET_FS_uri_chk_get_file_size (uri),
460 GNUNET_FS_DOWNLOAD_NO_TEMPORARIES,
463 p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
465 case GNUNET_FS_STATUS_SEARCH_UPDATE:
466 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
467 return NULL; /* don't care */
468 case GNUNET_FS_STATUS_SEARCH_ERROR:
469 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
471 GNUNET_STATISTICS_update (stats_handle,
472 "# failed searches", 1, GNUNET_NO);
473 p = info->value.search.cctx;
474 p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
476 case GNUNET_FS_STATUS_SEARCH_STOPPED:
477 p = info->value.search.cctx;
481 GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
486 /* unexpected event during profiling */
494 * Start publish operation.
496 * @param cls the 'struct Pattern' specifying the operation to perform
499 start_publish (void *cls)
501 struct Pattern *p = cls;
502 struct GNUNET_FS_FileInformation *fi;
505 fi = make_file (p->x, p->y, p);
506 p->start_time = GNUNET_TIME_absolute_get ();
507 p->ctx = GNUNET_FS_publish_start (fs_handle,
510 GNUNET_FS_PUBLISH_OPTION_NONE);
515 * Start download operation.
517 * @param cls the 'struct Pattern' specifying the operation to perform
520 start_download (void *cls)
522 struct Pattern *p = cls;
523 struct GNUNET_FS_Uri *keywords;
526 keywords = make_keywords (p->x);
527 p->start_time = GNUNET_TIME_absolute_get ();
528 p->sctx = GNUNET_FS_search_start (fs_handle, keywords,
530 GNUNET_FS_SEARCH_OPTION_NONE,
536 * @brief Main function that will be run by the scheduler.
539 * @param args remaining command-line arguments
540 * @param cfgfile name of the configuration file used (for saving, can be NULL!)
541 * @param cfg_ configuration
544 run (void *cls, char *const *args GNUNET_UNUSED,
545 const char *cfgfile GNUNET_UNUSED,
546 const struct GNUNET_CONFIGURATION_Handle *cfg_)
552 /* Scheduled the task to clean up when shutdown is called */
553 GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
557 GNUNET_CONFIGURATION_get_value_number (cfg,
561 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
562 "TESTBED", "PEERID");
563 global_ret = GNUNET_SYSERR;
564 GNUNET_SCHEDULER_shutdown ();
568 GNUNET_CONFIGURATION_get_value_number (cfg,
569 "FSPROFILER", "ANONYMITY_LEVEL",
573 GNUNET_CONFIGURATION_get_value_number (cfg,
574 "FSPROFILER", "REPLICATION_LEVEL",
576 replication_level = 1;
577 GNUNET_snprintf (myoptname, sizeof (myoptname),
578 "DOWNLOAD-PATTERN-%u", my_peerid);
580 GNUNET_CONFIGURATION_get_value_string (cfg,
581 "FSPROFILER", myoptname,
583 download_pattern = GNUNET_strdup ("");
584 GNUNET_snprintf (myoptname, sizeof (myoptname),
585 "PUBLISH-PATTERN-%u", my_peerid);
587 GNUNET_CONFIGURATION_get_value_string (cfg,
588 "FSPROFILER", myoptname,
590 publish_pattern = GNUNET_strdup ("");
592 parse_pattern (&download_head,
594 download_pattern)) ||
596 parse_pattern (&publish_head,
600 GNUNET_SCHEDULER_shutdown ();
604 stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
606 GNUNET_FS_start (cfg,
609 GNUNET_FS_FLAGS_NONE,
610 GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, 1,
611 GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, 1,
612 GNUNET_FS_OPTIONS_END);
613 if (NULL == fs_handle)
615 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not acquire FS handle. Exiting.\n");
616 global_ret = GNUNET_SYSERR;
617 GNUNET_SCHEDULER_shutdown ();
620 for (p = publish_head; NULL != p; p = p->next)
621 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
623 for (p = download_head; NULL != p; p = p->next)
624 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
630 * Program that performs various "random" FS activities.
632 * @param argc number of arguments from the command line
633 * @param argv command line arguments
634 * @return 0 ok, 1 on error
637 main (int argc, char *const *argv)
639 static const struct GNUNET_GETOPT_CommandLineOption options[] = {
640 GNUNET_GETOPT_OPTION_END
643 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
646 GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
648 ("Daemon to use file-sharing to measure its performance."),
649 options, &run, NULL)) ? global_ret : 1;
652 /* end of gnunet-daemon-fsprofiler.c */