src/nse/nse-profiler.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011 Christian Grothoff (and other contributing authors)
   4
   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.
   9
  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.
  14
  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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file nse/nse-profiler.c
  22  *
  23  * @brief Profiling driver for the network size estimation service.
  24  *        Generally, the profiler starts a given number of peers,
  25  *        then churns some off, waits a certain amount of time, then
  26  *        churns again, and repeats.
  27  */
  28 #include "platform.h"
  29 #include "gnunet_testing_lib.h"
  30 #include "gnunet_nse_service.h"
  31
  32 #define VERBOSE GNUNET_NO
  33
  34 struct NSEPeer
  35 {
  36   struct NSEPeer *prev;
  37
  38   struct NSEPeer *next;
  39
  40   struct GNUNET_TESTING_Daemon *daemon;
  41
  42   struct GNUNET_NSE_Handle *nse_handle;
  43 };
  44
  45 struct StatsContext
  46 {
  47   GNUNET_SCHEDULER_Task task;
  48   GNUNET_SCHEDULER_TaskIdentifier *task_id;
  49   void *task_cls;
  50   unsigned long long total_nse_bytes;
  51 };
  52
  53 static struct NSEPeer *peer_head;
  54
  55 static struct NSEPeer *peer_tail;
  56
  57 /**
  58  * How long until we give up on connecting the peers?
  59  */
  60 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1500)
  61
  62 static int ok;
  63
  64 /**
  65  * Be verbose
  66  */
  67 static int verbose;
  68
  69 /**
  70  * Total number of peers in the test.
  71  */
  72 static unsigned long long num_peers;
  73
  74 /**
  75  * Global configuration file
  76  */
  77 static struct GNUNET_CONFIGURATION_Handle *testing_cfg;
  78
  79 /**
  80  * Total number of currently running peers.
  81  */
  82 static unsigned long long peers_running;
  83
  84 /**
  85  * Current round we are in.
  86  */
  87 static unsigned long long current_round;
  88
  89 /**
  90  * Peers desired in the next round.
  91  */
  92 static unsigned long long peers_next_round;
  93
  94 /**
  95  * Maximum number of connections to NSE services.
  96  */
  97 static unsigned long long connection_limit;
  98
  99 /**
 100  * Total number of connections in the whole network.
 101  */
 102 static unsigned int total_connections;
 103
 104 /**
 105  * The currently running peer group.
 106  */
 107 static struct GNUNET_TESTING_PeerGroup *pg;
 108
 109 /**
 110  * File to report results to.
 111  */
 112 static struct GNUNET_DISK_FileHandle *output_file;
 113
 114 /**
 115  * File to log connection info, statistics to.
 116  */
 117 static struct GNUNET_DISK_FileHandle *data_file;
 118
 119 /**
 120  * How many data points to capture before triggering next round?
 121  */
 122 static struct GNUNET_TIME_Relative wait_time;
 123
 124 /**
 125  * Task called to disconnect peers.
 126  */
 127 static GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 128
 129 /**
 130  * Task called to shutdown test.
 131  */
 132 static GNUNET_SCHEDULER_TaskIdentifier shutdown_handle;
 133
 134 /**
 135  * Task used to churn the network.
 136  */
 137 static GNUNET_SCHEDULER_TaskIdentifier churn_task;
 138
 139 static char *topology_file;
 140
 141 static char *data_filename;
 142
 143 static uint64_t clock_skew;
 144
 145 /**
 146  * Check whether peers successfully shut down.
 147  */
 148 static void
 149 shutdown_callback (void *cls, const char *emsg)
 150 {
 151   if (emsg != NULL)
 152     {
 153 #if VERBOSE
 154       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
 155 #endif
 156       if (ok == 0)
 157         ok = 666;
 158     }
 159   else
 160     {
 161 #if VERBOSE
 162       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 163                   "All peers successfully shut down!\n");
 164 #endif
 165       ok = 0;
 166     }
 167 }
 168
 169 static void
 170 shutdown_task (void *cls,
 171                const struct GNUNET_SCHEDULER_TaskContext *tc)
 172 {
 173   struct NSEPeer *pos;
 174 #if VERBOSE
 175   fprintf(stderr, "Ending test.\n");
 176 #endif
 177
 178   if (disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 179     {
 180       GNUNET_SCHEDULER_cancel(disconnect_task);
 181       disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 182     }
 183   while (NULL != (pos = peer_head))
 184     {
 185       if (pos->nse_handle != NULL)
 186         GNUNET_NSE_disconnect(pos->nse_handle);
 187       GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, pos);
 188       GNUNET_free(pos);
 189     }
 190
 191   if (data_file != NULL)
 192     GNUNET_DISK_file_close(data_file);
 193   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 194 }
 195
 196 /**
 197  * Callback to call when network size estimate is updated.
 198  *
 199  * @param cls closure
 200  * @param estimate the value of the current network size estimate
 201  * @param std_dev standard deviation (rounded down to nearest integer)
 202  *                of the size estimation values seen
 203  *
 204  */
 205 static void
 206 handle_estimate (void *cls, double estimate, double std_dev)
 207 {
 208   struct NSEPeer *peer = cls;
 209   char *output_buffer;
 210   size_t size;
 211
 212   if (output_file != NULL)
 213     {
 214       size = GNUNET_asprintf(&output_buffer,
 215                              "%s %u %f %f %f\n",
 216                              GNUNET_i2s(&peer->daemon->id),
 217                              peers_running,
 218                              pow(2, estimate),
 219                              estimate,
 220                              std_dev);
 221       if (size != GNUNET_DISK_file_write(output_file, output_buffer, size))
 222         GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 223                    "Unable to write to file!\n");
 224       GNUNET_free (output_buffer);
 225     }
 226   else
 227     fprintf(stderr,
 228             "Received network size estimate from peer %s. Size: %f std.dev. %f\n",
 229             GNUNET_i2s(&peer->daemon->id),
 230             estimate,
 231             std_dev);
 232
 233 }
 234
 235 static void
 236 connect_nse_service (void *cls,
 237                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 238 {
 239   struct NSEPeer *current_peer;
 240   unsigned int i;
 241
 242 #if VERBOSE
 243   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 244               "Connecting to nse service of peers\n");
 245 #endif
 246   for (i = 0; i < num_peers; i++)
 247     {
 248       if ((connection_limit > 0) && (i % (num_peers / connection_limit) != 0))
 249         continue;
 250       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "TEST_NSE_MULTIPEER: connecting to nse service of peer %d\n", i);
 251       current_peer = GNUNET_malloc(sizeof(struct NSEPeer));
 252       current_peer->daemon = GNUNET_TESTING_daemon_get(pg, i);
 253       if (GNUNET_YES == GNUNET_TESTING_daemon_running(GNUNET_TESTING_daemon_get(pg, i)))
 254         {
 255           current_peer->nse_handle = GNUNET_NSE_connect (current_peer->daemon->cfg,
 256                                                          &handle_estimate,
 257                                                          current_peer);
 258           GNUNET_assert(current_peer->nse_handle != NULL);
 259         }
 260       GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
 261     }
 262 }
 263
 264
 265 static void
 266 churn_peers (void *cls,
 267              const struct GNUNET_SCHEDULER_TaskContext *tc);
 268
 269
 270 /**
 271  * Continuation called by the "get_all" and "get" functions.
 272  *
 273  * @param cls struct StatsContext
 274  * @param success GNUNET_OK if statistics were
 275  *        successfully obtained, GNUNET_SYSERR if not.
 276  */
 277 static void
 278 stats_finished_callback (void *cls, int success)
 279 {
 280   struct StatsContext *stats_context = (struct StatsContext *)cls;
 281   char *buf;
 282   int buf_len;
 283
 284   if ((GNUNET_OK == success) && (data_file != NULL)) /* Stats lookup successful, write out data */
 285     {
 286       buf = NULL;
 287       buf_len = GNUNET_asprintf(&buf,
 288                                 "TOTAL_NSE_BYTES: %u\n",
 289                                 stats_context->total_nse_bytes);
 290       if (buf_len > 0)
 291         {
 292           GNUNET_DISK_file_write(data_file, buf, buf_len);
 293         }
 294       GNUNET_free_non_null(buf);
 295     }
 296
 297   if (stats_context->task != NULL)
 298     *stats_context->task_id = GNUNET_SCHEDULER_add_now(stats_context->task,
 299                                                        stats_context->task_cls);
 300   GNUNET_free(stats_context);
 301 }
 302
 303
 304 /**
 305  * Callback function to process statistic values.
 306  *
 307  * @param cls struct StatsContext
 308  * @param peer the peer the statistics belong to
 309  * @param subsystem name of subsystem that created the statistic
 310  * @param name the name of the datum
 311  * @param value the current value
 312  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
 313  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
 314  */
 315 static int
 316 statistics_iterator (void *cls,
 317                      const struct GNUNET_PeerIdentity *peer,
 318                      const char *subsystem,
 319                      const char *name,
 320                      uint64_t value,
 321                      int is_persistent)
 322 {
 323   struct StatsContext *stats_context = cls;
 324   char *buf;
 325
 326   GNUNET_assert(0 < GNUNET_asprintf(&buf,
 327                                     "bytes of messages of type %d received",
 328                                     GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD));
 329   if ((0 == strstr(subsystem, "core")) && (0 == strstr(name, buf)))
 330     {
 331       stats_context->total_nse_bytes += value;
 332     }
 333   GNUNET_free(buf);
 334   return GNUNET_OK;
 335 }
 336
 337
 338 /**
 339  * @param cls struct StatsContext
 340  * @param tc task context
 341  */
 342 static void
 343 get_statistics (void *cls,
 344                 const struct GNUNET_SCHEDULER_TaskContext *tc)
 345 {
 346   struct StatsContext *stats_context = cls;
 347
 348   GNUNET_TESTING_get_statistics(pg,
 349                                 &stats_finished_callback,
 350                                 &statistics_iterator,
 351                                 stats_context);
 352 }
 353
 354
 355 static void
 356 disconnect_nse_peers (void *cls,
 357                       const struct GNUNET_SCHEDULER_TaskContext *tc)
 358 {
 359   struct NSEPeer *pos;
 360   char *buf;
 361   struct StatsContext *stats_context;
 362   disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 363   pos = peer_head;
 364
 365   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 366               "disconnecting nse service of peers\n");
 367   while (NULL != (pos = peer_head))
 368     {
 369       if (pos->nse_handle != NULL)
 370         {
 371           GNUNET_NSE_disconnect(pos->nse_handle);
 372           pos->nse_handle = NULL;
 373         }
 374       GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, pos);
 375       GNUNET_free(pos);
 376     }
 377
 378   GNUNET_asprintf(&buf,
 379                   "round%llu",
 380                   current_round);
 381   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (testing_cfg,
 382                                                           "nse-profiler",
 383                                                           buf,
 384                                                           &peers_next_round))
 385     {
 386       current_round++;
 387       GNUNET_assert(churn_task == GNUNET_SCHEDULER_NO_TASK);
 388       churn_task = GNUNET_SCHEDULER_add_now(&churn_peers, NULL);
 389     }
 390   else /* No more rounds, let's shut it down! */
 391     {
 392       stats_context = GNUNET_malloc(sizeof(struct StatsContext));
 393       GNUNET_SCHEDULER_cancel(shutdown_handle);
 394       shutdown_handle = GNUNET_SCHEDULER_NO_TASK;
 395       stats_context->task = &shutdown_task;
 396       stats_context->task_cls = NULL;
 397       stats_context->task_id = &shutdown_handle;
 398       GNUNET_SCHEDULER_add_now(&get_statistics, stats_context);
 399       //shutdown_handle = GNUNET_SCHEDULER_add_now(&shutdown_task, NULL);
 400     }
 401   GNUNET_free(buf);
 402 }
 403
 404
 405 /**
 406  * Prototype of a function that will be called when a
 407  * particular operation was completed the testing library.
 408  *
 409  * @param cls unused
 410  * @param emsg NULL on success
 411  */
 412 static void
 413 topology_output_callback (void *cls, const char *emsg)
 414 {
 415   struct StatsContext *stats_context;
 416   stats_context = GNUNET_malloc(sizeof(struct StatsContext));
 417
 418   disconnect_task = GNUNET_SCHEDULER_add_delayed(wait_time, &disconnect_nse_peers, NULL);
 419   GNUNET_SCHEDULER_add_now(&connect_nse_service, NULL);
 420 }
 421
 422
 423 /**
 424  * Prototype of a function that will be called when a
 425  * particular operation was completed the testing library.
 426  *
 427  * @param cls closure
 428  * @param emsg NULL on success
 429  */
 430 static void
 431 churn_callback (void *cls, const char *emsg)
 432 {
 433   char *temp_output_file;
 434
 435   if (emsg == NULL) /* Everything is okay! */
 436     {
 437       peers_running = GNUNET_TESTING_daemons_running(pg);
 438       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 439                   "Round %lu, churn finished successfully.\n",
 440                   current_round);
 441       GNUNET_assert(disconnect_task == GNUNET_SCHEDULER_NO_TASK);
 442       GNUNET_asprintf(&temp_output_file,
 443                       "%s_%lu.dot",
 444                       topology_file,
 445                       current_round);
 446       GNUNET_TESTING_peergroup_topology_to_file(pg,
 447                                                 temp_output_file,
 448                                                 &topology_output_callback,
 449                                                 NULL);
 450       GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 451                  "Writing topology to file %s\n",
 452                  temp_output_file);
 453       GNUNET_free(temp_output_file);
 454     }
 455   else
 456     {
 457       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 458                   "Round %lu, churn FAILED!!\n",
 459                   current_round);
 460       GNUNET_SCHEDULER_cancel(shutdown_handle);
 461       GNUNET_SCHEDULER_add_now(&shutdown_task, NULL);
 462     }
 463 }
 464
 465
 466 static void
 467 churn_peers (void *cls,
 468              const struct GNUNET_SCHEDULER_TaskContext *tc)
 469 {
 470   peers_running = GNUNET_TESTING_daemons_running(pg);
 471   churn_task = GNUNET_SCHEDULER_NO_TASK;
 472   if (peers_next_round == peers_running)
 473     {
 474       /* Nothing to do... */
 475       GNUNET_SCHEDULER_add_now(&connect_nse_service, NULL);
 476       GNUNET_assert(disconnect_task == GNUNET_SCHEDULER_NO_TASK);
 477       disconnect_task = GNUNET_SCHEDULER_add_delayed(wait_time,
 478                                                      &disconnect_nse_peers, NULL);
 479       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
 480                  "Round %lu, doing nothing!\n",
 481                  current_round);
 482     }
 483   else
 484     {
 485       if (peers_next_round > num_peers)
 486         {
 487           GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 488                      "Asked to turn on more peers than have!!\n");
 489           GNUNET_SCHEDULER_cancel(shutdown_handle);
 490           GNUNET_SCHEDULER_add_now(&shutdown_task, NULL);
 491         }
 492       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 493                   "Round %lu, turning off %lu peers, turning on %lu peers!\n",
 494                   current_round,
 495                   (peers_running > peers_next_round) ? peers_running
 496                       - peers_next_round : 0,
 497                   (peers_next_round > peers_running) ? peers_next_round
 498                       - peers_running : 0);
 499       GNUNET_TESTING_daemons_churn (pg, "nse",
 500                                     (peers_running > peers_next_round) ? peers_running
 501                                         - peers_next_round
 502                                         : 0,
 503                                     (peers_next_round > peers_running) ? peers_next_round
 504                                         - peers_running
 505                                         : 0, wait_time, &churn_callback,
 506                                     NULL);
 507     }
 508 }
 509
 510
 511 static void
 512 my_cb (void *cls,
 513        const char *emsg)
 514 {
 515   char *buf;
 516   int buf_len;
 517   if (emsg != NULL)
 518     {
 519       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 520                   "Peergroup callback called with error, aborting test!\n");
 521       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error from testing: `%s'\n");
 522       ok = 1;
 523       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 524       return;
 525     }
 526 #if VERBOSE
 527   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 528               "Peer Group started successfully, connecting to NSE service for each peer!\n");
 529 #endif
 530   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 531               "Have %u connections\n", total_connections);
 532   if (data_file != NULL)
 533     {
 534       buf = NULL;
 535       buf_len = GNUNET_asprintf(&buf,
 536                                 "CONNECTIONS_0: %u\n",
 537                                 total_connections);
 538       if (buf_len > 0)
 539         GNUNET_DISK_file_write(data_file, buf, buf_len);
 540       GNUNET_free (buf);
 541     }
 542   peers_running = GNUNET_TESTING_daemons_running(pg);
 543   GNUNET_SCHEDULER_add_now(&connect_nse_service, NULL);
 544   disconnect_task = GNUNET_SCHEDULER_add_delayed(wait_time, &disconnect_nse_peers, NULL);
 545 }
 546
 547
 548 /**
 549  * Function that will be called whenever two daemons are connected by
 550  * the testing library.
 551  *
 552  * @param cls closure
 553  * @param first peer id for first daemon
 554  * @param second peer id for the second daemon
 555  * @param distance distance between the connected peers
 556  * @param first_cfg config for the first daemon
 557  * @param second_cfg config for the second daemon
 558  * @param first_daemon handle for the first daemon
 559  * @param second_daemon handle for the second daemon
 560  * @param emsg error message (NULL on success)
 561  */
 562 static void
 563 connect_cb (void *cls,
 564             const struct GNUNET_PeerIdentity *first,
 565             const struct GNUNET_PeerIdentity *second,
 566             uint32_t distance,
 567             const struct GNUNET_CONFIGURATION_Handle *first_cfg,
 568             const struct GNUNET_CONFIGURATION_Handle *second_cfg,
 569             struct GNUNET_TESTING_Daemon *first_daemon,
 570             struct GNUNET_TESTING_Daemon *second_daemon,
 571             const char *emsg)
 572 {
 573   if (emsg == NULL)
 574     total_connections++;
 575 }
 576
 577
 578 static void
 579 run (void *cls,
 580      char *const *args,
 581      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 582 {
 583   char *temp_str;
 584   unsigned long long temp_wait;
 585
 586   ok = 1;
 587   testing_cfg = GNUNET_CONFIGURATION_create();
 588   GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_load(testing_cfg, cfgfile));
 589 #if VERBOSE
 590   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
 591   GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing",
 592                                            "use_progressbars",
 593                                            "YES");
 594 #endif
 595   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (testing_cfg,
 596                                                           "testing",
 597                                                           "num_peers", &num_peers))
 598     {
 599       GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Option TESTING:NUM_PEERS is required!\n");
 600       return;
 601     }
 602
 603   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (testing_cfg,
 604                                                           "nse-profiler",
 605                                                           "wait_time",
 606                                                           &temp_wait))
 607     {
 608       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 609                  "Option nse-profiler:wait_time is required!\n");
 610       return;
 611     }
 612
 613   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (testing_cfg,
 614                                                           "nse-profiler", "connection_limit",
 615                                                           &connection_limit))
 616     {
 617       connection_limit = 0;
 618     }
 619
 620   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (testing_cfg,
 621                                                           "nse-profiler", "topology_output_file",
 622                                                           &topology_file))
 623     {
 624       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 625                  "Option nse-profiler:topology_output_file is required!\n");
 626       return;
 627     }
 628
 629   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (testing_cfg,
 630                                                           "nse-profiler", "data_output_file",
 631                                                           &data_filename))
 632     {
 633       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 634                  "Option nse-profiler:data_output_file is required!\n");
 635       return;
 636     }
 637
 638   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (testing_cfg,
 639                                                           "nse-profiler",
 640                                                           "skew_clock"))
 641     {
 642       GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 643                  "Setting our clock as skewed...\n");
 644       clock_skew = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
 645                                             GNUNET_TIME_UNIT_MINUTES.rel_value);
 646     }
 647
 648
 649   data_file = GNUNET_DISK_file_open (data_filename,
 650                                      GNUNET_DISK_OPEN_READWRITE
 651                                      | GNUNET_DISK_OPEN_CREATE,
 652                                      GNUNET_DISK_PERM_USER_READ |
 653                                      GNUNET_DISK_PERM_USER_WRITE);
 654   if (data_file == NULL)
 655     GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 656                "Failed to open %s for output!\n",
 657                data_filename);
 658   GNUNET_free(data_filename);
 659
 660   wait_time = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_wait);
 661
 662   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(cfg,
 663                                                           "nse-profiler",
 664                                                           "output_file",
 665                                                           &temp_str))
 666     {
 667       output_file = GNUNET_DISK_file_open (temp_str, GNUNET_DISK_OPEN_READWRITE
 668                                                       | GNUNET_DISK_OPEN_CREATE,
 669                                                       GNUNET_DISK_PERM_USER_READ |
 670                                                       GNUNET_DISK_PERM_USER_WRITE);
 671       if (output_file == NULL)
 672         GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 673                    "Failed to open %s for output!\n",
 674                    temp_str);
 675     }
 676   GNUNET_free_non_null(temp_str);
 677
 678   pg = GNUNET_TESTING_peergroup_start(testing_cfg,
 679                                       num_peers,
 680                                       TIMEOUT,
 681                                       &connect_cb,
 682                                       &my_cb, NULL,
 683                                       NULL);
 684   GNUNET_assert (pg != NULL);
 685   shutdown_handle = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_get_forever(),
 686                                                   &shutdown_task,
 687                                                   NULL);
 688 }
 689
 690
 691
 692 /**
 693  * nse-profiler command line options
 694  */
 695 static struct GNUNET_GETOPT_CommandLineOption options[] = {
 696   {'V', "verbose", NULL,
 697    gettext_noop ("be verbose (print progress information)"),
 698    0, &GNUNET_GETOPT_set_one, &verbose},
 699   GNUNET_GETOPT_OPTION_END
 700 };
 701
 702
 703 int
 704 main (int argc, char *argv[])
 705 {
 706   int ret;
 707
 708   GNUNET_log_setup ("nse-profiler",
 709 #if VERBOSE
 710                     "DEBUG",
 711 #else
 712                     "WARNING",
 713 #endif
 714                     NULL);
 715   ret = 1;
 716   GNUNET_PROGRAM_run (argc,
 717                       argv, "nse-profiler", gettext_noop
 718                       ("Run a test of the NSE service."),
 719                       options, &run, &ok);
 720   GNUNET_DISK_directory_remove ("/tmp/nse-profiler");
 721   return ret;
 722 }
 723
 724 /* end of nse-profiler.c */