3 Utility functions to connect to the ctdb daemon
5 Copyright (C) Andrew Tridgell 2006
6 Copyright (C) Ronnie sahlberg 2010
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 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include "lib/events/events.h"
25 #include "lib/events/events_internal.h"
26 #include "include/ctdb.h"
27 #include "include/ctdb_protocol.h"
28 #include "include/ctdb_private.h"
31 struct ctdb_context *ctdb_connect(const char *addr)
33 struct event_context *ev;
34 struct ctdb_context *ctdb;
37 ev = event_context_init(NULL);
42 fprintf(stderr, "Failed to init ctdb\n");
46 ret = ctdb_set_socketname(ctdb, addr);
48 fprintf(stderr, __location__ " ctdb_set_socketname failed - %s\n", ctdb_errstr(ctdb));
53 ret = ctdb_socket_connect(ctdb);
55 fprintf(stderr, __location__ " Failed to connect to daemon\n");
64 int ctdb_get_fd(struct ctdb_context *ctdb)
66 return ctdb->daemon.sd;
69 int ctdb_which_events(struct ctdb_context *ctdb)
71 if (ctdb_queue_length(ctdb->daemon.queue) > 0) {
72 return POLLIN|POLLOUT;
81 initialise the ctdb daemon for client applications
83 struct ctdb_context *ctdb_init(struct event_context *ev)
86 struct ctdb_context *ctdb;
88 ctdb = talloc_zero(ev, struct ctdb_context);
90 DEBUG(DEBUG_ERR,(__location__ " talloc_zero failed.\n"));
94 ctdb->idr = idr_init(ctdb);
95 CTDB_NO_MEMORY_NULL(ctdb, ctdb->idr);
97 ret = ctdb_set_socketname(ctdb, CTDB_PATH);
99 DEBUG(DEBUG_ERR,(__location__ " ctdb_set_socketname failed.\n"));
112 * This is a bit hairy. due to the way ctdbd uses events.
113 * ctdbd quite frequently uses
114 * event_add_timed(... timeval_zero() ...)
116 * for example once it has finished reading off a full pdu off the
117 * domain socket, before calling the actual recdeive function.
119 * we probably need a new event function to handle these timed events
120 * event_loop_all_queued() or similar
122 int ctdb_service(struct ctdb_context *ctdb)
127 ret = event_loop_once(ctdb->ev);
129 t = common_event_loop_timer_delay(ctdb->ev);
130 } while(timeval_is_zero(&t));
137 int ctdb_cancel(ctdb_handle *handle)
143 struct ctdb_control_cb_data {
151 /*************************
152 * GET PNN of local node *
153 *************************/
155 ctdb_getpnn_recv_cb(struct ctdb_client_control_state *state)
157 struct ctdb_control_cb_data *cb_data = state->async.private_data;
158 ctdb_getpnn_cb callback = (ctdb_getpnn_cb)cb_data->callback;
160 callback(0, state->status, cb_data->private_data);
164 ctdb_getpnn_send(struct ctdb_context *ctdb,
166 ctdb_getpnn_cb callback,
169 struct ctdb_client_control_state *state;
170 struct ctdb_control_cb_data *cb_data;
172 state = ctdb_control_send(ctdb, destnode, 0,
173 CTDB_CONTROL_GET_PNN, 0, tdb_null,
177 DEBUG(DEBUG_ERR,(__location__ " Failed to send GET_PNN control\n"));
181 if (callback != NULL) {
182 cb_data = talloc(state, struct ctdb_control_cb_data);
183 cb_data->callback = callback;
184 cb_data->private_data = private_data;
186 state->async.fn = ctdb_getpnn_recv_cb;
187 state->async.private_data = cb_data;
190 return (ctdb_handle *)state;
193 int ctdb_getpnn_recv(struct ctdb_context *ctdb, ctdb_handle *handle, uint32_t *pnn)
195 struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
199 ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
201 DEBUG(DEBUG_ERR,(__location__ " ctdb_getpnn_recv failed\n"));
206 *pnn = (uint32_t)res;
209 return state->status;
212 int ctdb_getpnn(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *pnn)
214 struct ctdb_client_control_state *state;
216 state = ctdb_getpnn_send(ctdb, destnode, NULL, NULL);
218 DEBUG(DEBUG_ERR,(__location__ " ctdb_getpnn_send() failed.\n"));
222 return ctdb_getpnn_recv(ctdb, state, pnn);
227 /***********************
228 * GET RECOVERY MASTER *
229 ***********************/
231 ctdb_getrecmaster_recv_cb(struct ctdb_client_control_state *state)
233 struct ctdb_control_cb_data *cb_data = state->async.private_data;
234 ctdb_getrecmaster_cb callback = (ctdb_getrecmaster_cb)cb_data->callback;
236 callback(0, state->status, cb_data->private_data);
240 ctdb_getrecmaster_send(struct ctdb_context *ctdb,
242 ctdb_getrecmaster_cb callback,
245 struct ctdb_client_control_state *state;
246 struct ctdb_control_cb_data *cb_data;
248 state = ctdb_control_send(ctdb, destnode, 0,
249 CTDB_CONTROL_GET_RECMASTER, 0, tdb_null,
253 DEBUG(DEBUG_ERR,(__location__ " Failed to send GET_RECMASTER control\n"));
257 if (callback != NULL) {
258 cb_data = talloc(state, struct ctdb_control_cb_data);
259 cb_data->callback = callback;
260 cb_data->private_data = private_data;
262 state->async.fn = ctdb_getrecmaster_recv_cb;
263 state->async.private_data = cb_data;
266 return (ctdb_handle *)state;
269 int ctdb_getrecmaster_recv(struct ctdb_context *ctdb, ctdb_handle *handle, uint32_t *recmaster)
271 struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
275 ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
277 DEBUG(DEBUG_ERR,(__location__ " ctdb_getrecmaster_recv failed\n"));
281 if (recmaster != NULL) {
282 *recmaster = (uint32_t)res;
285 return state->status;
288 int ctdb_getrecmaster(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *recmaster)
290 struct ctdb_client_control_state *state;
292 state = ctdb_getrecmaster_send(ctdb, destnode, NULL, NULL);
294 DEBUG(DEBUG_ERR,(__location__ " ctdb_getrecmaster_send() failed.\n"));
298 return ctdb_getrecmaster_recv(ctdb, state, recmaster);
312 ctdb_set_message_handler_recv_cb(struct ctdb_client_control_state *state)
314 struct ctdb_control_cb_data *cb_data = state->async.private_data;
315 ctdb_set_message_handler_cb callback = (ctdb_set_message_handler_cb)cb_data->callback;
317 callback(state->status, cb_data->private_data);
322 tell the daemon what messaging srvid we will use, and register the message
323 handler function in the client
326 ctdb_set_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
327 ctdb_set_message_handler_cb callback,
328 ctdb_message_fn_t handler,
332 struct ctdb_client_control_state *state;
333 struct ctdb_control_cb_data *cb_data;
335 if (ctdb_register_message_handler(ctdb, ctdb, srvid, handler, private_data) != 0) {
339 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid,
340 CTDB_CONTROL_REGISTER_SRVID, 0, tdb_null,
344 DEBUG(DEBUG_ERR,(__location__ " Failed to send REGISTER_SRVID control\n"));
348 if (callback != NULL) {
349 cb_data = talloc(state, struct ctdb_control_cb_data);
350 cb_data->callback = callback;
351 cb_data->private_data = private_data;
353 state->async.fn = ctdb_set_message_handler_recv_cb;
354 state->async.private_data = cb_data;
357 return (ctdb_handle *)state;
360 int ctdb_set_message_handler_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
362 struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
366 ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
367 if (ret != 0 || res != 0) {
368 DEBUG(DEBUG_ERR,(__location__ " ctdb_set_message_handler_recv failed\n"));
372 return state->status;
375 int ctdb_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid, ctdb_message_fn_t handler, void *private_data)
377 struct ctdb_client_control_state *state;
379 state = ctdb_set_message_handler_send(ctdb, srvid, NULL, handler, private_data);
381 DEBUG(DEBUG_ERR,(__location__ " ctdb_set_message_handler_send() failed.\n"));
385 return ctdb_set_message_handler_recv(ctdb, state);
391 ctdb_remove_message_handler_recv_cb(struct ctdb_client_control_state *state)
393 struct ctdb_control_cb_data *cb_data = state->async.private_data;
394 ctdb_remove_message_handler_cb callback = (ctdb_remove_message_handler_cb)cb_data->callback;
396 callback(state->status, cb_data->private_data);
401 ctdb_remove_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
402 ctdb_remove_message_handler_cb callback,
406 struct ctdb_client_control_state *state;
407 struct ctdb_control_cb_data *cb_data;
409 if (ctdb_deregister_message_handler(ctdb, srvid, private_data)) {
413 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid,
414 CTDB_CONTROL_DEREGISTER_SRVID, 0, tdb_null,
418 DEBUG(DEBUG_ERR,(__location__ " Failed to send DEREGISTER_SRVID control\n"));
422 if (callback != NULL) {
423 cb_data = talloc(state, struct ctdb_control_cb_data);
424 cb_data->callback = callback;
425 cb_data->private_data = private_data;
427 state->async.fn = ctdb_remove_message_handler_recv_cb;
428 state->async.private_data = cb_data;
431 return (ctdb_handle *)state;
435 int ctdb_remove_message_handler_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
437 struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
441 ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
442 if (ret != 0 || res != 0) {
443 DEBUG(DEBUG_ERR,(__location__ " ctdb_remove_message_handler_recv failed\n"));
447 return state->status;
451 tell the daemon we no longer want a srvid
453 int ctdb_remove_message_handler(struct ctdb_context *ctdb, uint64_t srvid)
455 struct ctdb_client_control_state *state;
457 state = ctdb_remove_message_handler_send(ctdb, srvid, NULL, NULL);
459 DEBUG(DEBUG_ERR,(__location__ " ctdb_remove_message_handler_send() failed.\n"));
463 return ctdb_remove_message_handler_recv(ctdb, state);
473 * Create a database. If the database already exists this is a NOP.
476 ctdb_createdb_recv_cb(struct ctdb_client_control_state *state)
478 struct ctdb_control_cb_data *cb_data = state->async.private_data;
479 ctdb_createdb_cb callback = (ctdb_createdb_cb)cb_data->callback;
481 callback(state->status, cb_data->private_data);
486 ctdb_createdb_send(struct ctdb_context *ctdb, uint32_t destnode,
487 const char *name, bool persistent,
488 ctdb_createdb_cb callback,
492 struct ctdb_client_control_state *state;
493 struct ctdb_control_cb_data *cb_data;
496 data.dptr = discard_const(name);
497 data.dsize = strlen(name)+1;
499 state = ctdb_control_send(ctdb, destnode, 0,
500 persistent?CTDB_CONTROL_DB_ATTACH_PERSISTENT:CTDB_CONTROL_DB_ATTACH,
504 DEBUG(DEBUG_ERR,(__location__ " Failed to send CREATEDB control\n"));
508 if (callback != NULL) {
509 cb_data = talloc(state, struct ctdb_control_cb_data);
510 cb_data->callback = callback;
511 cb_data->private_data = private_data;
513 state->async.fn = ctdb_createdb_recv_cb;
514 state->async.private_data = cb_data;
517 return (ctdb_handle *)state;
521 int ctdb_createdb_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
523 struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
527 ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
528 if (ret != 0 || res != 0) {
529 DEBUG(DEBUG_ERR,(__location__ " ctdb_createdb_recv failed\n"));
533 return state->status;
536 int ctdb_createdb(struct ctdb_context *ctdb, uint32_t destnode, const char *name, bool persistent)
538 struct ctdb_client_control_state *state;
540 state = ctdb_createdb_send(ctdb, destnode, name, persistent, NULL, NULL);
542 DEBUG(DEBUG_ERR,(__location__ " ctdb_createdb_send() failed.\n"));
546 return ctdb_createdb_recv(ctdb, state);