GNUnet  0.19.4
gnunet-daemon-fsprofiler.c File Reference

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

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_Urimake_keywords (uint64_t kval)
 Create a KSK URI from a number. More...
 
static struct GNUNET_FS_FileInformationmake_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_Handlecfg
 Configuration we use. More...
 
static struct GNUNET_STATISTICS_Handlestats_handle
 Handle to the statistics service. More...
 
static struct GNUNET_FS_Handlefs_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 Patternpublish_head
 Head of the DLL of publish patterns. More...
 
static struct Patternpublish_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 Patterndownload_head
 Head of the DLL of publish patterns. More...
 
static struct Patterndownload_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
headwhere to store the head
tailwhere to store the tail
patternpattern to parse
Returns
GNUNET_OK on success

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

180 {
181  struct Pattern *p;
182  unsigned long long x;
183  unsigned long long y;
184  unsigned long long t;
185 
186  while (3 == sscanf (pattern,
187  "(%llu,%llu,%llu)",
188  &x, &y, &t))
189  {
190  p = GNUNET_new (struct Pattern);
191  p->x = x;
192  p->y = y;
193  p->delay.rel_value_us = (uint64_t) t;
195  pattern = strstr (pattern, ")");
196  GNUNET_assert (NULL != pattern);
197  pattern++;
198  }
199  return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
200 }
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:235
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
@ GNUNET_OK
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
We use 'patterns' of the form (x,y,t) to specify desired download/publish activities of a peer.
unsigned long long y
Y-value.
unsigned long long x
X-value.

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
kvalthe number
Returns
corresponding KSK URI

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

211 {
212  char kw[128];
213 
214  GNUNET_snprintf (kw, sizeof(kw),
215  "%llu", (unsigned long long) kval);
216  return GNUNET_FS_uri_ksk_create (kw, NULL);
217 }
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
Create an FS URI from a single user-supplied string of keywords.
Definition: fs_uri.c:1049
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.

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
lengthnumber of bytes in the file
kvalkeyword value and seed for the data of the file
ctxcontext to pass to 'fi'
Returns
file information handle for the file

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

233 {
234  struct GNUNET_FS_FileInformation *fi;
235  struct GNUNET_FS_BlockOptions bo;
236  char *data;
237  struct GNUNET_FS_Uri *keywords;
238  unsigned long long i;
239  uint64_t xor;
240 
241  data = NULL; /* to make compilers happy */
242  if ((0 != length) &&
243  (NULL == (data = GNUNET_malloc_large ((size_t) length))))
244  return NULL;
245  /* initialize data with 'unique' data only depending on 'kval' and 'size',
246  making sure that blocks do not repeat */
247  for (i = 0; i < length; i += 8)
248  {
249  xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
250  GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof(uint64_t)));
251  }
253  bo.anonymity_level = (uint32_t) anonymity_level;
254  bo.content_priority = 128;
256  keywords = make_keywords (kval);
258  ctx,
259  length,
260  data, keywords,
261  NULL, GNUNET_NO, &bo);
263  return fi;
264 }
static struct GNUNET_FS_Uri * make_keywords(uint64_t kval)
Create a KSK URI from a number.
static unsigned long long replication_level
Desired replication level.
static unsigned long long anonymity_level
Desired anonymity level.
static struct GNUNET_FS_Handle * fs_handle
Peer's FS handle.
uint32_t data
The data value.
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_data(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, void *data, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_FS_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MIN(a, b)
@ GNUNET_NO
#define GNUNET_malloc_large(size)
Wrapper around malloc.
#define GNUNET_TIME_UNIT_DAYS
One day.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:316
Settings for publishing a block (which may of course also apply to an entire directory or file).
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP,...
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority,...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
Information for a file or directory that is about to be published.
Definition: fs_api.h:228
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167
char ** keywords
Keywords start with a '+' if they are mandatory (in which case the '+' is NOT part of the keyword) an...
Definition: fs_api.h:186

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
clsunused

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

274 {
275  struct Pattern *p;
276 
277  while (NULL != (p = publish_head))
278  {
279  if (NULL != p->task)
280  GNUNET_SCHEDULER_cancel (p->task);
281  if (NULL != p->ctx)
282  GNUNET_FS_publish_stop (p->ctx);
284  GNUNET_free (p);
285  }
286  while (NULL != (p = download_head))
287  {
288  if (NULL != p->task)
289  GNUNET_SCHEDULER_cancel (p->task);
290  if (NULL != p->stask)
291  GNUNET_SCHEDULER_cancel (p->stask);
292  if (NULL != p->ctx)
294  if (NULL != p->sctx)
295  GNUNET_FS_search_stop (p->sctx);
297  GNUNET_free (p);
298  }
299  if (NULL != fs_handle)
300  {
302  fs_handle = NULL;
303  }
304  if (NULL != stats_handle)
305  {
307  stats_handle = NULL;
308  }
309 }
static struct Pattern * download_tail
Tail of the DLL of publish patterns.
static struct Pattern * publish_head
Head of the DLL of publish patterns.
static struct GNUNET_STATISTICS_Handle * stats_handle
Handle to the statistics service.
static struct Pattern * publish_tail
Tail of the DLL of publish patterns.
static struct Pattern * download_head
Head of the DLL of publish patterns.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1766
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2254
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3310
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1571
@ GNUNET_YES
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

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
clsthe 'struct Pattern' of the publish operation to stop

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

319 {
320  struct Pattern *p = cls;
321 
322  p->task = NULL;
323  GNUNET_FS_publish_stop (p->ctx);
324 }

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
clsthe 'struct Pattern' of the download operation to stop

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

334 {
335  struct Pattern *p = cls;
336 
337  p->task = NULL;
339 }

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
clsthe 'struct Pattern' of the download operation to stop

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

349 {
350  struct Pattern *p = cls;
351 
352  p->stask = NULL;
353  GNUNET_FS_search_stop (p->sctx);
354 }

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
clsclosure
infodetails 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.

375 {
376  struct Pattern *p;
377  const struct GNUNET_FS_Uri *uri;
378 
379  switch (info->status)
380  {
383  p = info->value.publish.cctx;
384  return p;
385 
387  p = info->value.publish.cctx;
388  return p;
389 
392  "Publishing failed\n");
394  "# failed publish operations", 1, GNUNET_NO);
395  p = info->value.publish.cctx;
397  return p;
398 
400  p = info->value.publish.cctx;
402  "# publishing time (ms)",
404  p->start_time).rel_value_us / 1000LL,
405  GNUNET_NO);
407  return p;
408 
410  p = info->value.publish.cctx;
411  p->ctx = NULL;
413  GNUNET_free (p);
414  return NULL;
415 
420  p = info->value.download.cctx;
421  return p;
422 
425  "Download failed\n");
427  "# failed downloads", 1, GNUNET_NO);
428  p = info->value.download.cctx;
430  return p;
431 
433  p = info->value.download.cctx;
435  "# download time (ms)",
437  p->start_time).rel_value_us / 1000LL,
438  GNUNET_NO);
440  return p;
441 
443  p = info->value.download.cctx;
444  p->ctx = NULL;
445  if (NULL == p->sctx)
446  {
448  GNUNET_free (p);
449  }
450  return NULL;
451 
454  p = info->value.search.cctx;
455  return p;
456 
458  p = info->value.search.cctx;
459  uri = info->value.search.specifics.result.uri;
461  return NULL; /* not what we want */
463  return NULL; /* not what we want */
465  "# search time (ms)",
467  p->start_time).rel_value_us / 1000LL,
468  GNUNET_NO);
469  p->start_time = GNUNET_TIME_absolute_get ();
471  NULL, NULL, NULL,
475  p,
476  NULL);
478  return NULL;
479 
482  return NULL; /* don't care */
483 
486  "Search failed\n");
488  "# failed searches", 1, GNUNET_NO);
489  p = info->value.search.cctx;
491  return p;
492 
494  p = info->value.search.cctx;
495  p->sctx = NULL;
496  if (NULL == p->ctx)
497  {
499  GNUNET_free (p);
500  }
501  return NULL;
502 
503  default:
504  /* unexpected event during profiling */
505  GNUNET_break (0);
506  return NULL;
507  }
508 }
static void publish_stop_task(void *cls)
Task run when a publish operation should be stopped.
static void search_stop_task(void *cls)
Task run when a download operation should be stopped.
static void download_stop_task(void *cls)
Task run when a download operation should be stopped.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
#define info
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1360
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx, struct GNUNET_FS_DownloadContext *parent)
Download parts of a file.
Definition: fs_download.c:2100
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1346
@ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
@ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
@ GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE
We have discovered a new namespace.
@ GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
@ GNUNET_FS_STATUS_SEARCH_ERROR
Signals a problem with this search.
@ GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
@ GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
@ GNUNET_FS_STATUS_PUBLISH_STOPPED
Notification that we have stopped the process of uploading a file structure; no further events will b...
@ GNUNET_FS_STATUS_PUBLISH_ERROR
Notification that an error was encountered sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS
Notification that we are making progress sharing a file structure.
@ GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
@ GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY
Notification that we are making progress sharing a directory.
@ GNUNET_FS_STATUS_PUBLISH_START
Notification that we have started to publish a file structure.
@ GNUNET_FS_STATUS_PUBLISH_COMPLETED
Notification that we completed sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
@ GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
Notification that this download is now actively being pursued (as opposed to waiting in the queue).
@ GNUNET_FS_STATUS_DOWNLOAD_STOPPED
Notification that this download was stopped (final event with respect to this action).
@ GNUNET_FS_STATUS_SEARCH_STOPPED
Last message from a search; this signals that there will be no further events associated with this se...
#define GNUNET_log(kind,...)
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
uint64_t rel_value_us
The actual value.

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
clsthe 'struct Pattern' specifying the operation to perform

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

518 {
519  struct Pattern *p = cls;
520  struct GNUNET_FS_FileInformation *fi;
521 
522  p->task = NULL;
523  fi = make_file (p->x, p->y, p);
524  p->start_time = GNUNET_TIME_absolute_get ();
526  fi,
527  NULL, NULL, NULL,
529 }
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 '...
struct GNUNET_FS_PublishContext * GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, struct GNUNET_FS_FileInformation *fi, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *nid, const char *nuid, enum GNUNET_FS_PublishOptions options)
Publish a file or directory.
Definition: fs_publish.c:1443
@ GNUNET_FS_PUBLISH_OPTION_NONE
No options (use defaults for everything).

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
clsthe 'struct Pattern' specifying the operation to perform

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

539 {
540  struct Pattern *p = cls;
541  struct GNUNET_FS_Uri *keywords;
542 
543  p->task = NULL;
544  keywords = make_keywords (p->x);
545  p->start_time = GNUNET_TIME_absolute_get ();
549  p);
550 }
struct GNUNET_FS_SearchContext * GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
Start search for content.
Definition: fs_search.c:1607
@ GNUNET_FS_SEARCH_OPTION_NONE
No options (use defaults for everything).

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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfg_configuration

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

565 {
566  char myoptname[128];
567  struct Pattern *p;
568 
569  cfg = cfg_;
570  /* Scheduled the task to clean up when shutdown is called */
572  NULL);
573 
574  if (GNUNET_OK !=
576  "TESTBED", "PEERID",
577  &my_peerid))
578  {
580  "TESTBED", "PEERID");
583  return;
584  }
585  if (GNUNET_OK !=
587  "FSPROFILER", "ANONYMITY_LEVEL",
588  &anonymity_level))
589  anonymity_level = 1;
590  if (GNUNET_OK !=
592  "FSPROFILER", "REPLICATION_LEVEL",
594  replication_level = 1;
595  GNUNET_snprintf (myoptname, sizeof(myoptname),
596  "DOWNLOAD-PATTERN-%llu", my_peerid);
597  if (GNUNET_OK !=
599  "FSPROFILER", myoptname,
602  GNUNET_snprintf (myoptname, sizeof(myoptname),
603  "PUBLISH-PATTERN-%llu", my_peerid);
604  if (GNUNET_OK !=
606  "FSPROFILER", myoptname,
607  &publish_pattern))
609  if ((GNUNET_OK !=
611  &download_tail,
612  download_pattern)) ||
613  (GNUNET_OK !=
615  &publish_tail,
616  publish_pattern)))
617  {
619  return;
620  }
621 
622  stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
623  fs_handle =
625  "fsprofiler",
626  &progress_cb, NULL,
631  if (NULL == fs_handle)
632  {
634  "Could not acquire FS handle. Exiting.\n");
637  return;
638  }
639  for (p = publish_head; NULL != p; p = p->next)
640  p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
641  &start_publish, p);
642  for (p = download_head; NULL != p; p = p->next)
643  p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
644  &start_download, p);
645 }
static char * publish_pattern
String describing which publishing operations this peer should perform.
static int global_ret
Return value from 'main'.
static char * download_pattern
String describing which download operations this peer should perform.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we use.
static void shutdown_task(void *cls)
Task run during shutdown.
static void start_download(void *cls)
Start download operation.
static unsigned long long my_peerid
Unique number for this peer in the testbed.
static void * progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS to a client about the progress of an operation.
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.
static void start_publish(void *cls)
Start publish operation.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
struct GNUNET_FS_Handle * GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *client_name, GNUNET_FS_ProgressCallback upcb, void *upcb_cls, enum GNUNET_FS_Flags flags,...)
Setup a connection to the file-sharing service.
Definition: fs_api.c:3244
@ GNUNET_FS_FLAGS_NONE
No special flags set.
@ GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
@ GNUNET_FS_OPTIONS_REQUEST_PARALLELISM
Maximum number of requests that should be pending at a given point in time (invidivual downloads may ...
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1334
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1272
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.

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
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

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

657 {
658  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
660  };
661 
662  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
663  return 2;
664  return (GNUNET_OK ==
665  GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
667  (
668  "Daemon to use file-sharing to measure its performance."),
669  options, &run, NULL)) ? global_ret : 1;
670 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:70
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.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1222
Definition of a command line option.

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().