clean out some more cruft
[vlendec/samba-autobuild/.git] / ctdb / direct / ctdbd.c
1 /* 
2    standalone ctdb daemon
3
4    Copyright (C) Andrew Tridgell  2006
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program 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
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22 #include "lib/events/events.h"
23 #include "system/filesys.h"
24 #include "popt.h"
25 #include "system/wait.h"
26 #include "cmdline.h"
27 #include "../include/ctdb_private.h"
28
29 static void block_signal(int signum)
30 {
31         struct sigaction act;
32
33         memset(&act, 0, sizeof(act));
34
35         act.sa_handler = SIG_IGN;
36         sigemptyset(&act.sa_mask);
37         sigaddset(&act.sa_mask, signum);
38         sigaction(signum, &act, NULL);
39 }
40
41 static struct {
42         const char *nlist;
43         const char *transport;
44         const char *myaddress;
45         const char *public_address_list;
46         const char *public_interface;
47         const char *event_script;
48         const char *logfile;
49         const char *recovery_lock_file;
50         const char *db_dir;
51 } options = {
52         .nlist = ETCDIR "/ctdb/nodes",
53         .transport = "tcp",
54         .event_script = ETCDIR "/ctdb/events",
55         .logfile = VARDIR "/log/log.ctdb",
56         .db_dir = VARDIR "/ctdb",
57 };
58
59
60
61 /*
62   main program
63 */
64 int main(int argc, const char *argv[])
65 {
66         struct ctdb_context *ctdb;
67         int interactive = 0;
68
69         struct poptOption popt_options[] = {
70                 POPT_AUTOHELP
71                 POPT_CTDB_CMDLINE
72                 { "interactive", 'i', POPT_ARG_NONE, &interactive, 0, "don't fork", NULL },
73                 { "public-addresses", 0, POPT_ARG_STRING, &options.public_address_list, 0, "public address list file", "filename" },
74                 { "public-interface", 0, POPT_ARG_STRING, &options.public_interface, 0, "public interface", "interface"},
75                 { "event-script", 0, POPT_ARG_STRING, &options.event_script, 0, "event script", "filename" },
76                 { "logfile", 0, POPT_ARG_STRING, &options.logfile, 0, "log file location", "filename" },
77                 { "nlist", 0, POPT_ARG_STRING, &options.nlist, 0, "node list file", "filename" },
78                 { "listen", 0, POPT_ARG_STRING, &options.myaddress, 0, "address to listen on", "address" },
79                 { "transport", 0, POPT_ARG_STRING, &options.transport, 0, "protocol transport", NULL },
80                 { "dbdir", 0, POPT_ARG_STRING, &options.db_dir, 0, "directory for the tdb files", NULL },
81                 { "reclock", 0, POPT_ARG_STRING, &options.recovery_lock_file, 0, "location of recovery lock file", "filename" },
82                 POPT_TABLEEND
83         };
84         int opt, ret;
85         const char **extra_argv;
86         int extra_argc = 0;
87         poptContext pc;
88         struct event_context *ev;
89
90         pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
91
92         while ((opt = poptGetNextOpt(pc)) != -1) {
93                 switch (opt) {
94                 default:
95                         fprintf(stderr, "Invalid option %s: %s\n", 
96                                 poptBadOption(pc, 0), poptStrerror(opt));
97                         exit(1);
98                 }
99         }
100
101         /* setup the remaining options for the main program to use */
102         extra_argv = poptGetArgs(pc);
103         if (extra_argv) {
104                 extra_argv++;
105                 while (extra_argv[extra_argc]) extra_argc++;
106         }
107
108         if (!options.recovery_lock_file) {
109                 DEBUG(0,("You must specifiy the location of a recovery lock file with --reclock\n"));
110                 exit(1);
111         }
112
113         block_signal(SIGPIPE);
114
115         ev = event_context_init(NULL);
116
117         ctdb = ctdb_cmdline_init(ev);
118
119         ret = ctdb_set_recovery_lock_file(ctdb, options.recovery_lock_file);
120         if (ret == -1) {
121                 printf("ctdb_set_recovery_lock_file failed - %s\n", ctdb_errstr(ctdb));
122                 exit(1);
123         }
124
125         ret = ctdb_set_transport(ctdb, options.transport);
126         if (ret == -1) {
127                 printf("ctdb_set_transport failed - %s\n", ctdb_errstr(ctdb));
128                 exit(1);
129         }
130
131         /* tell ctdb what address to listen on */
132         if (options.myaddress) {
133                 ret = ctdb_set_address(ctdb, options.myaddress);
134                 if (ret == -1) {
135                         printf("ctdb_set_address failed - %s\n", ctdb_errstr(ctdb));
136                         exit(1);
137                 }
138         }
139
140         /* tell ctdb what nodes are available */
141         ret = ctdb_set_nlist(ctdb, options.nlist);
142         if (ret == -1) {
143                 printf("ctdb_set_nlist failed - %s\n", ctdb_errstr(ctdb));
144                 exit(1);
145         }
146
147         if (options.db_dir) {
148                 ret = ctdb_set_tdb_dir(ctdb, options.db_dir);
149                 if (ret == -1) {
150                         printf("ctdb_set_tdb_dir failed - %s\n", ctdb_errstr(ctdb));
151                         exit(1);
152                 }
153         }
154
155         ret = ctdb_set_logfile(ctdb, options.logfile);
156         if (ret == -1) {
157                 printf("ctdb_set_logfile to %s failed - %s\n", options.logfile, ctdb_errstr(ctdb));
158                 exit(1);
159         }
160
161         if (options.public_interface) {
162                 ctdb->takeover.interface = talloc_strdup(ctdb, options.public_interface);
163                 CTDB_NO_MEMORY(ctdb, ctdb->takeover.interface);
164         }
165
166         if (options.public_address_list) {
167                 ret = ctdb_set_public_addresses(ctdb, options.public_address_list);
168                 if (ret == -1) {
169                         printf("Unable to setup public address list\n");
170                         exit(1);
171                 }
172                 ctdb->takeover.enabled = true;
173         }
174
175         ret = ctdb_set_event_script(ctdb, options.event_script);
176         if (ret == -1) {
177                 printf("Unable to setup event script\n");
178                 exit(1);
179         }
180
181         /* useful default logfile */
182         if (ctdb->logfile == NULL) {
183                 char *name = talloc_asprintf(ctdb, "%s/log.ctdb.vnn%u", 
184                                              VARDIR, ctdb->vnn);
185                 ctdb_set_logfile(ctdb, name);
186                 talloc_free(name);
187         }
188
189         /* start the protocol running (as a child) */
190         return ctdb_start_daemon(ctdb, interactive?False:True);
191 }