src/core/test_core_api_start_only.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
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file transport/test_core_api_start_only.c
  22  * @brief testcase for core_api.c that only starts two peers,
  23  *        connects to the core service and shuts down again
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_core_service.h"
  29 #include "gnunet_util_lib.h"
  30
  31 #define TIMEOUT 5
  32
  33 #define MTYPE 12345
  34
  35 struct PeerContext
  36 {
  37   struct GNUNET_CONFIGURATION_Handle *cfg;
  38   struct GNUNET_CORE_Handle *ch;
  39   struct GNUNET_PeerIdentity id;
  40   struct GNUNET_OS_Process *arm_proc;
  41 };
  42
  43 static struct PeerContext p1;
  44
  45 static struct PeerContext p2;
  46
  47 static struct GNUNET_SCHEDULER_Task *timeout_task_id;
  48
  49 static int ok;
  50
  51
  52 static void *
  53 connect_notify (void *cls,
  54                 const struct GNUNET_PeerIdentity *peer,
  55                 struct GNUNET_MQ_Handle *mq)
  56 {
  57   return NULL;
  58 }
  59
  60
  61 static void
  62 disconnect_notify (void *cls,
  63                    const struct GNUNET_PeerIdentity *peer,
  64                    void *internal_cls)
  65 {
  66 }
  67
  68
  69 static struct GNUNET_MQ_MessageHandler handlers[] = {
  70   GNUNET_MQ_handler_end ()
  71 };
  72
  73
  74 static void
  75 shutdown_task (void *cls)
  76 {
  77   GNUNET_CORE_disconnect (p1.ch);
  78   p1.ch = NULL;
  79   GNUNET_CORE_disconnect (p2.ch);
  80   p2.ch = NULL;
  81   ok = 0;
  82 }
  83
  84
  85 static void
  86 init_notify (void *cls,
  87              const struct GNUNET_PeerIdentity *my_identity)
  88 {
  89   struct PeerContext *p = cls;
  90
  91   if (p == &p1)
  92   {
  93     /* connect p2 */
  94     p2.ch = GNUNET_CORE_connect (p2.cfg,
  95                                  &p2,
  96                                  &init_notify,
  97                                  &connect_notify,
  98                                  &disconnect_notify,
  99                                  handlers);
 100   }
 101   else
 102   {
 103     GNUNET_assert (p == &p2);
 104     GNUNET_SCHEDULER_cancel (timeout_task_id);
 105     timeout_task_id = NULL;
 106     GNUNET_SCHEDULER_add_now (&shutdown_task,
 107                               NULL);
 108   }
 109 }
 110
 111
 112 static void
 113 setup_peer (struct PeerContext *p,
 114             const char *cfgname)
 115 {
 116   char *binary;
 117
 118   binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
 119   p->cfg = GNUNET_CONFIGURATION_create ();
 120   p->arm_proc =
 121     GNUNET_OS_start_process (GNUNET_YES,
 122                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
 123                              NULL, NULL, NULL,
 124                              binary,
 125                              "gnunet-service-arm",
 126                              "-c", cfgname,
 127                              NULL);
 128   GNUNET_assert (GNUNET_OK ==
 129                  GNUNET_CONFIGURATION_load (p->cfg,
 130                                             cfgname));
 131   GNUNET_free (binary);
 132 }
 133
 134
 135 static void
 136 timeout_task (void *cls)
 137 {
 138   FPRINTF (stderr,
 139            "%s",
 140            "Timeout.\n");
 141   if (NULL != p1.ch)
 142   {
 143     GNUNET_CORE_disconnect (p1.ch);
 144     p1.ch = NULL;
 145   }
 146   if (NULL != p2.ch)
 147   {
 148     GNUNET_CORE_disconnect (p2.ch);
 149     p2.ch = NULL;
 150   }
 151   ok = 42;
 152 }
 153
 154
 155 static void
 156 run (void *cls,
 157      char *const *args,
 158      const char *cfgfile,
 159      const struct GNUNET_CONFIGURATION_Handle *cfg)
 160 {
 161   GNUNET_assert (ok == 1);
 162   ok++;
 163   setup_peer (&p1, "test_core_api_peer1.conf");
 164   setup_peer (&p2, "test_core_api_peer2.conf");
 165   timeout_task_id =
 166       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 167                                     (GNUNET_TIME_UNIT_MINUTES,
 168                                      TIMEOUT),
 169                                     &timeout_task,
 170                                     NULL);
 171   p1.ch = GNUNET_CORE_connect (p1.cfg,
 172                                &p1,
 173                                &init_notify,
 174                                &connect_notify,
 175                                &disconnect_notify,
 176                                handlers);
 177 }
 178
 179
 180 static void
 181 stop_arm (struct PeerContext *p)
 182 {
 183   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 184               "Stopping peer\n");
 185   if (0 != GNUNET_OS_process_kill (p->arm_proc,
 186                                    GNUNET_TERM_SIG))
 187     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 188                          "kill");
 189   if (GNUNET_OK !=
 190       GNUNET_OS_process_wait (p->arm_proc))
 191     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 192                          "waitpid");
 193   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 194               "ARM process %u stopped\n",
 195               (unsigned int) GNUNET_OS_process_get_pid (p->arm_proc));
 196   GNUNET_OS_process_destroy (p->arm_proc);
 197   p->arm_proc = NULL;
 198   GNUNET_CONFIGURATION_destroy (p->cfg);
 199 }
 200
 201
 202 static int
 203 check ()
 204 {
 205   char *const argv[] = {
 206     "test-core-api-start-only",
 207     "-c",
 208     "test_core_api_data.conf",
 209     NULL
 210   };
 211   struct GNUNET_GETOPT_CommandLineOption options[] = {
 212     GNUNET_GETOPT_OPTION_END
 213   };
 214   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
 215   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 216
 217   ok = 1;
 218   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 219                       argv,
 220                       "test-core-api-start-only",
 221                       "nohelp",
 222                       options,
 223                       &run,
 224                       &ok);
 225   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 226               "Test finished\n");
 227   stop_arm (&p1);
 228   stop_arm (&p2);
 229   return ok;
 230 }
 231
 232
 233 int
 234 main (int argc,
 235       char *argv[])
 236 {
 237   int ret;
 238
 239   GNUNET_log_setup ("test-core-api-start-only",
 240                     "WARNING",
 241                     NULL);
 242   ret = check ();
 243   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
 244   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 245   return ret;
 246 }
 247
 248 /* end of test_core_api_start_only.c */