src/arm/test_exponential_backoff.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009, 2016 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18 /**
  19  * @file arm/test_exponential_backoff.c
  20  * @brief testcase for gnunet-service-arm.c
  21  * @author Christian Grothoff
  22  */
  23 #include "platform.h"
  24 #include "gnunet_arm_service.h"
  25 #include "gnunet_util_lib.h"
  26 #include "gnunet_protocols.h"
  27
  28 #define LOG(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  29
  30 #define LOG_BACKOFF GNUNET_NO
  31
  32 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  33
  34 #define SERVICE_TEST_TIMEOUT GNUNET_TIME_UNIT_FOREVER_REL
  35
  36 #define FIVE_MILLISECONDS GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 5)
  37
  38 #define SERVICE "do-nothing"
  39
  40 #define BINARY "mockup-service"
  41
  42 #define CFGFILENAME "test_arm_api_data2.conf"
  43
  44
  45 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  46
  47 static struct GNUNET_ARM_Handle *arm;
  48
  49 static struct GNUNET_ARM_MonitorHandle *mon;
  50
  51 static struct GNUNET_SCHEDULER_Task *kt;
  52
  53 static int ok = 1;
  54
  55 static int phase = 0;
  56
  57 static int trialCount;
  58
  59 static struct GNUNET_TIME_Absolute startedWaitingAt;
  60
  61 struct GNUNET_TIME_Relative waitedFor;
  62
  63 struct GNUNET_TIME_Relative waitedFor_prev;
  64
  65 #if LOG_BACKOFF
  66 static FILE *killLogFilePtr;
  67
  68 static char *killLogFileName;
  69 #endif
  70
  71
  72 /**
  73  * Context for handling the shutdown of a service.
  74  */
  75 struct ShutdownContext
  76 {
  77   /**
  78    * Connection to the service that is being shutdown.
  79    */
  80   struct GNUNET_MQ_Handle *mq;
  81
  82   /**
  83    * Task set up to cancel the shutdown request on timeout.
  84    */
  85   struct GNUNET_SCHEDULER_Task *cancel_task;
  86
  87 };
  88
  89
  90 static void
  91 kill_task (void *cbData);
  92
  93
  94 /**
  95  * Shutting down took too long, cancel receive and return error.
  96  *
  97  * @param cls closure
  98  */
  99 static void
 100 service_shutdown_timeout (void *cls)
 101 {
 102   GNUNET_assert (0);
 103 }
 104
 105
 106 /**
 107  * Generic error handler, called with the appropriate error code and
 108  * the same closure specified at the creation of the message queue.
 109  * Not every message queue implementation supports an error handler.
 110  *
 111  * @param cls closure with the `struct ShutdownContext *`
 112  * @param error error code
 113  */
 114 static void
 115 mq_error_handler (void *cls,
 116                   enum GNUNET_MQ_Error error)
 117 {
 118   struct ShutdownContext *shutdown_ctx = cls;
 119
 120   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 121               "Service shutdown complete (MQ error).\n");
 122   GNUNET_SCHEDULER_cancel (shutdown_ctx->cancel_task);
 123   GNUNET_MQ_destroy (shutdown_ctx->mq);
 124   GNUNET_free (shutdown_ctx);
 125 }
 126
 127
 128 static void
 129 kill_task (void *cbData)
 130 {
 131   struct ShutdownContext *shutdown_ctx
 132     = GNUNET_new (struct ShutdownContext);
 133   struct GNUNET_MQ_Envelope *env;
 134   struct GNUNET_MessageHeader *msg;
 135   struct GNUNET_MQ_MessageHandler handlers[] = {
 136     GNUNET_MQ_handler_end ()
 137   };
 138
 139   kt = NULL;
 140   if (trialCount == 13)
 141   {
 142     LOG ("Saw enough kills, asking ARM to stop mock service for good\n");
 143     GNUNET_ARM_request_service_stop (arm,
 144                                      SERVICE,
 145                                      NULL,
 146                                      NULL);
 147     ok = 0;
 148     trialCount++;
 149     GNUNET_free (shutdown_ctx);
 150     return;
 151   }
 152   shutdown_ctx->mq = GNUNET_CLIENT_connect (cfg,
 153                                             SERVICE,
 154                                             handlers,
 155                                             &mq_error_handler,
 156                                             shutdown_ctx);
 157   GNUNET_assert (NULL != shutdown_ctx->mq);
 158   trialCount++;
 159   LOG ("Sending a shutdown request to the mock service\n");
 160   env = GNUNET_MQ_msg (msg,
 161                        GNUNET_MESSAGE_TYPE_ARM_STOP); /* FIXME: abuse of message type */
 162   GNUNET_MQ_send (shutdown_ctx->mq,
 163                   env);
 164   shutdown_ctx->cancel_task
 165     = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 166                                     &service_shutdown_timeout,
 167                                     shutdown_ctx);
 168 }
 169
 170
 171 static void
 172 trigger_disconnect (void *cls)
 173 {
 174   GNUNET_ARM_disconnect (arm);
 175   GNUNET_ARM_monitor_stop (mon);
 176   if (NULL != kt)
 177   {
 178     GNUNET_SCHEDULER_cancel (kt);
 179     kt = NULL;
 180   }
 181 }
 182
 183
 184 static void
 185 arm_stop_cb (void *cls,
 186              enum GNUNET_ARM_RequestStatus status,
 187              enum GNUNET_ARM_Result result)
 188 {
 189   GNUNET_break (status == GNUNET_ARM_REQUEST_SENT_OK);
 190   GNUNET_break (result == GNUNET_ARM_RESULT_STOPPED);
 191   LOG ("ARM service stopped\n");
 192   GNUNET_SCHEDULER_shutdown ();
 193 }
 194
 195
 196 static void
 197 srv_status (void *cls,
 198             const char *service,
 199             enum GNUNET_ARM_ServiceStatus status)
 200 {
 201   if (status == GNUNET_ARM_SERVICE_MONITORING_STARTED)
 202   {
 203     LOG ("ARM monitor started, starting mock service\n");
 204     phase++;
 205     GNUNET_ARM_request_service_start (arm,
 206                                       SERVICE,
 207                                       GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 208                                       NULL,
 209                                       NULL);
 210     return;
 211   }
 212   if (0 != strcasecmp (service, SERVICE))
 213     return; /* not what we care about */
 214   if (phase == 1)
 215   {
 216     GNUNET_break (status == GNUNET_ARM_SERVICE_STARTING);
 217     GNUNET_break (phase == 1);
 218     LOG ("do-nothing is starting\n");
 219     phase++;
 220     ok = 1;
 221     GNUNET_assert (NULL == kt);
 222     startedWaitingAt = GNUNET_TIME_absolute_get ();
 223     kt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 224                                        &kill_task,
 225                                        NULL);
 226   }
 227   else if (phase == 2)
 228   {
 229     /* We passively monitor ARM for status updates. ARM should tell us
 230      * when do-nothing dies (no need to run a service upness test ourselves).
 231      */
 232     if (status == GNUNET_ARM_SERVICE_STARTING)
 233     {
 234       waitedFor = GNUNET_TIME_absolute_get_duration (startedWaitingAt);
 235       LOG ("Waited for: %s\n",
 236            GNUNET_STRINGS_relative_time_to_string (waitedFor,
 237                                                    GNUNET_YES));
 238
 239       LOG ("do-nothing is starting, killing it...\n");
 240       GNUNET_assert (NULL == kt);
 241       kt = GNUNET_SCHEDULER_add_now (&kill_task, &ok);
 242     }
 243     else if ((status == GNUNET_ARM_SERVICE_STOPPED) && (trialCount == 14))
 244     {
 245       phase++;
 246       LOG ("do-nothing stopped working %u times, we are done here\n",
 247            (unsigned int) trialCount);
 248       GNUNET_ARM_request_service_stop (arm,
 249                                        "arm",
 250                                        &arm_stop_cb,
 251                                        NULL);
 252     }
 253   }
 254 }
 255
 256
 257 static void
 258 arm_start_cb (void *cls,
 259               enum GNUNET_ARM_RequestStatus status,
 260               enum GNUNET_ARM_Result result)
 261 {
 262   GNUNET_break (status == GNUNET_ARM_REQUEST_SENT_OK);
 263   GNUNET_break (result == GNUNET_ARM_RESULT_STARTING);
 264   GNUNET_break (phase == 0);
 265   LOG ("Sent 'START' request for arm to ARM %s\n",
 266        (status == GNUNET_ARM_REQUEST_SENT_OK) ? "successfully" : "unsuccessfully");
 267 }
 268
 269
 270 static void
 271 task (void *cls,
 272       char *const *args,
 273       const char *cfgfile,
 274       const struct GNUNET_CONFIGURATION_Handle *c)
 275 {
 276   cfg = c;
 277   arm = GNUNET_ARM_connect (cfg, NULL, NULL);
 278   if (NULL == arm)
 279   {
 280     GNUNET_break (0);
 281     return;
 282   }
 283   mon = GNUNET_ARM_monitor_start (cfg,
 284                                   &srv_status,
 285                                   NULL);
 286   if (NULL == mon)
 287   {
 288     GNUNET_break (0);
 289     GNUNET_ARM_disconnect (arm);
 290     arm = NULL;
 291     return;
 292   }
 293   GNUNET_ARM_request_service_start (arm,
 294                                     "arm",
 295                                     GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 296                                     &arm_start_cb,
 297                                     NULL);
 298   GNUNET_SCHEDULER_add_shutdown (&trigger_disconnect,
 299                                  NULL);
 300 }
 301
 302
 303 static int
 304 check ()
 305 {
 306   char *const argv[] = {
 307     "test-exponential-backoff",
 308     "-c", CFGFILENAME,
 309     NULL
 310   };
 311   struct GNUNET_GETOPT_CommandLineOption options[] = {
 312     GNUNET_GETOPT_OPTION_END
 313   };
 314
 315   /* Running ARM  and running the do_nothing task */
 316   GNUNET_assert (GNUNET_OK ==
 317                  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 318                                      argv,
 319                                      "test-exponential-backoff",
 320                                      "nohelp",
 321                                      options,
 322                                      &task,
 323                                      NULL));
 324   return ok;
 325 }
 326
 327
 328 #ifndef PATH_MAX
 329 /**
 330  * Assumed maximum path length (for the log file name).
 331  */
 332 #define PATH_MAX 4096
 333 #endif
 334
 335
 336 static int
 337 init ()
 338 {
 339   struct GNUNET_CONFIGURATION_Handle *cfg;
 340   char pwd[PATH_MAX];
 341   char *binary;
 342
 343   cfg = GNUNET_CONFIGURATION_create ();
 344   if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg,
 345                                                "test_arm_api_data.conf"))
 346   {
 347     GNUNET_free (cfg);
 348     return GNUNET_SYSERR;
 349   }
 350   if (NULL == getcwd (pwd, PATH_MAX))
 351     return GNUNET_SYSERR;
 352   GNUNET_assert (0 < GNUNET_asprintf (&binary,
 353                                       "%s/%s",
 354                                       pwd,
 355                                       BINARY));
 356   GNUNET_CONFIGURATION_set_value_string (cfg,
 357                                          SERVICE,
 358                                          "BINARY",
 359                                          binary);
 360   GNUNET_free (binary);
 361   if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg,
 362                                                CFGFILENAME))
 363   {
 364     GNUNET_CONFIGURATION_destroy (cfg);
 365     return GNUNET_SYSERR;
 366   }
 367   GNUNET_CONFIGURATION_destroy (cfg);
 368
 369 #if LOG_BACKOFF
 370   killLogFileName = GNUNET_DISK_mktemp ("exponential-backoff-waiting.log");
 371   if (NULL == (killLogFilePtr = FOPEN (killLogFileName,
 372                                        "w")))
 373     {
 374       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
 375                                 "fopen",
 376                                 killLogFileName);
 377       GNUNET_free (killLogFileName);
 378       return GNUNET_SYSERR;
 379     }
 380 #endif
 381   return GNUNET_OK;
 382 }
 383
 384
 385 static void
 386 houseKeep ()
 387 {
 388 #if LOG_BACKOFF
 389   GNUNET_assert (0 == fclose (killLogFilePtr));
 390   GNUNET_free (killLogFileName);
 391 #endif
 392   (void) unlink (CFGFILENAME);
 393 }
 394
 395
 396 int
 397 main (int argc, char *argv[])
 398 {
 399   int ret;
 400
 401   GNUNET_log_setup ("test-exponential-backoff",
 402                     "WARNING",
 403                     NULL);
 404
 405   if (GNUNET_OK != init ())
 406     return 1;
 407   ret = check ();
 408   houseKeep ();
 409   return ret;
 410 }
 411
 412 /* end of test_exponential_backoff.c */