change the controls to return a struct ctdb_client_control_state* instead of a handle

and use a dedicated cancel fucntion for these   ctdb_cancel_control()

diff --git a/include/ctdb.h b/include/ctdb.h
index 33551d43b5cc4bebeec593079919c59e87004403..716e2a1312ff142b834180a4645eeb8fd53f7f8c 100644 (file)
--- a/include/ctdb.h
+++ b/include/ctdb.h
@@ -75,9 +75,9 @@ int ctdb_service(struct ctdb_context *ctdb);
 
 
 typedef void ctdb_handle;
+struct ctdb_client_control_state;
 
-
-typedef void (*ctdb_control_callback)(int32_t status, struct ctdb_context *ctdb, ctdb_handle *, void *private_data);
+typedef void (*ctdb_control_callback)(int32_t status, struct ctdb_context *ctdb, struct ctdb_client_control_state *state, void *private_data);
 
 
 /*
@@ -290,14 +290,17 @@ int ctdb_send_message(struct ctdb_context *ctdb, uint32_t pnn, uint64_t srvid, T
 
 /*
  * functions to read the pnn number of the local node
+ *
+ * ctdb_cancel_control(state) is used
+ * to abort this command before it completes.
  */
-ctdb_handle *
+struct ctdb_client_control_state *
 ctdb_getpnn_send(struct ctdb_context *ctdb,
                 uint32_t destnode,
                 ctdb_control_callback callback,
                 void *private_data);
 int ctdb_getpnn_recv(struct ctdb_context *ctdb,
-                    ctdb_handle *handle,
+                    struct ctdb_client_control_state *state,
                     uint32_t *pnn);
 int ctdb_getpnn(struct ctdb_context *ctdb,
                uint32_t destnode,
@@ -308,24 +311,32 @@ int ctdb_getpnn(struct ctdb_context *ctdb,
 
 /*
  * functions to read the recovery master of a node
+ *
+ * ctdb_cancel_control(state) is used
+ * to abort this command before it completes.
  */
-ctdb_handle *
+struct ctdb_client_control_state *
 ctdb_getrecmaster_send(struct ctdb_context *ctdb,
                        uint32_t destnode,
                        ctdb_control_callback callback,
                        void *private_data);
 int ctdb_getrecmaster_recv(struct ctdb_context *ctdb,
-                       ctdb_handle *handle,
-                       uint32_t *recmaster);
+                          struct ctdb_client_control_state *state,
+                          uint32_t *recmaster);
 int ctdb_getrecmaster(struct ctdb_context *ctdb,
                        uint32_t destnode,
                        uint32_t *recmaster);
 
 
 
+/*
+ * Cancel a control before it has completed
+ */
+int ctdb_cancel_control(struct ctdb_client_control_state *state);
+
 
 /*
- * cancel a request/call or release a resource
+ * release a handle
  */
 int ctdb_free(ctdb_handle *);
 

diff --git a/libctdb/libctdb.c b/libctdb/libctdb.c
index b6df7e7175f20da2a807acb8fe58452a06a323b2..25d60b796a8b7b269f33fd46ca1306f2e0b7f44d 100644 (file)
--- a/libctdb/libctdb.c
+++ b/libctdb/libctdb.c
@@ -64,40 +64,32 @@ ctdb_control_cb(struct ctdb_client_control_state *state)
  * This function is used to set the callback action for a handle
  */
 static int
-ctdb_set_control_callback(ctdb_handle *handle, ctdb_control_callback callback, void *private_data)
+ctdb_set_control_callback(struct ctdb_client_control_state *state, ctdb_control_callback callback, void *private_data)
 {
-       struct ctdb_client_control_state *control_state = talloc_get_type(handle, struct ctdb_client_control_state);
-
-       if (control_state != NULL) {
-               struct ctdb_control_cb_data *cb_data;
-
-               if (callback == NULL) {
-                       if (control_state->async.private_data != NULL) {
-                               talloc_free(control_state->async.private_data);
-                               control_state->async.private_data = NULL;
-                       }
-                       control_state->async.fn           = NULL;
-
-                       return 0;
-               }
+       struct ctdb_control_cb_data *cb_data;
 
-               cb_data = talloc(control_state, struct ctdb_control_cb_data);
-               if (cb_data == NULL) {
-                       DEBUG(DEBUG_ERR, (__location__ " Failed to alloc cb_data\n"));
-                       return -1;
+       if (callback == NULL) {
+               if (state->async.private_data != NULL) {
+                       talloc_free(state->async.private_data);
+                       state->async.private_data = NULL;
                }
+               state->async.fn           = NULL;
+               return 0;
+       }
 
-               cb_data->callback     = callback;
-               cb_data->private_data = private_data;
+       cb_data = talloc(state, struct ctdb_control_cb_data);
+       if (cb_data == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " Failed to alloc cb_data\n"));
+               return -1;
+       }
 
-               control_state->async.fn           = ctdb_control_cb;
-               control_state->async.private_data = cb_data;
+       cb_data->callback     = callback;
+       cb_data->private_data = private_data;
 
-               return 0;
-       }
+       state->async.fn           = ctdb_control_cb;
+       state->async.private_data = cb_data;
 
-       DEBUG(DEBUG_ERR, (__location__ " Unknown type of handle passed to ctdb_set_callback.\n"));
-       return -1;
+       return 0;
 }
 
 
@@ -226,6 +218,11 @@ int ctdb_service(struct ctdb_context *ctdb)
 }
 
 
+int ctdb_cancel_control(struct ctdb_client_control_state *state)
+{
+       talloc_free(state);
+       return 0;
+}
 
 int ctdb_free(ctdb_handle *handle)
 {
@@ -239,7 +236,7 @@ int ctdb_free(ctdb_handle *handle)
 /*************************
  * GET PNN of local node *
  *************************/
-ctdb_handle *
+struct ctdb_client_control_state *
 ctdb_getpnn_send(struct ctdb_context *ctdb,
                        uint32_t destnode,
                        ctdb_control_callback callback,
@@ -260,12 +257,11 @@ ctdb_getpnn_send(struct ctdb_context *ctdb,
                ctdb_set_control_callback(state, callback, private_data);
        }
 
-       return (ctdb_handle *)state;
+       return state;
 }
 
-int ctdb_getpnn_recv(struct ctdb_context *ctdb, ctdb_handle *handle, uint32_t *pnn)
+int ctdb_getpnn_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state, uint32_t *pnn)
 {
-       struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
        int ret;
 
        if (state->c->opcode != CTDB_CONTROL_GET_PNN) {
@@ -303,7 +299,7 @@ int ctdb_getpnn(struct ctdb_context *ctdb, uint32_t destnode, uint32_t *pnn)
 /***********************
  * GET RECOVERY MASTER *
  ***********************/
-ctdb_handle *
+struct ctdb_client_control_state *
 ctdb_getrecmaster_send(struct ctdb_context *ctdb,
                        uint32_t destnode,
                        ctdb_control_callback callback,
@@ -324,12 +320,11 @@ ctdb_getrecmaster_send(struct ctdb_context *ctdb,
                ctdb_set_control_callback(state, callback, private_data);
        }
 
-       return (ctdb_handle *)state;
+       return state;
 }
 
-int ctdb_getrecmaster_recv(struct ctdb_context *ctdb, ctdb_handle *handle, uint32_t *recmaster)
+int ctdb_getrecmaster_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state, uint32_t *recmaster)
 {
-       struct ctdb_client_control_state *state = talloc_get_type(handle, struct ctdb_client_control_state);
        int ret;
 
        if (state->c->opcode != CTDB_CONTROL_GET_RECMASTER) {

diff --git a/libctdb/tst.c b/libctdb/tst.c
index abedd20470d5810057f0c9294296f33ee525fbd9..c66d4d51aca36753264fb47e0b4753f4db1f793d 100644 (file)
--- a/libctdb/tst.c
+++ b/libctdb/tst.c
@@ -15,7 +15,7 @@ void msg_h(struct ctdb_context *ctdb, uint64_t srvid, TDB_DATA data, void *priva
 }
 
 
-void pnn_cb(int32_t status, struct ctdb_context *ctdb, ctdb_handle *handle, void *private_data)
+void pnn_cb(int32_t status, struct ctdb_context *ctdb, struct ctdb_client_control_state *state, void *private_data)
 {
        uint32_t pnn;
        int ret;
@@ -25,7 +25,7 @@ void pnn_cb(int32_t status, struct ctdb_context *ctdb, ctdb_handle *handle, void
                return;
        }
 
-       ret = ctdb_getpnn_recv(ctdb, handle, &pnn);
+       ret = ctdb_getpnn_recv(ctdb, state, &pnn);
        if (ret != 0) {
                printf("Failed to read getpnn reply\n");
                return;
@@ -34,7 +34,7 @@ void pnn_cb(int32_t status, struct ctdb_context *ctdb, ctdb_handle *handle, void
        printf("status:%d pnn:%d\n", status, pnn);
 }
 
-void rm_cb(int32_t status, struct ctdb_context *ctdb, ctdb_handle *handle, void *private_data)
+void rm_cb(int32_t status, struct ctdb_context *ctdb, struct ctdb_client_control_state *state, void *private_data)
 {
        uint32_t rm;
        int ret;
@@ -44,7 +44,7 @@ void rm_cb(int32_t status, struct ctdb_context *ctdb, ctdb_handle *handle, void
                return;
        }
 
-       ret = ctdb_getrecmaster_recv(ctdb, handle, &rm);
+       ret = ctdb_getrecmaster_recv(ctdb, state, &rm);
        if (ret != 0) {
                printf("Failed to read getpnn reply\n");
                return;
@@ -98,6 +98,7 @@ int main(int argc, char *argv[])
 {
        struct ctdb_context *ctdb;
        struct ctdb_db_context *ctdb_db_context;
+       struct ctdb_client_control_state *control_state;
        ctdb_handle *handle;
        struct pollfd pfd;
        int ret;
@@ -146,8 +147,8 @@ int main(int argc, char *argv[])
         * ASYNC call with callback to read the recmaster
         * this is the preferred way to use libctdb
         */
-       handle = ctdb_getrecmaster_send(ctdb, CTDB_CURRENT_NODE, rm_cb, NULL);
-       if (handle == NULL) {
+       control_state = ctdb_getrecmaster_send(ctdb, CTDB_CURRENT_NODE, rm_cb, NULL);
+       if (control_state == NULL) {
                printf("Failed to send get_recmaster control\n");
                exit(10);
        }
@@ -157,15 +158,14 @@ int main(int argc, char *argv[])
         * calls the blocking *_recv() function.
         * Avoid this mode for performance critical tasks
         */
-       handle = ctdb_getrecmaster_send(ctdb, CTDB_CURRENT_NODE, NULL, NULL);
-       if (handle == NULL) {
+       control_state = ctdb_getrecmaster_send(ctdb, CTDB_CURRENT_NODE, NULL, NULL);
+       if (control_state == NULL) {
                printf("Failed to send get_recmaster control\n");
                exit(10);
        }
-       ret = ctdb_getrecmaster_recv(ctdb, handle, &recmaster);
+       ret = ctdb_getrecmaster_recv(ctdb, control_state, &recmaster);
        if (ret != 0) {
                printf("Failed to receive response to getrecmaster\n");
-               ctdb_free(handle);
                exit(10);
        }
        printf("GETRECMASTER SEMI-SYNC: status:%d recmaster:%d\n", ret, recmaster);