src/arm/gnunet-arm.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 2, 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 /**
  22  * @file arm/gnunet-arm.c
  23  * @brief arm for writing a tool
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_client_lib.h"
  29 #include "gnunet_getopt_lib.h"
  30 #include "gnunet_program_lib.h"
  31 #include "gnunet_time_lib.h"
  32
  33 /**
  34  * Timeout for all operations.
  35  */
  36 #define TIMEOUT  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  37
  38 /**
  39  * Set if we are to shutdown all services (including ARM).
  40  */
  41 static int end;
  42
  43 /**
  44  * Set if we are to start default services (including ARM).
  45  */
  46 static int start;
  47
  48 /**
  49  * Set to the name of a service to start.
  50  */
  51 static char *init;
  52
  53 /**
  54  * Set to the name of a service to kill.
  55  */
  56 static char *term;
  57
  58 /**
  59  * Set to the name of a service to test.
  60  */
  61 static char *test;
  62
  63 /**
  64  * Final status code.
  65  */
  66 static int ret;
  67
  68 /**
  69  * Connection with ARM.
  70  */
  71 static struct GNUNET_ARM_Handle *h;
  72
  73 /**
  74  * Our scheduler.
  75  */
  76 static struct GNUNET_SCHEDULER_Handle *sched;
  77
  78 /**
  79  * Our configuration.
  80  */
  81 const struct GNUNET_CONFIGURATION_Handle *cfg;
  82
  83 /**
  84  * Processing stage that we are in.  Simple counter.
  85  */
  86 static unsigned int phase;
  87
  88
  89 /**
  90  * Main continuation-passing-style loop.  Runs the various
  91  * jobs that we've been asked to do in order.
  92  *
  93  * @param cls closure, unused
  94  * @param tc context, unused
  95  */
  96 static void
  97 cps_loop (void *cls,
  98           const struct GNUNET_SCHEDULER_TaskContext *tc);
  99
 100
 101 /**
 102  * Callback invoked with the status of the last operation.  Reports to the
 103  * user and then runs the next phase in the FSM.
 104  *
 105  * @param cls pointer to "const char*" identifying service that was manipulated
 106  * @param success GNUNET_OK if service is now running, GNUNET_NO if not, GNUNET_SYSERR on error
 107  */
 108 static void
 109 confirm_cb (void *cls, int success)
 110 {
 111   const char *service = cls;
 112   switch (success)
 113     {
 114     case GNUNET_OK:
 115       fprintf (stdout, _("Service `%s' is now running.\n"), service);
 116       break;
 117     case GNUNET_NO:
 118       fprintf (stdout, _("Service `%s' is not running.\n"), service);
 119       break;
 120     case GNUNET_SYSERR:
 121       fprintf (stdout,
 122                _("Error updating service `%s': ARM not running\n"), service);
 123       break;
 124     }
 125   GNUNET_SCHEDULER_add_continuation (sched,
 126                                      &cps_loop,
 127                                      NULL,
 128                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 129 }
 130
 131
 132 /**
 133  * Function called to confirm that a service is running (or that
 134  * it is not running).
 135  *
 136  * @param cls pointer to "const char*" identifying service that was manipulated
 137  * @param tc reason determines if service is now running
 138  */
 139 static void
 140 confirm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 141 {
 142   const char *service = cls;
 143
 144   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
 145     fprintf (stdout, _("Service `%s' is running.\n"), service);
 146   else
 147     fprintf (stdout, _("Service `%s' is not running.\n"), service);
 148   GNUNET_SCHEDULER_add_continuation (sched,
 149                                      &cps_loop,
 150                                      NULL,
 151                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 152 }
 153
 154
 155 /**
 156  * Main function that will be run by the scheduler.
 157  *
 158  * @param cls closure
 159  * @param s the scheduler to use
 160  * @param args remaining command-line arguments
 161  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 162  * @param c configuration
 163  */
 164 static void
 165 run (void *cls,
 166      struct GNUNET_SCHEDULER_Handle *s,
 167      char *const *args,
 168      const char *cfgfile,
 169      const struct GNUNET_CONFIGURATION_Handle *c)
 170 {
 171   sched = s;
 172   cfg = c;
 173   h = GNUNET_ARM_connect (cfg, sched, NULL);
 174   if (h == NULL)
 175     {
 176       fprintf (stderr,
 177                _("Fatal error initializing ARM API.\n"));
 178       ret = 1;
 179       return;
 180     }
 181   GNUNET_SCHEDULER_add_continuation (sched,
 182                                      &cps_loop,
 183                                      NULL,
 184                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 185 }
 186
 187
 188 /**
 189  * Main continuation-passing-style loop.  Runs the various
 190  * jobs that we've been asked to do in order.
 191  *
 192  * @param cls closure, unused
 193  * @param tc context, unused
 194  */
 195 static void
 196 cps_loop (void *cls,
 197           const struct GNUNET_SCHEDULER_TaskContext *tc)
 198 {
 199   while (1)
 200     {
 201       switch (phase++)
 202         {
 203         case 0:
 204           if (term != NULL)
 205             {
 206               GNUNET_ARM_stop_service (h, term, TIMEOUT, &confirm_cb, term);
 207               return;
 208             }
 209           break;
 210         case 1:
 211           if (end)
 212             {
 213               GNUNET_ARM_stop_service (h, "arm", TIMEOUT, &confirm_cb, "arm");
 214               return;
 215             }
 216           break;
 217         case 2:
 218           if (start)
 219             {
 220               GNUNET_ARM_start_service (h, "arm", TIMEOUT, &confirm_cb, "arm");
 221               return;
 222             }
 223           break;
 224         case 3:
 225           if (init != NULL)
 226             {
 227               GNUNET_ARM_start_service (h, init, TIMEOUT, &confirm_cb, init);
 228               return;
 229             }
 230           break;
 231         case 4:
 232           if (test != NULL)
 233             {
 234               GNUNET_CLIENT_service_test (sched, test, cfg, TIMEOUT, &confirm_task, test);
 235               return;
 236             }
 237           break;
 238         default: /* last phase */
 239           GNUNET_ARM_disconnect (h);
 240           return;
 241         }
 242     }
 243 }
 244
 245
 246 /**
 247  * gnunet-arm command line options
 248  */
 249 static struct GNUNET_GETOPT_CommandLineOption options[] = {
 250   {'e', "end", NULL, gettext_noop ("stop all GNUnet services"),
 251    GNUNET_NO, &GNUNET_GETOPT_set_one, &end},
 252   {'i', "init", "SERVICE", gettext_noop ("start a particular service"),
 253    GNUNET_YES, &GNUNET_GETOPT_set_string, &init},
 254   {'k', "kill", "SERVICE", gettext_noop ("stop a particular service"),
 255    GNUNET_YES, &GNUNET_GETOPT_set_string, &term},
 256   {'s', "start", NULL, gettext_noop ("start all GNUnet default services"),
 257    GNUNET_NO, &GNUNET_GETOPT_set_one, &start},
 258   {'t', "test", "SERVICE",
 259    gettext_noop ("test if a particular service is running"),
 260    GNUNET_YES, &GNUNET_GETOPT_set_string, &test},
 261   GNUNET_GETOPT_OPTION_END
 262 };
 263
 264
 265 /**
 266  * The main function to obtain arm from gnunetd.
 267  *
 268  * @param argc number of arguments from the command line
 269  * @param argv command line arguments
 270  * @return 0 ok, 1 on error
 271  */
 272 int
 273 main (int argc, char *const *argv)
 274 {
 275   return (GNUNET_OK ==
 276           GNUNET_PROGRAM_run (argc,
 277                               argv,
 278                               "gnunet-arm",
 279                               gettext_noop
 280                               ("Control services and the Automated Restart Manager (ARM)"),
 281                               options, &run, NULL)) ? ret : 1;
 282 }
 283
 284 /* end of gnunet-arm.c */