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)
 226           fprintf (stderr,
 227                    "new, %i measurements, average: %f stddev: %f\n",
 228                    c_new, average[0], stddev[0]);
 229
 230         average[1] = 0.0;
 231         for (c=0; c<c_modified;c++)
 232         {
 233                 average[1] += (double) results_modified[c].duration;
 234         }
 235         average[1] /= c_modified;
 236
 237         stddev[1] = 0.0;
 238         for (c=0; c<c_modified;c++)
 239         {
 240                 stddev[1] += (results_modified[c].duration - average[1]) * (results_modified[c].duration - average[1]);
 241         }
 242         stddev[1] /= c_modified;
 243         stddev[1] = sqrt (stddev[1]);
 244         if (!machine_parsable)
 245           fprintf (stderr,
 246                    "modified, %i measurements, average: %f stddev: %f\n",
 247                    c_modified, average[1], stddev[1]);
 248
 249         average[2] = 0.0;
 250         for (c=0; c<c_unmodified;c++)
 251         {
 252                 average[2] += (double) results_unmodified[c].duration;
 253         }
 254         average[2] /= c_unmodified;
 255         stddev[2] = 0.0;
 256         for (c=0; c<c_unmodified;c++)
 257         {
 258                 stddev[2] += (results_unmodified[c].duration - average[2]) * (results_unmodified[c].duration - average[2]);
 259         }
 260         stddev[2] /= c_unmodified;
 261         stddev[2] = sqrt (stddev[2]);
 262
 263         if (!machine_parsable)
 264           fprintf (stderr,
 265                    "unmodified, %i measurements, average: %f stddev: %f\n",
 266                    c_unmodified, average[2], stddev[2]);
 267
 268         if (machine_parsable)
 269           fprintf (stderr,
 270                    "peers,%i,mechs,%lu,"
 271                    "new,%i,%f,%f,"
 272                    "mod,%i,%f,%f,"
 273                    "unmod,%i,%f,%f\n",
 274                    peers-1, results_unmodified[0].mechs,
 275                    c_new, average[0], stddev[0],
 276                    c_modified, average[1], stddev[1],
 277                    c_unmodified, average[2], stddev[2]);
 278         shutdown_peers();
 279 }
 280
 281 int stats_cb (void *cls,
 282                            const char *subsystem,
 283                            const char *name,
 284                            uint64_t value,
 285                            int is_persistent)
 286 {
 287         static int printed = GNUNET_NO;
 288         //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
 289         if (0 == strcmp (name,"ATS invalid solutions"))
 290         {
 291                 if (stats_task != GNUNET_SCHEDULER_NO_TASK)
 292                 {
 293                         GNUNET_SCHEDULER_cancel(stats_task);
 294                         stats_task = GNUNET_SCHEDULER_NO_TASK;
 295                 }
 296                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n", value);
 297                 shutdown_peers();
 298                 return GNUNET_SYSERR;
 299         }
 300
 301         if (0 == strcmp (name,"ATS solution"))
 302         {
 303                 s_solution = NULL;
 304         }
 305
 306         if (0 == strcmp (name,"ATS peers"))
 307         {
 308                 s_peers = NULL;
 309         }
 310
 311         if (0 == strcmp (name,"ATS mechanisms"))
 312         {
 313                 s_mechs = NULL;
 314         }
 315
 316         if (0 == strcmp (name,"ATS duration"))
 317         {
 318                 s_duration = NULL;
 319         }
 320         if (0 == strcmp (name,"ATS timestamp"))
 321         {
 322                 s_time = NULL;
 323         }
 324         if (0 == strcmp (name,"ATS state"))
 325         {
 326                 s_state = NULL;
 327         }
 328
 329     if ((measurement_started == GNUNET_NO) && (0 == strcmp (name, "ATS peers")) && (value == peers-1))
 330     {
 331                 measurement_started = GNUNET_YES;
 332                 count = 1;
 333                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All %llu peers connected\n", value);
 334 #if !VERBOSE
 335                 if (!machine_parsable)  fprintf(stderr, "%i", count);
 336 #endif
 337     }
 338
 339     if (measurement_started == GNUNET_YES)
 340     {
 341                 // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
 342                 if (0 == strcmp (name,"ATS timestamp"))
 343                 {
 344                         if (current.timestamp == 0)
 345                         {
 346                                 printed = GNUNET_NO;
 347                                 current.timestamp = value;
 348                         }
 349                         if (current.timestamp == value)
 350                         {
 351                                 printed = GNUNET_YES;
 352                         }
 353                         if (current.timestamp != value)
 354                         {
 355                                 if (current.state == ATS_NEW)
 356                                 {
 357                                         if (c_new < MEASUREMENTS)
 358                                         {
 359                                                 results_new[c_new] = current;
 360                                                 c_new++;
 361                                         }
 362                                         else
 363                                         {
 364                                           force_rebuild = GNUNET_NO;
 365                                           force_q_updates = GNUNET_NO;
 366                                           send_msg = GNUNET_NO;
 367                                         }
 368                                 }
 369                                 if (current.state == ATS_UNMODIFIED)
 370                                 {
 371                                         if (c_unmodified < MEASUREMENTS)
 372                                         {
 373                                                 results_unmodified[c_unmodified] = current;
 374                                                 c_unmodified++;
 375                                         }
 376
 377                                 }
 378                                 if (current.state == ATS_Q_UPDATED)
 379                                 {
 380                                         if (c_modified < MEASUREMENTS)
 381                                         {
 382                                                 results_modified[c_modified] = current;
 383                                                 c_modified++;
 384                                         }
 385                                         else
 386                                         {
 387                                                 force_q_updates = GNUNET_NO;
 388                                                 force_rebuild = GNUNET_YES;
 389                                         }
 390                                 }
 391                                 count ++;
 392
 393                                 fprintf (stderr,
 394                                          "(new: %i / modified: %i / unmodified: %i) of %i \n",
 395                                          c_new, c_modified, c_unmodified , MEASUREMENTS);
 396                                 if ((c_modified >= MEASUREMENTS) && (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS))
 397                                 {
 398 #if !VERBOSE
 399                                         if (!machine_parsable) fprintf(stdout, "\n");
 400 #endif
 401                                         if (stats_task != GNUNET_SCHEDULER_NO_TASK)
 402                                         {
 403                                                 GNUNET_SCHEDULER_cancel(stats_task);
 404                                                 stats_task = GNUNET_SCHEDULER_NO_TASK;
 405                                         }
 406                                         evaluate_measurements();
 407                                         return GNUNET_SYSERR;
 408                                 }
 409
 410                                 printed = GNUNET_NO;
 411                                 current.timestamp = value;
 412 #if !VERBOSE
 413                                 if (!machine_parsable) fprintf(stderr, "..%i", count);
 414 #endif
 415                                 return GNUNET_OK;
 416                         }
 417                 }
 418
 419                 if (0 == strcmp (name,"ATS solution"))
 420                 {
 421                         current.solution = value;
 422                         if (printed == GNUNET_NO)
 423                           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 424                 }
 425
 426                 if (0 == strcmp (name,"ATS peers"))
 427                 {
 428                         current.peers = value;
 429                         if (printed == GNUNET_NO)
 430                           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 431                 }
 432
 433                 if (0 == strcmp (name,"ATS mechanisms"))
 434                 {
 435                         current.mechs = value;
 436                         if (printed == GNUNET_NO)
 437                           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 438                 }
 439
 440                 if (0 == strcmp (name,"ATS duration"))
 441                 {
 442                         current.duration = value;
 443                         if (printed == GNUNET_NO)
 444                           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
 445                 }
 446                 if (0 == strcmp (name,"ATS state"))
 447                 {
 448                         current.state = value;
 449                         char * cont;
 450                         if (value == ATS_NEW)
 451                                 cont = "NEW";
 452                         if (value == ATS_C_UPDATED)
 453                                 cont = "C_UPDATED";
 454                         if (value == ATS_Q_UPDATED)
 455                                 cont = "Q_UPDATED";
 456                         if (value == ATS_QC_UPDATED)
 457                                 cont = "QC_UPDATED";
 458                         if (value == ATS_UNMODIFIED)
 459                                 cont = "UNMODIFIED";
 460                         if (printed == GNUNET_NO)
 461                           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] ATS state: %s\n", count, cont);
 462                 }
 463     }
 464     return GNUNET_OK;
 465 }
 466
 467
 468 void
 469 stats_get_task (void *cls,
 470                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 471 {
 472         stats_task = GNUNET_SCHEDULER_NO_TASK;
 473         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 474             return;
 475
 476         s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp", TIMEOUT, NULL, &stats_cb, NULL);
 477         s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution", TIMEOUT, NULL, &stats_cb, NULL);
 478         s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration", TIMEOUT, NULL, &stats_cb, NULL);
 479         s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers", TIMEOUT, NULL, &stats_cb, NULL);
 480         s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms", TIMEOUT, NULL, &stats_cb, NULL);
 481         s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions", TIMEOUT, NULL, &stats_cb, NULL);
 482         s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL, &stats_cb, NULL);
 483
 484         stats_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100), &stats_get_task, NULL);
 485 }
 486
 487 void
 488 delay (void *cls,
 489                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 490 {
 491         shutdown_task = GNUNET_SCHEDULER_NO_TASK;
 492         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 493             return;
 494
 495 #if VERBOSE
 496         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Delay over\n");
 497 #endif
 498         shutdown_peers ();
 499 }
 500
 501 static void connect_peers()
 502 {
 503     shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
 504
 505 }
 506
 507 size_t send_dummy_data_task (void *cls, size_t size, void *buf)
 508 {
 509
 510         int s = sizeof (struct TestMessage);
 511         struct TestMessage hdr;
 512
 513         hdr.header.size = htons (s);
 514         hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
 515         if (force_rebuild)
 516                 hdr.num = htonl (1);
 517         if (force_q_updates)
 518                 hdr.num = htonl (2);
 519
 520
 521         memcpy (buf,&hdr, s);
 522         // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
 523         t  = NULL;
 524         return s;
 525 }
 526
 527 void send_task_f (void *cls,
 528                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 529 {
 530         send_task = GNUNET_SCHEDULER_NO_TASK;
 531         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 532             return;
 533
 534         if (t!=NULL)
 535         {
 536                 GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
 537                 t = NULL;
 538         }
 539         // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i to %s\n", size, GNUNET_i2s(&master_deamon->id));
 540         if (send_msg == GNUNET_YES)
 541                 t = GNUNET_TRANSPORT_notify_transmit_ready(th, &master_deamon->id, sizeof (struct TestMessage), 0, SEND_TIMEOUT, &send_dummy_data_task, NULL);
 542         send_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000), &send_task_f, NULL);
 543 }
 544
 545
 546
 547 void daemon_connect_cb(void *cls,
 548                                                 const struct GNUNET_PeerIdentity *first,
 549                                                 const struct GNUNET_PeerIdentity *second,
 550                                                 uint32_t distance,
 551                                                 const struct GNUNET_CONFIGURATION_Handle *first_cfg,
 552                                                 const struct GNUNET_CONFIGURATION_Handle *second_cfg,
 553                                                 struct GNUNET_TESTING_Daemon *first_daemon,
 554                                                 struct GNUNET_TESTING_Daemon *second_daemon,
 555                                                 const char *emsg)
 556 {
 557         char * firstc =  strdup(GNUNET_i2s(first));
 558         char * secondc =  strdup(GNUNET_i2s(second));
 559         connected++;
 560         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 561                     "Connected peers `%s'<->`%s' (%i/%i)\n", firstc, secondc, connected, peers-1);
 562         GNUNET_free(firstc);
 563         GNUNET_free(secondc);
 564
 565         if (((first_daemon == ping_deamon) || (second_daemon == ping_deamon)) && (master_deamon != NULL) && (ping_deamon != NULL))
 566         {
 567                   th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,&ping_deamon->id, NULL, NULL,NULL, NULL);
 568                   t = NULL;
 569                   force_q_updates = GNUNET_YES;
 570                   send_msg = GNUNET_YES;
 571                   send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
 572         }
 573 }
 574
 575 void cont_cb (void *cls, int success)
 576 {
 577     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 578                 "STATS cont_cb: %i\n", success);
 579 }
 580
 581 static void
 582 daemon_start_cb (void *cls,
 583        const struct GNUNET_PeerIdentity *id,
 584        const struct GNUNET_CONFIGURATION_Handle *cfg,
 585        struct GNUNET_TESTING_Daemon *d, const char *emsg)
 586 {
 587   if (id == NULL)
 588     {
 589       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 590                   "Start callback called with error (too long starting peers), aborting test!\n");
 591       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error from testing: `%s'\n");
 592       failed_peers++;
 593       if (failed_peers == peers_left)
 594         {
 595           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 596                       "Too many peers failed, ending test!\n");
 597           ok = 1;
 598         shutdown_peers ();
 599         }
 600       return;
 601     }
 602   peers_left--;
 603
 604   if (master_deamon == NULL)
 605   {
 606           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Master peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
 607
 608           master_deamon = d;
 609           stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
 610           GNUNET_assert (stats != NULL);
 611           stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
 612   }
 613   else
 614   {
 615           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting peer `%s'\n", GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
 616           GNUNET_TESTING_daemons_connect(d, master_deamon, TIMEOUT, 0, GNUNET_YES,&daemon_connect_cb, NULL);
 617   }
 618
 619   if (peers_left == 0)
 620     {
 621           if (ping_deamon == NULL)
 622           {
 623                   ping_deamon = d;
 624                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
 625           }
 626
 627           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 628                   "All peers started successfully!\n");
 629       connect_peers();
 630       ok = 0;
 631     }
 632   else if (failed_peers == peers_left)
 633     {
 634       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 635                   "Too many peers failed, ending test!\n");
 636       shutdown_peers();
 637       ok = 1;
 638     }
 639 }
 640
 641
 642 static void
 643 run (void *cls,
 644      char *const *args,
 645      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 646 {
 647   ok = 1;
 648   measurement_started = GNUNET_NO;
 649 #if VERBOSE
 650   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
 651 #endif
 652   peers_left = peers;
 653   pg = GNUNET_TESTING_daemons_start (cfg,
 654                                      peers_left, /* Total number of peers */
 655                                      peers_left, /* Number of outstanding connections */
 656                                      peers_left, /* Number of parallel ssh connections, or peers being started at once */
 657                                      TIMEOUT,
 658                                      NULL, NULL,
 659                                      &daemon_start_cb, NULL, NULL, NULL, NULL);
 660   GNUNET_assert (pg != NULL);
 661 }
 662
 663 static int
 664 check ()
 665 {
 666   char *const argv[] = { "test-testing",
 667     "-c",
 668     config_file,
 669 #if VERBOSE
 670     "-L", "DEBUG",
 671 #endif
 672     NULL
 673   };
 674   struct GNUNET_GETOPT_CommandLineOption options[] = {
 675     GNUNET_GETOPT_OPTION_END
 676   };
 677   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 678                       argv, "test-transport-ats", "nohelp",
 679                       options, &run, &ok);
 680   return ok;
 681 }
 682
 683 int
 684 main (int argc, char *argv[])
 685 {
 686
 687   int ret;
 688
 689   GNUNET_log_setup ("test-transport-ats",
 690 #if VERBOSE
 691                     "DEBUG",
 692 #else
 693                     "INFO",
 694 #endif
 695                     NULL);
 696
 697 #if !HAVE_LIBGLPK
 698         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed, exiting testcase\n");
 699         return 0;
 700 #endif
 701
 702   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 703
 704
 705   machine_parsable = GNUNET_NO;
 706   peers = NUM_PEERS;
 707   config_file = "test_transport_ats_4addr.conf";
 708
 709   int c = 0;
 710   if (argc >= 2)
 711   {
 712          for (c=0; c<argc; c++)
 713          {
 714                  /* set peers */
 715                  if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
 716                  {
 717                           peers = atoi(argv[c+1]);
 718                           peers++;
 719                  }
 720                  /* set machine parsable */
 721                  if (strcmp(argv[c], "-m") == 0)
 722                  {
 723                          machine_parsable = GNUNET_YES;
 724                  }
 725                  /* set config file */
 726                  if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
 727                  {
 728                          config_file = argv[c+1];
 729                  }
 730          }
 731   }
 732
 733
 734
 735   ret = check ();
 736   /**
 737    * Still need to remove the base testing directory here,
 738    * because group starts will create subdirectories under this
 739    * main dir.  However, we no longer need to sleep, as the
 740    * shutdown sequence won't return until everything is cleaned
 741    * up.
 742    */
 743   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 744   return ret;
 745 }
 746
 747 /* end of test_transport_ats.c*/