source/cluster/ctdb/ctdb_cluster.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    ctdb clustering hooks
   5
   6    Copyright (C) Andrew Tridgell 2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/events/events.h"
  25 #include "cluster/cluster.h"
  26 #include "system/filesys.h"
  27 #include "cluster/cluster_private.h"
  28 #include "lib/tdb/include/tdb.h"
  29 #include "include/ctdb.h"
  30 #include "db_wrap.h"
  31 #include "lib/util/dlinklist.h"
  32
  33 /* a linked list of messaging handlers, allowing incoming messages
  34    to be directed to the right messaging context */
  35 struct cluster_messaging_list {
  36         struct cluster_messaging_list *next, *prev;
  37         struct cluster_state *state;
  38         struct messaging_context *msg;
  39         struct server_id server;
  40         cluster_message_fn_t handler;
  41 };
  42
  43 struct cluster_state {
  44         struct ctdb_context *ctdb;
  45         struct cluster_messaging_list *list;
  46 };
  47
  48
  49
  50 /*
  51   return a server_id for a ctdb node
  52 */
  53 static struct server_id ctdb_id(struct cluster_ops *ops, uint32_t id)
  54 {
  55         struct cluster_state *state = ops->private;
  56         struct ctdb_context *ctdb = state->ctdb;
  57         struct server_id server_id;
  58         server_id.node = ctdb_get_vnn(ctdb);
  59         server_id.id = id;
  60         return server_id;
  61 }
  62
  63
  64 /*
  65   return a server_id as a string
  66 */
  67 static const char *ctdb_id_string(struct cluster_ops *ops,
  68                                   TALLOC_CTX *mem_ctx, struct server_id id)
  69 {
  70         return talloc_asprintf(mem_ctx, "%u.%u", id.node, id.id);
  71 }
  72
  73 /*
  74   this is an interim method for subsystems that have not yet been
  75   converted to use the ctdb api. It opens a shared database in the
  76   cluster temporary area, using TDB_CLEAR_IF_FIRST which relies on
  77   correct operation of fcntl locks on the shared fileystem.
  78 */
  79 static struct tdb_wrap *ctdb_tdb_tmp_open(struct cluster_ops *ops,
  80                                           TALLOC_CTX *mem_ctx, const char *dbname,
  81                                           int flags)
  82 {
  83         const char *dir = lp_parm_string(-1, "ctdb", "shared data");
  84         char *path;
  85         struct tdb_wrap *w;
  86         if (dir == NULL) {
  87                 DEBUG(0,("ERROR: You must set 'ctdb:shared data' to a cluster shared path\n"));
  88                 return NULL;
  89         }
  90         path = talloc_asprintf(mem_ctx, "%s/%s", dir, dbname);
  91         w = tdb_wrap_open(mem_ctx, path, 0,
  92                           flags | TDB_CLEAR_IF_FIRST,
  93                           O_RDWR|O_CREAT, 0600);
  94         talloc_free(path);
  95         return w;
  96 }
  97
  98 /*
  99   get at the ctdb handle
 100 */
 101 static void *ctdb_backend_handle(struct cluster_ops *ops)
 102 {
 103         struct cluster_state *state = ops->private;
 104         return (void *)state->ctdb;
 105 }
 106
 107 /*
 108   dispatch incoming ctdb messages
 109 */
 110 static void ctdb_message_handler(struct ctdb_context *ctdb, uint32_t srvid,
 111                                  TDB_DATA data, void *private)
 112 {
 113 }
 114
 115 /*
 116   setup a handler for ctdb messages
 117 */
 118 static NTSTATUS ctdb_message_init(struct cluster_ops *ops,
 119                                   struct messaging_context *msg,
 120                                   struct server_id server,
 121                                   cluster_message_fn_t handler)
 122 {
 123         /* nothing to do - we're now using the wildcard message handler */
 124         return NT_STATUS_OK;
 125 }
 126
 127 /*
 128   send a ctdb message to another node
 129 */
 130 static NTSTATUS ctdb_message_send(struct cluster_ops *ops,
 131                                   struct server_id server, DATA_BLOB *data)
 132 {
 133         struct cluster_state *state = ops->private;
 134         struct ctdb_context *ctdb = state->ctdb;
 135         TDB_DATA tdata;
 136         int ret;
 137
 138         tdata.dptr = data->data;
 139         tdata.dsize = data->length;
 140
 141         ret = ctdb_send_message(ctdb, server.node, server.id, tdata);
 142         if (ret != 0) {
 143                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 144         }
 145         return NT_STATUS_OK;
 146 }
 147
 148 static struct cluster_ops cluster_ctdb_ops = {
 149         .cluster_id           = ctdb_id,
 150         .cluster_id_string    = ctdb_id_string,
 151         .cluster_tdb_tmp_open = ctdb_tdb_tmp_open,
 152         .backend_handle       = ctdb_backend_handle,
 153         .message_init         = ctdb_message_init,
 154         .message_send         = ctdb_message_send,
 155         .private           = NULL
 156 };
 157
 158 /* initialise ctdb */
 159 void cluster_ctdb_init(struct event_context *ev, const char *model)
 160 {
 161         const char *nlist;
 162         const char *address;
 163         const char *transport;
 164         struct cluster_state *state;
 165         int ret, lacount, i;
 166         const char *db_list[] = { "brlock", "opendb" };
 167
 168         nlist = lp_parm_string(-1, "ctdb", "nlist");
 169         if (nlist == NULL) return;
 170
 171         address = lp_parm_string(-1, "ctdb", "address");
 172         if (address == NULL) return;
 173
 174         transport = lp_parm_string(-1, "ctdb", "transport");
 175         if (transport == NULL) {
 176                 transport = "tcp";
 177         }
 178
 179         state = talloc(ev, struct cluster_state);
 180         if (state == NULL) goto failed;
 181
 182         state->ctdb = ctdb_init(ev);
 183         if (state->ctdb == NULL) goto failed;
 184
 185         state->list = NULL;
 186
 187         cluster_ctdb_ops.private = state;
 188
 189         ret = ctdb_set_transport(state->ctdb, transport);
 190         if (ret == -1) {
 191                 DEBUG(0,("ctdb_set_transport failed - %s\n",
 192                          ctdb_errstr(state->ctdb)));
 193                 goto failed;
 194         }
 195
 196         if (lp_parm_bool(-1, "ctdb", "selfconnect", False)) {
 197                 DEBUG(0,("Enabling ctdb selfconnect\n"));
 198                 ctdb_set_flags(state->ctdb, CTDB_FLAG_SELF_CONNECT);
 199         }
 200
 201         if (strcmp(model, "single") != 0) {
 202                 DEBUG(0,("Enabling ctdb daemon mode\n"));
 203                 ctdb_set_flags(state->ctdb, CTDB_FLAG_DAEMON_MODE);
 204         }
 205
 206         lacount = lp_parm_int(-1, "ctdb", "maxlacount", -1);
 207         if (lacount != -1) {
 208                 ctdb_set_max_lacount(state->ctdb, lacount);
 209         }
 210
 211         /* tell ctdb what address to listen on */
 212         ret = ctdb_set_address(state->ctdb, address);
 213         if (ret == -1) {
 214                 DEBUG(0,("ctdb_set_address failed - %s\n", ctdb_errstr(state->ctdb)));
 215                 goto failed;
 216         }
 217
 218         /* tell ctdb what nodes are available */
 219         ret = ctdb_set_nlist(state->ctdb, nlist);
 220         if (ret == -1) {
 221                 DEBUG(0,("ctdb_set_nlist failed - %s\n", ctdb_errstr(state->ctdb)));
 222                 goto failed;
 223         }
 224
 225         /* attach all the databases we will need */
 226         for (i=0;i<ARRAY_SIZE(db_list);i++) {
 227                 struct ctdb_db_context *ctdb_db;
 228                 ctdb_db = ctdb_attach(state->ctdb, db_list[i], TDB_INTERNAL,
 229                                       O_RDWR|O_CREAT|O_TRUNC, 0666);
 230                 if (ctdb_db == NULL) goto failed;
 231         }
 232
 233         /* setup a global message handler */
 234         ret = ctdb_set_message_handler(state->ctdb, CTDB_SRVID_ALL,
 235                                        ctdb_message_handler, state);
 236         if (ret == -1) {
 237                 DEBUG(0,("ctdb_set_message_handler failed - %s\n",
 238                          ctdb_errstr(state->ctdb)));
 239                 exit(1);
 240         }
 241
 242         /* start the protocol running */
 243         ret = ctdb_start(state->ctdb);
 244         if (ret == -1) {
 245                 DEBUG(0,("ctdb_start failed - %s\n", ctdb_errstr(state->ctdb)));
 246                 goto failed;
 247         }
 248
 249         /* wait until all nodes are connected (should not be needed
 250            outside of test code) */
 251         ctdb_connect_wait(state->ctdb);
 252
 253         cluster_set_ops(&cluster_ctdb_ops);
 254
 255         return;
 256
 257 failed:
 258         DEBUG(0,("cluster_ctdb_init failed\n"));
 259         talloc_free(state);
 260 }
 261