#include <poll.h>
#include "includes.h"
#include "lib/events/events.h"
+#include "lib/events/events_internal.h"
#include "include/ctdb.h"
#include "include/ctdb_protocol.h"
#include "include/ctdb_private.h"
+#include <sys/time.h>
struct ctdb_context *ctdb_connect(const char *addr)
{
int ctdb_service(struct ctdb_context *ctdb)
{
int ret;
+ struct timeval t;
ret = event_loop_once(ctdb->ev);
- ret = event_loop_once(ctdb->ev);
+ do {
+ t = common_event_loop_timer_delay(ctdb->ev);
+ } while(timeval_is_zero(&t));
return 0;
}
void *private_data;
};
+
+
+
+/*************************
+ * GET PNN of local node *
+ *************************/
static void
-ctdb_getrecmaster_recv_cb(struct ctdb_client_control_state *state)
+ctdb_getpnn_recv_cb(struct ctdb_client_control_state *state)
{
struct ctdb_control_cb_data *cb_data = state->async.private_data;
- get_recmaster_cb callback = (get_recmaster_cb)cb_data->callback;
+ ctdb_getpnn_cb callback = (ctdb_getpnn_cb)cb_data->callback;
callback(0, state->status, cb_data->private_data);
}
+ctdb_handle *
+ctdb_getpnn_send(struct ctdb_context *ctdb,
+ uint32_t destnode,
+ ctdb_getpnn_cb callback,
+ void *private_data)
+{
+ struct ctdb_client_control_state *state;
+ struct ctdb_control_cb_data *cb_data;
+
+ state = ctdb_control_send(ctdb, destnode, 0,
+ CTDB_CONTROL_GET_PNN, 0, tdb_null,
+ ctdb, NULL);
+
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send GET_PNN control\n"));
+ return NULL;
+ }
+
+ if (callback != NULL) {
+ cb_data = talloc(state, struct ctdb_control_cb_data);
+ cb_data->callback = callback;
+ cb_data->private_data = private_data;
+
+ state->async.fn = ctdb_getpnn_recv_cb;
+ state->async.private_data = cb_data;
+ }
+
+ return (ctdb_handle *)state;
+}
+
+int ctdb_getpnn_recv(struct ctdb_context *ctdb, ctdb_handle *handle, uint32_t *pnn)
+{
+ struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
+ int ret;
+ int32_t res;
+
+ ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_getpnn_recv failed\n"));
+ return -1;
+ }
+
+ if (pnn != NULL) {
+ *pnn = (uint32_t)res;
+ }
+
+ return state->status;
+}
+
+int ctdb_getpnn(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *pnn)
+{
+ struct ctdb_client_control_state *state;
+
+ state = ctdb_getpnn_send(ctdb, destnode, NULL, NULL);
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_getpnn_send() failed.\n"));
+ return -1;
+ }
+
+ return ctdb_getpnn_recv(ctdb, state, pnn);
+}
+
+
+
+/***********************
+ * GET RECOVERY MASTER *
+ ***********************/
+static void
+ctdb_getrecmaster_recv_cb(struct ctdb_client_control_state *state)
+{
+ struct ctdb_control_cb_data *cb_data = state->async.private_data;
+ ctdb_getrecmaster_cb callback = (ctdb_getrecmaster_cb)cb_data->callback;
+
+ callback(0, state->status, cb_data->private_data);
+}
-/*
- get the recovery master of a remote node
- */
ctdb_handle *
ctdb_getrecmaster_send(struct ctdb_context *ctdb,
uint32_t destnode,
- get_recmaster_cb callback,
+ ctdb_getrecmaster_cb callback,
void *private_data)
{
struct ctdb_client_control_state *state;
state = ctdb_control_send(ctdb, destnode, 0,
CTDB_CONTROL_GET_RECMASTER, 0, tdb_null,
- ctdb, NULL, NULL);
+ ctdb, NULL);
+
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send GET_RECMASTER control\n"));
+ return NULL;
+ }
if (callback != NULL) {
cb_data = talloc(state, struct ctdb_control_cb_data);
return -1;
}
- if (recmaster) {
+ if (recmaster != NULL) {
*recmaster = (uint32_t)res;
}
- return 0;
+ return state->status;
}
int ctdb_getrecmaster(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *recmaster)
{
struct ctdb_client_control_state *state;
- state = ctdb_getrecmaster_send(ctdb, destnode, NULL, recmaster);
+ state = ctdb_getrecmaster_send(ctdb, destnode, NULL, NULL);
if (state == NULL) {
DEBUG(DEBUG_ERR,(__location__ " ctdb_getrecmaster_send() failed.\n"));
return -1;
+
+
+
+
+
+
+
+
+static void
+ctdb_set_message_handler_recv_cb(struct ctdb_client_control_state *state)
+{
+ struct ctdb_control_cb_data *cb_data = state->async.private_data;
+ ctdb_set_message_handler_cb callback = (ctdb_set_message_handler_cb)cb_data->callback;
+
+ callback(state->status, cb_data->private_data);
+}
+
+
+/*
+ tell the daemon what messaging srvid we will use, and register the message
+ handler function in the client
+*/
+ctdb_handle *
+ctdb_set_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
+ ctdb_set_message_handler_cb callback,
+ ctdb_message_fn_t handler,
+ void *private_data)
+
+{
+ struct ctdb_client_control_state *state;
+ struct ctdb_control_cb_data *cb_data;
+
+ if (ctdb_register_message_handler(ctdb, ctdb, srvid, handler, private_data) != 0) {
+ return NULL;
+ }
+
+ state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid,
+ CTDB_CONTROL_REGISTER_SRVID, 0, tdb_null,
+ ctdb, NULL);
+
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send REGISTER_SRVID control\n"));
+ return NULL;
+ }
+
+ if (callback != NULL) {
+ cb_data = talloc(state, struct ctdb_control_cb_data);
+ cb_data->callback = callback;
+ cb_data->private_data = private_data;
+
+ state->async.fn = ctdb_set_message_handler_recv_cb;
+ state->async.private_data = cb_data;
+ }
+
+ return (ctdb_handle *)state;
+}
+
+int ctdb_set_message_handler_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
+{
+ struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
+ int ret;
+ int32_t res;
+
+ ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
+ if (ret != 0 || res != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_set_message_handler_recv failed\n"));
+ return -1;
+ }
+
+ return state->status;
+}
+
+int ctdb_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid, ctdb_message_fn_t handler, void *private_data)
+{
+ struct ctdb_client_control_state *state;
+
+ state = ctdb_set_message_handler_send(ctdb, srvid, NULL, handler, private_data);
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_set_message_handler_send() failed.\n"));
+ return -1;
+ }
+
+ return ctdb_set_message_handler_recv(ctdb, state);
+}
+
+
+
+static void
+ctdb_remove_message_handler_recv_cb(struct ctdb_client_control_state *state)
+{
+ struct ctdb_control_cb_data *cb_data = state->async.private_data;
+ ctdb_remove_message_handler_cb callback = (ctdb_remove_message_handler_cb)cb_data->callback;
+
+ callback(state->status, cb_data->private_data);
+}
+
+
+ctdb_handle *
+ctdb_remove_message_handler_send(struct ctdb_context *ctdb, uint64_t srvid,
+ ctdb_remove_message_handler_cb callback,
+ void *private_data)
+
+{
+ struct ctdb_client_control_state *state;
+ struct ctdb_control_cb_data *cb_data;
+
+ if (ctdb_deregister_message_handler(ctdb, srvid, private_data)) {
+ return NULL;
+ }
+
+ state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, srvid,
+ CTDB_CONTROL_DEREGISTER_SRVID, 0, tdb_null,
+ ctdb, NULL);
+
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send DEREGISTER_SRVID control\n"));
+ return NULL;
+ }
+
+ if (callback != NULL) {
+ cb_data = talloc(state, struct ctdb_control_cb_data);
+ cb_data->callback = callback;
+ cb_data->private_data = private_data;
+
+ state->async.fn = ctdb_remove_message_handler_recv_cb;
+ state->async.private_data = cb_data;
+ }
+
+ return (ctdb_handle *)state;
+}
+
+
+int ctdb_remove_message_handler_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
+{
+ struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
+ int ret;
+ int32_t res;
+
+ ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
+ if (ret != 0 || res != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_remove_message_handler_recv failed\n"));
+ return -1;
+ }
+
+ return state->status;
+}
+
+/*
+ tell the daemon we no longer want a srvid
+*/
+int ctdb_remove_message_handler(struct ctdb_context *ctdb, uint64_t srvid)
+{
+ struct ctdb_client_control_state *state;
+
+ state = ctdb_remove_message_handler_send(ctdb, srvid, NULL, NULL);
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_remove_message_handler_send() failed.\n"));
+ return -1;
+ }
+
+ return ctdb_remove_message_handler_recv(ctdb, state);
+}
+
+
+
+
+
+
+
+/*
+ * Create a database. If the database already exists this is a NOP.
+ */
+static void
+ctdb_createdb_recv_cb(struct ctdb_client_control_state *state)
+{
+ struct ctdb_control_cb_data *cb_data = state->async.private_data;
+ ctdb_createdb_cb callback = (ctdb_createdb_cb)cb_data->callback;
+
+ callback(state->status, cb_data->private_data);
+}
+
+
+ctdb_handle *
+ctdb_createdb_send(struct ctdb_context *ctdb, uint32_t destnode,
+ const char *name, bool persistent,
+ ctdb_createdb_cb callback,
+ void *private_data)
+
+{
+ struct ctdb_client_control_state *state;
+ struct ctdb_control_cb_data *cb_data;
+ TDB_DATA data;
+
+ data.dptr = discard_const(name);
+ data.dsize = strlen(name)+1;
+
+ state = ctdb_control_send(ctdb, destnode, 0,
+ persistent?CTDB_CONTROL_DB_ATTACH_PERSISTENT:CTDB_CONTROL_DB_ATTACH,
+ 0, data,
+ ctdb, NULL);
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send CREATEDB control\n"));
+ return NULL;
+ }
+
+ if (callback != NULL) {
+ cb_data = talloc(state, struct ctdb_control_cb_data);
+ cb_data->callback = callback;
+ cb_data->private_data = private_data;
+
+ state->async.fn = ctdb_createdb_recv_cb;
+ state->async.private_data = cb_data;
+ }
+
+ return (ctdb_handle *)state;
+}
+
+
+int ctdb_createdb_recv(struct ctdb_context *ctdb, ctdb_handle *handle)
+{
+ struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
+ int ret;
+ int32_t res;
+
+ ret = ctdb_control_recv(ctdb, state, state, NULL, &res, NULL);
+ if (ret != 0 || res != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_createdb_recv failed\n"));
+ return -1;
+ }
+
+ return state->status;
+}
+
+int ctdb_createdb(struct ctdb_context *ctdb, uint32_t destnode, const char *name, bool persistent)
+{
+ struct ctdb_client_control_state *state;
+
+ state = ctdb_createdb_send(ctdb, destnode, name, persistent, NULL, NULL);
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_createdb_send() failed.\n"));
+ return -1;
+ }
+
+ return ctdb_createdb_recv(ctdb, state);
+}
+
+
+
git.samba.org / sahlberg / ctdb.git / blobdiff