gnunet-daemon-fsprofiler.c File Reference

daemon that publishes and downloads (random) files More...

#include "platform.h"
#include "gnunet_fs_service.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-daemon-fsprofiler.c:

Go to the source code of this file.

Data Structures
struct	Pattern
	We use 'patterns' of the form (x,y,t) to specify desired download/publish activities of a peer. More...

Functions
static int	parse_pattern (struct Pattern **head, struct Pattern **tail, const char *pattern)
	Parse a pattern string and store the corresponding 'struct Pattern' in the given head/tail. More...
static struct GNUNET_FS_Uri *	make_keywords (uint64_t kval)
	Create a KSK URI from a number. More...
static struct GNUNET_FS_FileInformation *	make_file (uint64_t length, uint64_t kval, void *ctx)
	Create a file of the given length with a deterministic amount of data to be published under keyword 'kval'. More...
static void	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	publish_stop_task (void *cls)
	Task run when a publish operation should be stopped. More...
static void	download_stop_task (void *cls)
	Task run when a download operation should be stopped. More...
static void	search_stop_task (void *cls)
	Task run when a download operation should be stopped. More...
static void *	progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
	Notification of FS to a client about the progress of an operation. More...
static void	start_publish (void *cls)
	Start publish operation. More...
static void	start_download (void *cls)
	Start download operation. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg_)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	Program that performs various "random" FS activities. More...

Variables
static int	global_ret
	Return value from 'main'. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration we use. More...
static struct GNUNET_STATISTICS_Handle *	stats_handle
	Handle to the statistics service. More...
static struct GNUNET_FS_Handle *	fs_handle
	Peer's FS handle. More...
static unsigned long long	my_peerid
	Unique number for this peer in the testbed. More...
static unsigned long long	anonymity_level
	Desired anonymity level. More...
static unsigned long long	replication_level
	Desired replication level. More...
static char *	publish_pattern
	String describing which publishing operations this peer should perform. More...
static struct Pattern *	publish_head
	Head of the DLL of publish patterns. More...
static struct Pattern *	publish_tail
	Tail of the DLL of publish patterns. More...
static char *	download_pattern
	String describing which download operations this peer should perform. More...
static struct Pattern *	download_head
	Head of the DLL of publish patterns. More...
static struct Pattern *	download_tail
	Tail of the DLL of publish patterns. More...

Detailed Description

daemon that publishes and downloads (random) files

Author

Christian Grothoff

TODO:

• how to signal driver that we're done?

Definition in file gnunet-daemon-fsprofiler.c.

Function Documentation

parse_pattern()

static int parse_pattern ( struct Pattern **  head, struct Pattern **  tail, const char *  pattern  )

static

Parse a pattern string and store the corresponding 'struct Pattern' in the given head/tail.

Parameters

head	where to store the head
tail	where to store the tail
pattern	pattern to parse

Returns

GNUNET_OK on success

Definition at line 177 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p;
  unsigned long long x;
  unsigned long long y;
  unsigned long long t;
 
  while (3 == sscanf (pattern,
                      "(%llu,%llu,%llu)",
                      &x, &y, &t))
  {
    p = GNUNET_new (struct Pattern);
    p->x = x;
    p->y = y;
    p->delay.rel_value_us = (uint64_t) t;
    GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
    pattern = strstr (pattern, ")");
    GNUNET_assert (NULL != pattern);
    pattern++;
  }
  return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_OK, GNUNET_SYSERR, head, p, t, tail, Pattern::x, and Pattern::y.

Referenced by run().

Here is the caller graph for this function:

make_keywords()

static struct GNUNET_FS_Uri* make_keywords ( uint64_t  kval )

static

Create a KSK URI from a number.

Parameters

kval	the number

Returns

corresponding KSK URI

Definition at line 210 of file gnunet-daemon-fsprofiler.c.

{
  char kw[128];
 
  GNUNET_snprintf (kw, sizeof(kw),
                   "%llu", (unsigned long long) kval);
  return GNUNET_FS_uri_ksk_create (kw, NULL);
}

References GNUNET_FS_uri_ksk_create(), and GNUNET_snprintf().

Referenced by make_file(), and start_download().

Here is the call graph for this function:

Here is the caller graph for this function:

make_file()

static struct GNUNET_FS_FileInformation* make_file ( uint64_t  length, uint64_t  kval, void *  ctx  )

static

Create a file of the given length with a deterministic amount of data to be published under keyword 'kval'.

Parameters

length	number of bytes in the file
kval	keyword value and seed for the data of the file
ctx	context to pass to 'fi'

Returns

file information handle for the file

Definition at line 230 of file gnunet-daemon-fsprofiler.c.

{
  struct GNUNET_FS_FileInformation *fi;
  struct GNUNET_FS_BlockOptions bo;
  char *data;
  struct GNUNET_FS_Uri *keywords;
  unsigned long long i;
  uint64_t xor;
 
  data = NULL; /* to make compilers happy */
  if ((0 != length) &&
      (NULL == (data = GNUNET_malloc_large ((size_t) length))))
    return NULL;
  /* initialize data with 'unique' data only depending on 'kval' and 'size',
     making sure that blocks do not repeat */
  for (i = 0; i < length; i += 8)
  {
    xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
    GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof(uint64_t)));
  }
  bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS);
  bo.anonymity_level = (uint32_t) anonymity_level;
  bo.content_priority = 128;
  bo.replication_level = (uint32_t) replication_level;
  keywords = make_keywords (kval);
  fi = GNUNET_FS_file_information_create_from_data (fs_handle,
                                                    ctx,
                                                    length,
                                                    data, keywords,
                                                    NULL, GNUNET_NO, &bo);
  GNUNET_FS_uri_destroy (keywords);
  return fi;
}

References anonymity_level, GNUNET_FS_BlockOptions::anonymity_level, bo, GNUNET_FS_BlockOptions::content_priority, ctx, data, GNUNET_FS_BlockOptions::expiration_time, fs_handle, GNUNET_FS_file_information_create_from_data(), GNUNET_FS_uri_destroy(), GNUNET_malloc_large, GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_DAYS, GNUNET_FS_Uri::keywords, make_keywords(), replication_level, and GNUNET_FS_BlockOptions::replication_level.

Referenced by start_publish().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 273 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p;
 
  while (NULL != (p = publish_head))
  {
    if (NULL != p->task)
      GNUNET_SCHEDULER_cancel (p->task);
    if (NULL != p->ctx)
      GNUNET_FS_publish_stop (p->ctx);
    GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
    GNUNET_free (p);
  }
  while (NULL != (p = download_head))
  {
    if (NULL != p->task)
      GNUNET_SCHEDULER_cancel (p->task);
    if (NULL != p->stask)
      GNUNET_SCHEDULER_cancel (p->stask);
    if (NULL != p->ctx)
      GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
    if (NULL != p->sctx)
      GNUNET_FS_search_stop (p->sctx);
    GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
    GNUNET_free (p);
  }
  if (NULL != fs_handle)
  {
    GNUNET_FS_stop (fs_handle);
    fs_handle = NULL;
  }
  if (NULL != stats_handle)
  {
    GNUNET_STATISTICS_destroy (stats_handle, GNUNET_YES);
    stats_handle = NULL;
  }
}

References download_head, download_tail, fs_handle, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_FS_download_stop(), GNUNET_FS_publish_stop(), GNUNET_FS_search_stop(), GNUNET_FS_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_YES, p, publish_head, publish_tail, and stats_handle.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

publish_stop_task()

static void publish_stop_task ( void *  cls )

static

Task run when a publish operation should be stopped.

Parameters

cls	the 'struct Pattern' of the publish operation to stop

Definition at line 318 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p = cls;
 
  p->task = NULL;
  GNUNET_FS_publish_stop (p->ctx);
}

References GNUNET_FS_publish_stop(), and p.

Referenced by progress_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

download_stop_task()

static void download_stop_task ( void *  cls )

static

Task run when a download operation should be stopped.

Parameters

cls	the 'struct Pattern' of the download operation to stop

Definition at line 333 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p = cls;
 
  p->task = NULL;
  GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
}

References GNUNET_FS_download_stop(), GNUNET_YES, and p.

Referenced by progress_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

search_stop_task()

static void search_stop_task ( void *  cls )

static

Task run when a download operation should be stopped.

Parameters

cls	the 'struct Pattern' of the download operation to stop

Definition at line 348 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p = cls;
 
  p->stask = NULL;
  GNUNET_FS_search_stop (p->sctx);
}

References GNUNET_FS_search_stop(), and p.

Referenced by progress_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

progress_cb()

static void* progress_cb ( void *  cls, const struct GNUNET_FS_ProgressInfo *  info  )

static

Notification of FS to a client about the progress of an operation.

Callbacks of this type will be used for uploads, downloads and searches. Some of the arguments depend a bit in their meaning on the context in which the callback is used.

Parameters

cls	closure
info	details about the event, specifying the event type and various bits about the event

Returns

client-context (for the next progress call for this operation; should be set to NULL for SUSPEND and STOPPED events). The value returned will be passed to future callbacks in the respective field in the GNUNET_FS_ProgressInfo struct.

Definition at line 373 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p;
  const struct GNUNET_FS_Uri *uri;
 
  switch (info->status)
  {
  case GNUNET_FS_STATUS_PUBLISH_START:
  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
    p = info->value.publish.cctx;
    return p;
 
  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
    p = info->value.publish.cctx;
    return p;
 
  case GNUNET_FS_STATUS_PUBLISH_ERROR:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Publishing failed\n");
    GNUNET_STATISTICS_update (stats_handle,
                              "# failed publish operations", 1, GNUNET_NO);
    p = info->value.publish.cctx;
    p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
    return p;
 
  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
    p = info->value.publish.cctx;
    GNUNET_STATISTICS_update (stats_handle,
                              "# publishing time (ms)",
                              (long long) GNUNET_TIME_absolute_get_duration (
                                p->start_time).rel_value_us / 1000LL,
                              GNUNET_NO);
    p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
    return p;
 
  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
    p = info->value.publish.cctx;
    p->ctx = NULL;
    GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
    GNUNET_free (p);
    return NULL;
 
  case GNUNET_FS_STATUS_DOWNLOAD_START:
  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
    p = info->value.download.cctx;
    return p;
 
  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Download failed\n");
    GNUNET_STATISTICS_update (stats_handle,
                              "# failed downloads", 1, GNUNET_NO);
    p = info->value.download.cctx;
    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
    return p;
 
  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
    p = info->value.download.cctx;
    GNUNET_STATISTICS_update (stats_handle,
                              "# download time (ms)",
                              (long long) GNUNET_TIME_absolute_get_duration (
                                p->start_time).rel_value_us / 1000LL,
                              GNUNET_NO);
    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
    return p;
 
  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
    p = info->value.download.cctx;
    p->ctx = NULL;
    if (NULL == p->sctx)
    {
      GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
      GNUNET_free (p);
    }
    return NULL;
 
  case GNUNET_FS_STATUS_SEARCH_START:
  case GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE:
    p = info->value.search.cctx;
    return p;
 
  case GNUNET_FS_STATUS_SEARCH_RESULT:
    p = info->value.search.cctx;
    uri = info->value.search.specifics.result.uri;
    if (GNUNET_YES != GNUNET_FS_uri_test_chk (uri))
      return NULL;   /* not what we want */
    if (p->y != GNUNET_FS_uri_chk_get_file_size (uri))
      return NULL;   /* not what we want */
    GNUNET_STATISTICS_update (stats_handle,
                              "# search time (ms)",
                              (long long) GNUNET_TIME_absolute_get_duration (
                                p->start_time).rel_value_us / 1000LL,
                              GNUNET_NO);
    p->start_time = GNUNET_TIME_absolute_get ();
    p->ctx = GNUNET_FS_download_start (fs_handle, uri,
                                       NULL, NULL, NULL,
                                       0, GNUNET_FS_uri_chk_get_file_size (uri),
                                       anonymity_level,
                                       GNUNET_FS_DOWNLOAD_NO_TEMPORARIES,
                                       p,
                                       NULL);
    p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
    return NULL;
 
  case GNUNET_FS_STATUS_SEARCH_UPDATE:
  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
    return NULL;   /* don't care */
 
  case GNUNET_FS_STATUS_SEARCH_ERROR:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Search failed\n");
    GNUNET_STATISTICS_update (stats_handle,
                              "# failed searches", 1, GNUNET_NO);
    p = info->value.search.cctx;
    p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
    return p;
 
  case GNUNET_FS_STATUS_SEARCH_STOPPED:
    p = info->value.search.cctx;
    p->sctx = NULL;
    if (NULL == p->ctx)
    {
      GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
      GNUNET_free (p);
    }
    return NULL;
 
  default:
    /* unexpected event during profiling */
    GNUNET_break (0);
    return NULL;
  }
}

References anonymity_level, download_head, download_stop_task(), download_tail, fs_handle, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_DOWNLOAD_NO_TEMPORARIES, GNUNET_FS_download_start(), GNUNET_FS_STATUS_DOWNLOAD_ACTIVE, GNUNET_FS_STATUS_DOWNLOAD_COMPLETED, GNUNET_FS_STATUS_DOWNLOAD_ERROR, GNUNET_FS_STATUS_DOWNLOAD_INACTIVE, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS, GNUNET_FS_STATUS_DOWNLOAD_START, GNUNET_FS_STATUS_DOWNLOAD_STOPPED, GNUNET_FS_STATUS_PUBLISH_COMPLETED, GNUNET_FS_STATUS_PUBLISH_ERROR, GNUNET_FS_STATUS_PUBLISH_PROGRESS, GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY, GNUNET_FS_STATUS_PUBLISH_START, GNUNET_FS_STATUS_PUBLISH_STOPPED, GNUNET_FS_STATUS_SEARCH_ERROR, GNUNET_FS_STATUS_SEARCH_RESULT, GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE, GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED, GNUNET_FS_STATUS_SEARCH_START, GNUNET_FS_STATUS_SEARCH_STOPPED, GNUNET_FS_STATUS_SEARCH_UPDATE, GNUNET_FS_uri_chk_get_file_size(), GNUNET_FS_uri_test_chk(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, info, p, publish_head, publish_stop_task(), publish_tail, GNUNET_TIME_Relative::rel_value_us, search_stop_task(), stats_handle, and uri.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

start_publish()

static void start_publish ( void *  cls )

static

Start publish operation.

Parameters

cls	the 'struct Pattern' specifying the operation to perform

Definition at line 517 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p = cls;
  struct GNUNET_FS_FileInformation *fi;
 
  p->task = NULL;
  fi = make_file (p->x, p->y, p);
  p->start_time = GNUNET_TIME_absolute_get ();
  p->ctx = GNUNET_FS_publish_start (fs_handle,
                                    fi,
                                    NULL, NULL, NULL,
                                    GNUNET_FS_PUBLISH_OPTION_NONE);
}

References fs_handle, GNUNET_FS_PUBLISH_OPTION_NONE, GNUNET_FS_publish_start(), GNUNET_TIME_absolute_get(), make_file(), and p.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

start_download()

static void start_download ( void *  cls )

static

Start download operation.

Parameters

cls	the 'struct Pattern' specifying the operation to perform

Definition at line 538 of file gnunet-daemon-fsprofiler.c.

{
  struct Pattern *p = cls;
  struct GNUNET_FS_Uri *keywords;
 
  p->task = NULL;
  keywords = make_keywords (p->x);
  p->start_time = GNUNET_TIME_absolute_get ();
  p->sctx = GNUNET_FS_search_start (fs_handle, keywords,
                                    anonymity_level,
                                    GNUNET_FS_SEARCH_OPTION_NONE,
                                    p);
}

References anonymity_level, fs_handle, GNUNET_FS_SEARCH_OPTION_NONE, GNUNET_FS_search_start(), GNUNET_TIME_absolute_get(), GNUNET_FS_Uri::keywords, make_keywords(), and p.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg_  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg_	configuration

Definition at line 562 of file gnunet-daemon-fsprofiler.c.

{
  char myoptname[128];
  struct Pattern *p;
 
  cfg = cfg_;
  /* Scheduled the task to clean up when shutdown is called */
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "TESTBED", "PEERID",
                                             &my_peerid))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "TESTBED", "PEERID");
    global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "FSPROFILER", "ANONYMITY_LEVEL",
                                             &anonymity_level))
    anonymity_level = 1;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg,
                                             "FSPROFILER", "REPLICATION_LEVEL",
                                             &replication_level))
    replication_level = 1;
  GNUNET_snprintf (myoptname, sizeof(myoptname),
                   "DOWNLOAD-PATTERN-%llu", my_peerid);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "FSPROFILER", myoptname,
                                             &download_pattern))
    download_pattern = GNUNET_strdup ("");
  GNUNET_snprintf (myoptname, sizeof(myoptname),
                   "PUBLISH-PATTERN-%llu", my_peerid);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "FSPROFILER", myoptname,
                                             &publish_pattern))
    publish_pattern = GNUNET_strdup ("");
  if ((GNUNET_OK !=
       parse_pattern (&download_head,
                      &download_tail,
                      download_pattern)) ||
      (GNUNET_OK !=
       parse_pattern (&publish_head,
                      &publish_tail,
                      publish_pattern)))
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
  fs_handle =
    GNUNET_FS_start (cfg,
                     "fsprofiler",
                     &progress_cb, NULL,
                     GNUNET_FS_FLAGS_NONE,
                     GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, 1,
                     GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, 1,
                     GNUNET_FS_OPTIONS_END);
  if (NULL == fs_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not acquire FS handle. Exiting.\n");
    global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  for (p = publish_head; NULL != p; p = p->next)
    p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
                                            &start_publish, p);
  for (p = download_head; NULL != p; p = p->next)
    p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
                                            &start_download, p);
}

References anonymity_level, cfg, download_head, download_pattern, download_tail, fs_handle, global_ret, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, GNUNET_FS_OPTIONS_END, GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, GNUNET_FS_start(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_snprintf(), GNUNET_STATISTICS_create(), GNUNET_strdup, GNUNET_SYSERR, my_peerid, p, parse_pattern(), progress_cb(), publish_head, publish_pattern, publish_tail, replication_level, shutdown_task(), start_download(), start_publish(), and stats_handle.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

Program that performs various "random" FS activities.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 656 of file gnunet-daemon-fsprofiler.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  return (GNUNET_OK ==
          GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
                              gettext_noop
                              (
                                "Daemon to use file-sharing to measure its performance."),
                              options, &run, NULL)) ? global_ret : 1;
}

References gettext_noop, global_ret, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), options, and run().

Here is the call graph for this function:

Variable Documentation

global_ret

int global_ret

static

Return value from 'main'.

Definition at line 95 of file gnunet-daemon-fsprofiler.c.

Referenced by main(), and run().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration we use.

Definition at line 100 of file gnunet-daemon-fsprofiler.c.

Referenced by run().

stats_handle

struct GNUNET_STATISTICS_Handle* stats_handle

static

Handle to the statistics service.

Definition at line 105 of file gnunet-daemon-fsprofiler.c.

Referenced by progress_cb(), run(), and shutdown_task().

fs_handle

struct GNUNET_FS_Handle* fs_handle

static

Peer's FS handle.

Definition at line 110 of file gnunet-daemon-fsprofiler.c.

Referenced by make_file(), progress_cb(), run(), shutdown_task(), start_download(), and start_publish().

my_peerid

unsigned long long my_peerid

static

Unique number for this peer in the testbed.

Definition at line 115 of file gnunet-daemon-fsprofiler.c.

Referenced by run().

anonymity_level

unsigned long long anonymity_level

static

Desired anonymity level.

Definition at line 120 of file gnunet-daemon-fsprofiler.c.

Referenced by make_file(), progress_cb(), run(), and start_download().

replication_level

unsigned long long replication_level

static

Desired replication level.

Definition at line 125 of file gnunet-daemon-fsprofiler.c.

Referenced by make_file(), and run().

publish_pattern

char* publish_pattern

static

String describing which publishing operations this peer should perform.

The format is "(SIZE,SEED,TIME)*", for example: "(1,5,0)(7,3,13)" means to publish a file with 1 byte and seed/keyword 5 immediately and another file with 7 bytes and seed/keyword 3 after 13 ms.

Definition at line 134 of file gnunet-daemon-fsprofiler.c.

Referenced by run().

publish_head

struct Pattern* publish_head

static

Head of the DLL of publish patterns.

Definition at line 139 of file gnunet-daemon-fsprofiler.c.

Referenced by progress_cb(), run(), and shutdown_task().

publish_tail

struct Pattern* publish_tail

static

Tail of the DLL of publish patterns.

Definition at line 144 of file gnunet-daemon-fsprofiler.c.

Referenced by progress_cb(), run(), and shutdown_task().

download_pattern

char* download_pattern

static

String describing which download operations this peer should perform.

The format is "(KEYWORD,SIZE,DELAY)*"; for example, "(1,7,3)(3,8,8)" means to download one file of 7 bytes under keyword "1" starting the search after 3 ms; and another one of 8 bytes under keyword '3' starting after 8 ms. The file size is used to determine which search result(s) should be used or ignored.

Definition at line 154 of file gnunet-daemon-fsprofiler.c.

Referenced by run().

download_head

struct Pattern* download_head

static

Head of the DLL of publish patterns.

Definition at line 159 of file gnunet-daemon-fsprofiler.c.

Referenced by progress_cb(), run(), and shutdown_task().

download_tail

struct Pattern* download_tail

static

Tail of the DLL of publish patterns.

Definition at line 164 of file gnunet-daemon-fsprofiler.c.

Referenced by progress_cb(), run(), and shutdown_task().