ctdb/common/cmdline.c

   1 /*
   2    common commandline code to ctdb test tools
   3
   4    Copyright (C) Andrew Tridgell  2007
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "includes.h"
  22 #include "lib/events/events.h"
  23 #include "system/filesys.h"
  24 #include "popt.h"
  25 #include "../include/ctdb.h"
  26 #include "../include/ctdb_private.h"
  27
  28 /* Handle common command line options for ctdb test progs
  29  */
  30
  31 static struct {
  32         const char *nlist;
  33         const char *transport;
  34         const char *myaddress;
  35         const char *socketname;
  36         int self_connect;
  37         const char *db_dir;
  38         int torture;
  39         const char *logfile;
  40         const char *events;
  41 } ctdb_cmdline = {
  42         .nlist = NULL,
  43         .transport = "tcp",
  44         .myaddress = NULL,
  45         .socketname = CTDB_PATH,
  46         .self_connect = 0,
  47         .db_dir = NULL,
  48         .torture = 0,
  49         .logfile = NULL,
  50 };
  51
  52 enum {OPT_EVENTSYSTEM=1};
  53
  54 static void ctdb_cmdline_callback(poptContext con,
  55                                   enum poptCallbackReason reason,
  56                                   const struct poptOption *opt,
  57                                   const char *arg, const void *data)
  58 {
  59         switch (opt->val) {
  60         case OPT_EVENTSYSTEM:
  61                 event_set_default_backend(arg);
  62                 break;
  63         }
  64 }
  65
  66
  67 struct poptOption popt_ctdb_cmdline[] = {
  68         { NULL, 0, POPT_ARG_CALLBACK, (void *)ctdb_cmdline_callback },
  69         { "nlist", 0, POPT_ARG_STRING, &ctdb_cmdline.nlist, 0, "node list file", "filename" },
  70         { "listen", 0, POPT_ARG_STRING, &ctdb_cmdline.myaddress, 0, "address to listen on", "address" },
  71         { "socket", 0, POPT_ARG_STRING, &ctdb_cmdline.socketname, 0, "local socket name", "filename" },
  72         { "transport", 0, POPT_ARG_STRING, &ctdb_cmdline.transport, 0, "protocol transport", NULL },
  73         { "self-connect", 0, POPT_ARG_NONE, &ctdb_cmdline.self_connect, 0, "enable self connect", "boolean" },
  74         { "debug", 'd', POPT_ARG_INT, &LogLevel, 0, "debug level"},
  75         { "dbdir", 0, POPT_ARG_STRING, &ctdb_cmdline.db_dir, 0, "directory for the tdb files", NULL },
  76         { "torture", 0, POPT_ARG_NONE, &ctdb_cmdline.torture, 0, "enable nastiness in library", NULL },
  77         { "logfile", 0, POPT_ARG_STRING, &ctdb_cmdline.logfile, 0, "log file location", "filename" },
  78         { "events", 0, POPT_ARG_STRING, NULL, OPT_EVENTSYSTEM, "event system", NULL },
  79         { NULL }
  80 };
  81
  82
  83 /*
  84   startup daemon side of ctdb according to command line options
  85  */
  86 struct ctdb_context *ctdb_cmdline_init(struct event_context *ev)
  87 {
  88         struct ctdb_context *ctdb;
  89         int i, ret;
  90
  91         if (ctdb_cmdline.nlist == NULL) {
  92                 printf("You must provide a node list with --nlist\n");
  93                 exit(1);
  94         }
  95
  96         /* initialise ctdb */
  97         ctdb = ctdb_init(ev);
  98         if (ctdb == NULL) {
  99                 printf("Failed to init ctdb\n");
 100                 exit(1);
 101         }
 102
 103         ret = ctdb_set_logfile(ctdb, ctdb_cmdline.logfile);
 104         if (ret == -1) {
 105                 printf("ctdb_set_logfile failed - %s\n", ctdb_errstr(ctdb));
 106                 exit(1);
 107         }
 108
 109         if (ctdb_cmdline.self_connect) {
 110                 ctdb_set_flags(ctdb, CTDB_FLAG_SELF_CONNECT);
 111         }
 112         if (ctdb_cmdline.torture) {
 113                 ctdb_set_flags(ctdb, CTDB_FLAG_TORTURE);
 114         }
 115
 116         ret = ctdb_set_transport(ctdb, ctdb_cmdline.transport);
 117         if (ret == -1) {
 118                 printf("ctdb_set_transport failed - %s\n", ctdb_errstr(ctdb));
 119                 exit(1);
 120         }
 121
 122         /* tell ctdb what address to listen on */
 123         if (ctdb_cmdline.myaddress) {
 124                 ret = ctdb_set_address(ctdb, ctdb_cmdline.myaddress);
 125                 if (ret == -1) {
 126                         printf("ctdb_set_address failed - %s\n", ctdb_errstr(ctdb));
 127                         exit(1);
 128                 }
 129         }
 130
 131         /* tell ctdb the socket address */
 132         ret = ctdb_set_socketname(ctdb, ctdb_cmdline.socketname);
 133         if (ret == -1) {
 134                 printf("ctdb_set_socketname failed - %s\n", ctdb_errstr(ctdb));
 135                 exit(1);
 136         }
 137
 138         /* tell ctdb what nodes are available */
 139         ret = ctdb_set_nlist(ctdb, ctdb_cmdline.nlist);
 140         if (ret == -1) {
 141                 printf("ctdb_set_nlist failed - %s\n", ctdb_errstr(ctdb));
 142                 exit(1);
 143         }
 144
 145         if (ctdb_cmdline.db_dir) {
 146                 ret = ctdb_set_tdb_dir(ctdb, ctdb_cmdline.db_dir);
 147                 if (ret == -1) {
 148                         printf("ctdb_set_tdb_dir failed - %s\n", ctdb_errstr(ctdb));
 149                         exit(1);
 150                 }
 151         }
 152
 153         /* initialize the vnn mapping table */
 154 /*
 155 XXX we currently initialize it to the maximum number of nodes to
 156 XXX make it behave the same way as previously.
 157 XXX Once we have recovery working we should initialize this always to
 158 XXX generation==0 (==invalid) and let the recovery tool populate this
 159 XXX table for the daemons.
 160 */
 161         ctdb->vnn_map = talloc_zero_size(ctdb, offsetof(struct ctdb_vnn_map, map) + 4*ctdb->num_nodes);
 162         if (ctdb->vnn_map == NULL) {
 163                 DEBUG(0,(__location__ " Unable to allocate vnn_map structure\n"));
 164                 exit(1);
 165         }
 166         ctdb->vnn_map->generation = 1;
 167         ctdb->vnn_map->size = ctdb->num_nodes;
 168         for(i=0;i<ctdb->vnn_map->size;i++){
 169                 ctdb->vnn_map->map[i] = i%ctdb->num_nodes;
 170         }
 171
 172
 173         return ctdb;
 174 }
 175
 176
 177 /*
 178   startup a client only ctdb context
 179  */
 180 struct ctdb_context *ctdb_cmdline_client(struct event_context *ev)
 181 {
 182         struct ctdb_context *ctdb;
 183         int ret;
 184
 185         /* initialise ctdb */
 186         ctdb = ctdb_init(ev);
 187         if (ctdb == NULL) {
 188                 printf("Failed to init ctdb\n");
 189                 exit(1);
 190         }
 191
 192         /* tell ctdb the socket address */
 193         ret = ctdb_set_socketname(ctdb, ctdb_cmdline.socketname);
 194         if (ret == -1) {
 195                 printf("ctdb_set_socketname failed - %s\n", ctdb_errstr(ctdb));
 196                 exit(1);
 197         }
 198
 199         ret = ctdb_socket_connect(ctdb);
 200         if (ret != 0) {
 201                 DEBUG(0,(__location__ " Failed to connect to daemon\n"));
 202                 talloc_free(ctdb);
 203                 return NULL;
 204         }
 205
 206         /* get our config */
 207         ret = ctdb_ctrl_get_config(ctdb);
 208         if (ret != 0) {
 209                 DEBUG(0,(__location__ " Failed to get ctdb config\n"));
 210                 talloc_free(ctdb);
 211                 return NULL;
 212         }
 213
 214         return ctdb;
 215 }