gnunet-daemon-fsprofiler.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2012 Christian Grothoff

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

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

struct Pattern {
  struct Pattern *next;

  struct Pattern *prev;

  void *ctx;

  void *sctx;

  struct GNUNET_TIME_Absolute start_time;

  struct GNUNET_TIME_Relative delay;

  struct GNUNET_SCHEDULER_Task * task;

  struct GNUNET_SCHEDULER_Task * stask;

  unsigned long long x;

  unsigned long long y;
};


static int global_ret;

static const struct GNUNET_CONFIGURATION_Handle *cfg;

static struct GNUNET_STATISTICS_Handle *stats_handle;

static struct GNUNET_FS_Handle *fs_handle;

static unsigned long long my_peerid;

static unsigned long long anonymity_level;

static unsigned long long replication_level;

static char *publish_pattern;

static struct Pattern *publish_head;

static struct Pattern *publish_tail;

static char *download_pattern;

static struct Pattern *download_head;

static struct Pattern *download_tail;


static int
parse_pattern(struct Pattern **head,
              struct Pattern **tail,
              const char *pattern)
{
  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;
}


static struct GNUNET_FS_Uri *
make_keywords(uint64_t kval)
{
  char kw[128];

  GNUNET_snprintf(kw, sizeof(kw),
                  "%llu", (unsigned long long)kval);
  return GNUNET_FS_uri_ksk_create(kw, NULL);
}


static struct GNUNET_FS_FileInformation *
make_file(uint64_t length,
          uint64_t kval,
          void *ctx)
{
  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;
}


static void
shutdown_task(void *cls)
{
  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;
    }
}


static void
publish_stop_task(void *cls)
{
  struct Pattern *p = cls;

  p->task = NULL;
  GNUNET_FS_publish_stop(p->ctx);
}


static void
download_stop_task(void *cls)
{
  struct Pattern *p = cls;

  p->task = NULL;
  GNUNET_FS_download_stop(p->ctx, GNUNET_YES);
}


static void
search_stop_task(void *cls)
{
  struct Pattern *p = cls;

  p->stask = NULL;
  GNUNET_FS_search_stop(p->sctx);
}


static void *
progress_cb(void *cls,
            const struct GNUNET_FS_ProgressInfo *info)
{
  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;
    }
}


static void
start_publish(void *cls)
{
  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);
}


static void
start_download(void *cls)
{
  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);
}


static void
run(void *cls, char *const *args GNUNET_UNUSED,
    const char *cfgfile GNUNET_UNUSED,
    const struct GNUNET_CONFIGURATION_Handle *cfg_)
{
  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-%u", 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-%u", 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);
}


int
main(int argc, char *const *argv)
{
  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;
}

/* end of gnunet-daemon-fsprofiler.c */