src/transport/test_transport_ats.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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 testing/test_transport_ats.c
  22  * @brief testcase for ats functionality
  23  */
  24 #include "platform.h"
  25 #include "gnunet_testing_lib.h"
  26 #include "gnunet_transport_service.h"
  27 #include "gnunet_scheduler_lib.h"
  28 #include "gauger.h"
  29
  30 #define VERBOSE GNUNET_NO
  31
  32 #define NUM_PEERS 11
  33 #define MEASUREMENTS 5
  34
  35 #define DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  36 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  37 #define SEND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  38
  39 #define ATS_NEW 0
  40 #define ATS_Q_UPDATED 1
  41 #define ATS_C_UPDATED 2
  42 #define ATS_QC_UPDATED 3
  43 #define ATS_UNMODIFIED 4
  44
  45 static int ok;
  46
  47 static int peers_left;
  48
  49 static int failed_peers;
  50
  51 static int measurement_started = GNUNET_NO;
  52 static char * config_file;
  53
  54 static struct GNUNET_TESTING_PeerGroup *pg;
  55
  56 static  GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
  57 static  GNUNET_SCHEDULER_TaskIdentifier stats_task;
  58 static  GNUNET_SCHEDULER_TaskIdentifier send_task;
  59 struct GNUNET_TESTING_Daemon * master_deamon;
  60 struct GNUNET_TESTING_Daemon * ping_deamon;
  61
  62 struct GNUNET_STATISTICS_Handle * stats;
  63
  64 struct TEST_result
  65 {
  66         uint64_t timestamp;
  67         uint64_t duration;
  68         uint64_t mechs;
  69         uint64_t peers;
  70         uint64_t solution;
  71         uint64_t state;
  72 };
  73
  74 struct TestMessage
  75 {
  76   struct GNUNET_MessageHeader header;
  77   uint32_t num;
  78 };
  79
  80
  81 static int count;
  82 static int c_new;
  83 static int c_unmodified;
  84 static int c_modified;
  85 static int connected;
  86 static int peers;
  87
  88 static int force_q_updates;
  89 static int force_rebuild;
  90 static int send_msg;
  91 static int machine_parsable;
  92
  93 static struct TEST_result results_new       [MEASUREMENTS+1];
  94 static struct TEST_result results_modified  [MEASUREMENTS+1];
  95 static struct TEST_result results_unmodified[MEASUREMENTS+1];
  96 static struct TEST_result current;
  97
  98 static struct GNUNET_STATISTICS_GetHandle * s_solution;
  99 static struct GNUNET_STATISTICS_GetHandle * s_time;
 100 static struct GNUNET_STATISTICS_GetHandle * s_peers;
 101 static struct GNUNET_STATISTICS_GetHandle * s_mechs;
 102 static struct GNUNET_STATISTICS_GetHandle * s_duration;
 103 static struct GNUNET_STATISTICS_GetHandle * s_invalid;
 104 static struct GNUNET_STATISTICS_GetHandle * s_state;
 105
 106 struct GNUNET_TRANSPORT_TransmitHandle * t;
 107 struct GNUNET_TRANSPORT_Handle * th;
 108
 109 /**
 110  * Check whether peers successfully shut down.
 111  */
 112 void
 113 shutdown_callback (void *cls, const char *emsg)
 114 {
 115   if (emsg != NULL)
 116     {
 117 #if VERBOSE
 118       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
 119 #endif
 120       if (ok == 0)
 121         ok = 666;
 122     }
 123   else
 124     {
 125 #if VERBOSE
 126       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 127                   "All peers successfully shut down!\n");
 128         if (stats != NULL)
 129                 GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
 130         stats = NULL;
 131 #endif
 132     }
 133 }
 134
 135 static void shutdown_peers()
 136 {
 137         if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
 138         {
 139                 GNUNET_SCHEDULER_cancel(shutdown_task);
 140                 shutdown_task = GNUNET_SCHEDULER_NO_TASK;
 141         }
 142         if (stats_task != GNUNET_SCHEDULER_NO_TASK)
 143         {
 144                 GNUNET_SCHEDULER_cancel(stats_task);
 145                 stats_task = GNUNET_SCHEDULER_NO_TASK;
 146         }
 147         if (send_task != GNUNET_SCHEDULER_NO_TASK)
 148         {
 149                 GNUNET_SCHEDULER_cancel(send_task);
 150                 send_task = GNUNET_SCHEDULER_NO_TASK;
 151         }
 152
 153         if (t!=NULL)
 154         {
 155                 GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
 156                 t = NULL;
 157         }
 158
 159         GNUNET_TRANSPORT_disconnect(th);
 160
 161         if (s_time != NULL)
 162         {
 163                 GNUNET_STATISTICS_get_cancel(s_time);
 164                 s_time = NULL;
 165         }
 166         if (s_peers != NULL)
 167         {
 168                 GNUNET_STATISTICS_get_cancel(s_peers);
 169                 s_peers = NULL;
 170         }
 171         if (s_mechs != NULL)
 172         {
 173                 GNUNET_STATISTICS_get_cancel(s_mechs);
 174                 s_mechs = NULL;
 175         }
 176         if (s_solution != NULL)
 177         {
 178                 GNUNET_STATISTICS_get_cancel(s_solution);
 179                 s_solution = NULL;
 180         }
 181         if (s_duration != NULL)
 182         {
 183                 GNUNET_STATISTICS_get_cancel(s_duration);
 184                 s_duration = NULL;
 185         }
 186         if (s_invalid != NULL)
 187         {
 188                 GNUNET_STATISTICS_get_cancel(s_invalid);
 189                 s_invalid = NULL;
 190         }
 191         if (s_state != NULL)
 192         {
 193                 GNUNET_STATISTICS_get_cancel(s_state);
 194                 s_state = NULL;
 195         }
 196
 197     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 198 }
 199
 200 static void evaluate_measurements()
 201 {
 202         int c;
 203         //int mechs = 0;
 204         double average[3];
 205         double stddev[3];
 206         //char * output;
 207         c = 1;
 208
 209         //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
 210
 211         average[0] = 0.0;
 212         for (c=0; c<c_new;c++)
 213         {
 214                 average[0] += (double) results_new[c].duration;
 215         }
 216         average[0] /= c_new;
 217
 218         stddev[0] = 0.0;
 219         for (c=0; c<c_new;c++)
 220         {
 221                 stddev[0] += (results_new[c].duration - average[0]) * (results_new[c].duration - average[0]);
 222         }
 223         stddev[0] /= c_new;
 224         stddev[0] = sqrt (stddev[0]);
 225         if (!machine_parsable) GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"new, %i measurements, average: %f stddev: %f\n",
 226                         c_new, average[0], stddev[0]);
 227
 228         average[1] = 0.0;
 229         for (c=0; c<c_modified;c++)
 230         {
 231                 average[1] += (double) results_modified[c].duration;
 232         }
 233         average[1] /= c_modified;
 234
 235         stddev[1] = 0.0;
 236         for (c=0; c<c_modified;c++)
 237         {
 238                 stddev[1] += (results_modified[c].duration - average[1]) * (results_modified[c].duration - average[1]);
 239         }
 240         stddev[1] /= c_modified;
 241         stddev[1] = sqrt (stddev[1]);
 242         if (!machine_parsable) GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"modified, %i measurements, average: %f stddev: %f\n",
 243                         c_modified, average[1], stddev[1]);
 244
 245         average[2] = 0.0;
 246         for (c=0; c<c_unmodified;c++)
 247         {
 248                 average[2] += (double) results_unmodified[c].duration;
 249         }
 250         average[2] /= c_unmodified;
 251         stddev[2] = 0.0;
 252         for (c=0; c<c_unmodified;c++)
 253         {
 254                 stddev[2] += (results_unmodified[c].duration - average[2]) * (results_unmodified[c].duration - average[2]);
 255         }
 256         stddev[2] /= c_unmodified;
 257         stddev[2] = sqrt (stddev[2]);
 258
 259         if (!machine_parsable) GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"unmodified, %i measurements, average: %f stddev: %f\n",
 260                         c_unmodified, average[2], stddev[2]);
 261
 262         if (machine_parsable)
 263                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,",peers,%i,mechs,%i,"
 264                                         "new,%i,%f,%f,"
 265                                         "mod,%i,%f,%f,"
 266                                         "unmod,%i,%f,%f\n",
 267                                         peers-1, results_unmodified[0].mechs,
 268                                         c_new, average[0], stddev[0],
 269                                         c_modified, average[1], stddev[1],
 270                                         c_unmodified, average[2], stddev[2]);
 271         shutdown_peers();
 272 }
 273
 274 int stats_cb (void *cls,
 275                            const char *subsystem,
 276                            const char *name,
 277                            uint64_t value,
 278                            int is_persistent)
 279 {
 280         static int printed = GNUNET_NO;
 281         //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
 282         if (0 == strcmp (name,"ATS invalid solutions"))
 283         {
 284                 if (stats_task != GNUNET_SCHEDULER_NO_TASK)
 285                 {
 286                         GNUNET_SCHEDULER_cancel(stats_task);
 287                         stats_task = GNUNET_SCHEDULER_NO_TASK;
 288                 }
 289                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n", value);
 290                 shutdown_peers();
 291                 return GNUNET_SYSERR;
 292         }
 293
 294         if (0 == strcmp (name,"ATS solution"))
 295         {
 296                 s_solution = NULL;
 297         }
 298
 299         if (0 == strcmp (name,"ATS peers"))
 300         {
 301                 s_peers = NULL;
 302         }
 303
 304         if (0 == strcmp (name,"ATS mechanisms"))
 305         {
 306                 s_mechs = NULL;
 307         }
 308
 309         if (0 == strcmp (name,"ATS duration"))
 310         {
 311                 s_duration = NULL;
 312         }
 313         if (0 == strcmp (name,"ATS timestamp"))
 314         {
 315                 s_time = NULL;
 316         }
 317         if (0 == strcmp (name,"ATS state"))
 318         {
 319                 s_state = NULL;
 320         }
 321
 322     if ((measurement_started == GNUNET_NO) && (0 == strcmp (name, "ATS peers")) && (value == peers-1))
 323     {
 324                 measurement_started = GNUNET_YES;
 325                 count = 1;
 326                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All %llu peers connected\n", value);
 327 #if !VERBOSE
 328                 if (!machine_parsable)  fprintf(stderr, "%i", count);
 329 #endif
 330     }
 331
 332     if (measurement_started == GNUNET_YES)
 333     {
 334                 // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
 335                 if (0 == strcmp (name,"ATS timestamp"))
 336                 {
 337                         if (current.timestamp == 0)
 338                         {
 339                                 printed = GNUNET_NO;
 340                                 current.timestamp = value;
 341                         }
 342                         if (current.timestamp == value)
 343                         {
 344                                 printed = GNUNET_YES;
 345                         }
 346                         if (current.timestamp != value)
 347                         {
 348                                 if (current.state == ATS_NEW)
 349                                 {
 350                                         if (c_new < MEASUREMENTS)
 351                                         {
 352                                                 results_new[c_new] = current;
 353                                                 c_new++;
 354                                         }
 355                                         else
 356                                         {
 357                                           force_rebuild = GNUNET_NO;
 358                                           force_q_updates = GNUNET_NO;
 359                                           send_msg = GNUNET_NO;
 360                                         }
 361                                 }
 362                                 if (current.state == ATS_UNMODIFIED)
 363                                 {
 364                                         if (c_unmodified < MEASUREMENTS)
 365                                         {
 366                                                 results_unmodified[c_unmodified] = current;
 367                                                 c_unmodified++;
 368                                         }
 369
 370                                 }
 371                                 if (current.state == ATS_Q_UPDATED)
 372                                 {
 373                                         if (c_modified < MEASUREMENTS)
 374                                         {
 375                                                 results_modified[c_modified] = current;
 376                                                 c_modified++;
 377                                         }
 378                                         else
 379                                         {
 380                                                 force_q_updates = GNUNET_NO;
 381                                                 force_rebuild = GNUNET_YES;
 382                                         }
 383                                 }
 384                                 count ++;
 385
 386                                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "(new: %i / modified: %i / unmodified: %i) of %i \n", c_new, c_modified, c_unmodified , MEASUREMENTS);
 387                                 if ((count > MEASUREMENTS * 10) || ((c_modified >= MEASUREMENTS) && (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS)))
 388                                 {
 389 #if !VERBOSE
 390                                         if (!machine_parsable) fprintf(stdout, "\n");
 391 #endif
 392                                         if (stats_task != GNUNET_SCHEDULER_NO_TASK)
 393                                         {
 394                                                 GNUNET_SCHEDULER_cancel(stats_task);
 395                                                 stats_task = GNUNET_SCHEDULER_NO_TASK;
 396                                         }
 397                                         evaluate_measurements();
 398                                         return GNUNET_SYSERR;
 399                                 }
 400
 401                                 printed = GNUNET_NO;
 402                                 current.timestamp = value;
 403 #if !VERBOSE
 404                                 if (!machine_parsable) fprintf(stderr, "..%i", count);
 405 #endif
 406                                 return GNUNET_OK;
 407                         }
 408                 }
 409
 410                 if (0 == strcmp (name,"ATS solution"))
 411                 {
 412                         current.solution = value;
 413                         if (printed == GNUNET_NO) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 414                 }
 415
 416                 if (0 == strcmp (name,"ATS peers"))
 417                 {
 418                         current.peers = value;
 419                         if (printed == GNUNET_NO) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 420                 }
 421
 422                 if (0 == strcmp (name,"ATS mechanisms"))
 423                 {
 424                         current.mechs = value;
 425                         if (printed == GNUNET_NO) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 426                 }
 427
 428                 if (0 == strcmp (name,"ATS duration"))
 429                 {
 430                         current.duration = value;
 431                         if (printed == GNUNET_NO) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 432                 }
 433                 if (0 == strcmp (name,"ATS state"))
 434                 {
 435                         current.state = value;
 436                         char * cont;
 437                         if (value == ATS_NEW)
 438                                 cont = "NEW";
 439                         if (value == ATS_C_UPDATED)
 440                                 cont = "C_UPDATED";
 441                         if (value == ATS_Q_UPDATED)
 442                                 cont = "Q_UPDATED";
 443                         if (value == ATS_QC_UPDATED)
 444                                 cont = "QC_UPDATED";
 445                         if (value == ATS_UNMODIFIED)
 446                                 cont = "UNMODIFIED";
 447                         if (printed == GNUNET_NO) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] ATS state: %s\n", count, cont);
 448                 }
 449     }
 450     return GNUNET_OK;
 451 }
 452
 453
 454 void
 455 stats_get_task (void *cls,
 456                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 457 {
 458         stats_task = GNUNET_SCHEDULER_NO_TASK;
 459         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 460             return;
 461
 462         s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp", TIMEOUT, NULL, &stats_cb, NULL);
 463         s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution", TIMEOUT, NULL, &stats_cb, NULL);
 464         s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration", TIMEOUT, NULL, &stats_cb, NULL);
 465         s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers", TIMEOUT, NULL, &stats_cb, NULL);
 466         s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms", TIMEOUT, NULL, &stats_cb, NULL);
 467         s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions", TIMEOUT, NULL, &stats_cb, NULL);
 468         s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL, &stats_cb, NULL);
 469
 470         stats_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250), &stats_get_task, NULL);
 471 }
 472
 473 void
 474 delay (void *cls,
 475                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 476 {
 477         shutdown_task = GNUNET_SCHEDULER_NO_TASK;
 478         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 479             return;
 480
 481 #if VERBOSE
 482         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Delay over\n");
 483 #endif
 484         shutdown_peers ();
 485 }
 486
 487 static void connect_peers()
 488 {
 489     shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
 490
 491 }
 492
 493 size_t send_dummy_data_task (void *cls, size_t size, void *buf)
 494 {
 495
 496         int s = sizeof (struct TestMessage);
 497         struct TestMessage hdr;
 498
 499         hdr.header.size = htons (s);
 500         hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
 501         if (force_rebuild)
 502                 hdr.num = htonl (1);
 503         if (force_q_updates)
 504                 hdr.num = htonl (2);
 505
 506
 507         memcpy (buf,&hdr, s);
 508         // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
 509         t  = NULL;
 510         return s;
 511 }
 512
 513 void send_task_f (void *cls,
 514                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 515 {
 516         send_task = GNUNET_SCHEDULER_NO_TASK;
 517         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 518             return;
 519
 520         if (t!=NULL)
 521         {
 522                 GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
 523                 t = NULL;
 524         }
 525         // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i to %s\n", size, GNUNET_i2s(&master_deamon->id));
 526         if (send_msg == GNUNET_YES)
 527                 t = GNUNET_TRANSPORT_notify_transmit_ready(th, &master_deamon->id, sizeof (struct TestMessage), 0, SEND_TIMEOUT, &send_dummy_data_task, NULL);
 528         send_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000), &send_task_f, NULL);
 529 }
 530
 531
 532
 533 void daemon_connect_cb(void *cls,
 534                                                 const struct GNUNET_PeerIdentity *first,
 535                                                 const struct GNUNET_PeerIdentity *second,
 536                                                 uint32_t distance,
 537                                                 const struct GNUNET_CONFIGURATION_Handle *first_cfg,
 538                                                 const struct GNUNET_CONFIGURATION_Handle *second_cfg,
 539                                                 struct GNUNET_TESTING_Daemon *first_daemon,
 540                                                 struct GNUNET_TESTING_Daemon *second_daemon,
 541                                                 const char *emsg)
 542 {
 543         char * firstc =  strdup(GNUNET_i2s(first));
 544         char * secondc =  strdup(GNUNET_i2s(second));
 545         connected++;
 546         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected peers `%s'<->`%s' (%i/%i)\n", firstc, secondc, connected, peers-1);
 547         GNUNET_free(firstc);
 548         GNUNET_free(secondc);
 549
 550         if (((first_daemon == ping_deamon) || (second_daemon == ping_deamon)) && (master_deamon != NULL) && (ping_deamon != NULL))
 551         {
 552                   th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,&ping_deamon->id, NULL, NULL,NULL, NULL);
 553                   t = NULL;
 554                   force_q_updates = GNUNET_YES;
 555                   send_msg = GNUNET_YES;
 556                   send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
 557         }
 558 }
 559
 560 void cont_cb (void *cls, int success)
 561 {
 562     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 563                 "STATS cont_cb: %i\n", success);
 564 }
 565
 566 static void
 567 daemon_start_cb (void *cls,
 568        const struct GNUNET_PeerIdentity *id,
 569        const struct GNUNET_CONFIGURATION_Handle *cfg,
 570        struct GNUNET_TESTING_Daemon *d, const char *emsg)
 571 {
 572   if (id == NULL)
 573     {
 574       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 575                   "Start callback called with error (too long starting peers), aborting test!\n");
 576       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error from testing: `%s'\n");
 577       failed_peers++;
 578       if (failed_peers == peers_left)
 579         {
 580           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 581                       "Too many peers failed, ending test!\n");
 582           ok = 1;
 583         shutdown_peers ();
 584         }
 585       return;
 586     }
 587   peers_left--;
 588
 589   if (master_deamon == NULL)
 590   {
 591           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Master peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
 592
 593           master_deamon = d;
 594           stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
 595           GNUNET_assert (stats != NULL);
 596           stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
 597   }
 598   else
 599   {
 600           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting peer `%s'\n", GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
 601           GNUNET_TESTING_daemons_connect(d, master_deamon, TIMEOUT, 0, GNUNET_YES,&daemon_connect_cb, NULL);
 602   }
 603
 604   if (peers_left == 0)
 605     {
 606           if (ping_deamon == NULL)
 607           {
 608                   ping_deamon = d;
 609                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
 610           }
 611
 612           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 613                   "All peers started successfully!\n");
 614       connect_peers();
 615       ok = 0;
 616     }
 617   else if (failed_peers == peers_left)
 618     {
 619       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 620                   "Too many peers failed, ending test!\n");
 621       shutdown_peers();
 622       ok = 1;
 623     }
 624 }
 625
 626
 627 static void
 628 run (void *cls,
 629      char *const *args,
 630      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 631 {
 632   ok = 1;
 633   measurement_started = GNUNET_NO;
 634 #if VERBOSE
 635   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
 636 #endif
 637   peers_left = peers;
 638   pg = GNUNET_TESTING_daemons_start (cfg,
 639                                      peers_left, /* Total number of peers */
 640                                      peers_left, /* Number of outstanding connections */
 641                                      peers_left, /* Number of parallel ssh connections, or peers being started at once */
 642                                      TIMEOUT,
 643                                      NULL, NULL,
 644                                      &daemon_start_cb, NULL, NULL, NULL, NULL);
 645   GNUNET_assert (pg != NULL);
 646 }
 647
 648 static int
 649 check ()
 650 {
 651   char *const argv[] = { "test-testing",
 652     "-c",
 653     config_file,
 654 #if VERBOSE
 655     "-L", "DEBUG",
 656 #endif
 657     NULL
 658   };
 659   struct GNUNET_GETOPT_CommandLineOption options[] = {
 660     GNUNET_GETOPT_OPTION_END
 661   };
 662   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 663                       argv, "test-transport-ats", "nohelp",
 664                       options, &run, &ok);
 665   return ok;
 666 }
 667
 668 int
 669 main (int argc, char *argv[])
 670 {
 671 #if !HAVE_LIBGLPK
 672         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed, exiting testcase\n");
 673         return 0;
 674 #endif
 675
 676   int ret;
 677
 678   GNUNET_log_setup ("test-transport-ats",
 679 #if VERBOSE
 680                     "DEBUG",
 681 #else
 682                     "INFO",
 683 #endif
 684                     NULL);
 685   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 686
 687   machine_parsable = GNUNET_NO;
 688   peers = NUM_PEERS;
 689   config_file = "test_transport_ats_1addr.conf";
 690
 691   int c = 0;
 692   if (argc >= 2)
 693   {
 694          for (c=0; c<argc; c++)
 695          {
 696                  /* set peers */
 697                  if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
 698                  {
 699                           peers = atoi(argv[c+1]);
 700                           peers++;
 701                  }
 702                  /* set machine parsable */
 703                  if (strcmp(argv[c], "-m") == 0)
 704                  {
 705                          machine_parsable = GNUNET_YES;
 706                  }
 707                  /* set config file */
 708                  if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
 709                  {
 710                          config_file = argv[c+1];
 711                  }
 712          }
 713   }
 714
 715
 716
 717   ret = check ();
 718   /**
 719    * Still need to remove the base testing directory here,
 720    * because group starts will create subdirectories under this
 721    * main dir.  However, we no longer need to sleep, as the
 722    * shutdown sequence won't return until everything is cleaned
 723    * up.
 724    */
 725   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 726   return ret;
 727 }
 728
 729 /* end of test_transport_ats.c*/