libctdb: use bool in API

Return bool instead of -1/0; that's what the young kids are doing
these days!

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

diff --git a/include/ctdb.h b/include/ctdb.h
index 1d0a08611c1e6614602f19938b0338ccc026ee8c..8aede08730bb4a76430d3e548575a8640fce2fde 100644 (file)
--- a/include/ctdb.h
+++ b/include/ctdb.h
@@ -48,7 +48,7 @@ int ctdb_get_fd(struct ctdb_connection *ctdb);
 
 int ctdb_which_events(struct ctdb_connection *ctdb);
 
-int ctdb_service(struct ctdb_connection *ctdb, int revents);
+bool ctdb_service(struct ctdb_connection *ctdb, int revents);
 
 struct ctdb_request;
 
@@ -148,11 +148,11 @@ ctdb_set_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid,
                              ctdb_callback_t callback,
                              void *private_data);
 
-int ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
-                                 struct ctdb_request *handle);
+bool ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
+                                  struct ctdb_request *handle);
 
-int ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
-                            ctdb_message_fn_t handler, void *private_data);
+bool ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
+                             ctdb_message_fn_t handler, void *private_data);
 
 
 
@@ -164,9 +164,9 @@ ctdb_remove_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid,
                                 ctdb_callback_t callback,
                                 void *private_data);
 
-int ctdb_remove_message_handler_recv(struct ctdb_request *handle);
+bool ctdb_remove_message_handler_recv(struct ctdb_request *handle);
 
-int ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid);
+bool ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid);
 
 
 
@@ -174,7 +174,7 @@ int ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid);
  * send a message to a specific node/port
  * this function is non-blocking
  */
-int ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data);
+bool ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data);
 
 
 
@@ -186,12 +186,12 @@ ctdb_getpnn_send(struct ctdb_connection *ctdb,
                 uint32_t destnode,
                 ctdb_callback_t callback,
                 void *private_data);
-int ctdb_getpnn_recv(struct ctdb_connection *ctdb,
-                    struct ctdb_request *req, uint32_t *pnn);
+bool ctdb_getpnn_recv(struct ctdb_connection *ctdb,
+                     struct ctdb_request *req, uint32_t *pnn);
 
-int ctdb_getpnn(struct ctdb_connection *ctdb,
-               uint32_t destnode,
-               uint32_t *pnn);
+bool ctdb_getpnn(struct ctdb_connection *ctdb,
+                uint32_t destnode,
+                uint32_t *pnn);
 
 
 
@@ -204,12 +204,12 @@ ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
                        uint32_t destnode,
                        ctdb_callback_t callback,
                        void *private_data);
-int ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
-                          struct ctdb_request *handle,
-                          uint32_t *recmaster);
-int ctdb_getrecmaster(struct ctdb_connection *ctdb,
-                       uint32_t destnode,
-                       uint32_t *recmaster);
+bool ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
+                           struct ctdb_request *handle,
+                           uint32_t *recmaster);
+bool ctdb_getrecmaster(struct ctdb_connection *ctdb,
+                      uint32_t destnode,
+                      uint32_t *recmaster);
 
 
 
@@ -217,7 +217,7 @@ int ctdb_getrecmaster(struct ctdb_connection *ctdb,
 /*
  * cancel a request
  */
-int ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req);
+void ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req);
 
 
 /*

diff --git a/libctdb/control.c b/libctdb/control.c
index f861146b4362991db94c3736fa95f38f42d3bd5d..d5f23f0fcdbc4117dc43664dc1666bd1d517145a 100644 (file)
--- a/libctdb/control.c
+++ b/libctdb/control.c
@@ -24,21 +24,21 @@
 #undef ctdb_getrecmaster_send
 #undef ctdb_getpnn_send
 
-int ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
+bool ctdb_getrecmaster_recv(struct ctdb_connection *ctdb,
                           struct ctdb_request *req, uint32_t *recmaster)
 {
        struct ctdb_reply_control *reply;
 
        reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_GET_RECMASTER);
        if (!reply) {
-               return -1;
+               return false;
        }
        if (reply->status == -1) {
                DEBUG(ctdb, LOG_ERR, "ctdb_getrecmaster_recv: status -1");
-               return -1;
+               return false;
        }
        *recmaster = reply->status;
-       return 0;
+       return true;
 }
 
 struct ctdb_request *ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
@@ -51,21 +51,21 @@ struct ctdb_request *ctdb_getrecmaster_send(struct ctdb_connection *ctdb,
                                        callback, private_data);
 }
 
-int ctdb_getpnn_recv(struct ctdb_connection *ctdb,
+bool ctdb_getpnn_recv(struct ctdb_connection *ctdb,
                     struct ctdb_request *req, uint32_t *pnn)
 {
        struct ctdb_reply_control *reply;
 
        reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_GET_PNN);
        if (!reply) {
-               return -1;
+               return false;
        }
        if (reply->status == -1) {
                DEBUG(ctdb, LOG_ERR, "ctdb_getpnn_recv: status -1");
-               return -1;
+               return false;
        }
        *pnn = reply->status;
-       return 0;
+       return true;
 }
 
 struct ctdb_request *ctdb_getpnn_send(struct ctdb_connection *ctdb,

diff --git a/libctdb/ctdb.c b/libctdb/ctdb.c
index 5e4121fc2ff058114fbd5cda54afd5ece7849892..3350c6e5d830dafdc2453bdfa8eeb9e52dcb2638 100644 (file)
--- a/libctdb/ctdb.c
+++ b/libctdb/ctdb.c
@@ -103,7 +103,7 @@ static void set_pnn(struct ctdb_connection *ctdb,
                    struct ctdb_request *req,
                    void *unused)
 {
-       if (ctdb_getpnn_recv(ctdb, req, &ctdb->pnn) != 0) {
+       if (!ctdb_getpnn_recv(ctdb, req, &ctdb->pnn)) {
                DEBUG(ctdb, LOG_CRIT,
                      "ctdb_connect(async): failed to get pnn");
                ctdb->broken = true;
@@ -327,10 +327,10 @@ static ssize_t real_error(ssize_t ret)
        return ret;
 }
 
-int ctdb_service(struct ctdb_connection *ctdb, int revents)
+bool ctdb_service(struct ctdb_connection *ctdb, int revents)
 {
        if (ctdb->broken) {
-               return -1;
+               return false;
        }
 
        if (holding_lock(ctdb)) {
@@ -344,7 +344,7 @@ int ctdb_service(struct ctdb_connection *ctdb, int revents)
                                DEBUG(ctdb, LOG_ERR,
                                      "ctdb_service: error writing to ctdbd");
                                ctdb->broken = true;
-                               return -1;
+                               return false;
                        }
                        if (io_elem_finished(ctdb->outq->io)) {
                                struct ctdb_request *done = ctdb->outq;
@@ -365,7 +365,7 @@ int ctdb_service(struct ctdb_connection *ctdb, int revents)
                                DEBUG(ctdb, LOG_ERR,
                                      "ctdb_service: allocating readbuf");
                                ctdb->broken = true;
-                               return -1;
+                               return false;
                        }
                }
 
@@ -377,7 +377,7 @@ int ctdb_service(struct ctdb_connection *ctdb, int revents)
                        DEBUG(ctdb, LOG_ERR,
                              "ctdb_service: error reading from ctdbd");
                        ctdb->broken = true;
-                       return -1;
+                       return false;
                } else if (ret < 0) {
                        /* No progress, stop loop. */
                        revents = 0;
@@ -387,7 +387,7 @@ int ctdb_service(struct ctdb_connection *ctdb, int revents)
                }
        }
 
-       return 0;
+       return true;
 }
 
 /* This is inefficient.  We could pull in idtree.c. */
@@ -453,14 +453,13 @@ void ctdb_cancel_callback(struct ctdb_connection *ctdb,
        ctdb_request_free(ctdb, req);
 }
 
-int ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req)
+void ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req)
 {
        DEBUG(ctdb, LOG_DEBUG, "ctdb_cancel: %p (id %u)",
              req, req->hdr.hdr ? req->hdr.hdr->reqid : 0);
 
        /* FIXME: If it's not sent, we could just free it right now. */
        req->callback = ctdb_cancel_callback;
-       return 0;
 }
 
 struct ctdb_db {

diff --git a/libctdb/messages.c b/libctdb/messages.c
index e4b03d9e9ef192e4fb51eb542faf0dd9f16b5b77..d2d3e4b05c179ce0142a9b3b8c50176e306af489 100644 (file)
--- a/libctdb/messages.c
+++ b/libctdb/messages.c
@@ -43,28 +43,28 @@ void deliver_message(struct ctdb_connection *ctdb, struct ctdb_req_header *hdr)
        }
 }
 
-int ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
-                                 struct ctdb_request *req)
+bool ctdb_set_message_handler_recv(struct ctdb_connection *ctdb,
+                                  struct ctdb_request *req)
 {
        struct message_handler_info *info = req->extra;
        struct ctdb_reply_control *reply;
 
        reply = unpack_reply_control(ctdb, req, CTDB_CONTROL_REGISTER_SRVID);
        if (!reply) {
-               return -1;
+               return false;
        }
        if (reply->status != 0) {
                DEBUG(ctdb, LOG_WARNING,
                      "ctdb_set_message_handler_recv: status %i",
                      reply->status);
-               return -1;
+               return false;
        }
 
        /* Put ourselves in list of handlers. */
        DLIST_ADD(ctdb->message_handlers, info);
        /* Keep safe from destructor */
        req->extra = NULL;
-       return 0;
+       return true;
 }
 
 static void free_info(struct ctdb_connection *ctdb, struct ctdb_request *req)
@@ -110,7 +110,7 @@ ctdb_set_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid,
        return req;
 }
 
-int ctdb_send_message(struct ctdb_connection *ctdb,
+bool ctdb_send_message(struct ctdb_connection *ctdb,
                      uint32_t pnn, uint64_t srvid,
                      TDB_DATA data)
 {
@@ -122,7 +122,7 @@ int ctdb_send_message(struct ctdb_connection *ctdb,
                               ctdb_cancel_callback, NULL);
        if (!req) {
                DEBUG(ctdb, LOG_ERR, "ctdb_set_message: allocating message");
-               return -1;
+               return false;
        }
 
        io_elem_init_req_header(req->io,
@@ -133,5 +133,5 @@ int ctdb_send_message(struct ctdb_connection *ctdb,
        pkt->datalen = data.dsize;
        memcpy(pkt->data, data.dptr, data.dsize);
        DLIST_ADD_END(ctdb->outq, req, struct ctdb_request);
-       return 0;
+       return true;
 }

diff --git a/libctdb/sync.c b/libctdb/sync.c
index b4c7b06246576cbebc9c2bdce4d1eb67e8b98c36..3ee33011a23a27e0a3b2a791186886f615fafcb8 100644 (file)
--- a/libctdb/sync.c
+++ b/libctdb/sync.c
@@ -59,12 +59,12 @@ static void set(struct ctdb_connection *ctdb,
        *done = true;
 }
 
-int ctdb_getrecmaster(struct ctdb_connection *ctdb,
-                     uint32_t destnode, uint32_t *recmaster)
+bool ctdb_getrecmaster(struct ctdb_connection *ctdb,
+                      uint32_t destnode, uint32_t *recmaster)
 {
        struct ctdb_request *req;
        bool done = false;
-       int ret = -1;
+       bool ret = false;
 
        req = synchronous(ctdb,
                          ctdb_getrecmaster_send(ctdb, destnode, set, &done),
@@ -95,12 +95,12 @@ struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
        return ret;
 }
 
-int ctdb_getpnn(struct ctdb_connection *ctdb,
-               uint32_t destnode, uint32_t *pnn)
+bool ctdb_getpnn(struct ctdb_connection *ctdb,
+                uint32_t destnode, uint32_t *pnn)
 {
        struct ctdb_request *req;
        bool done = false;
-       int ret = -1;
+       bool ret = false;
 
        req = synchronous(ctdb,
                          ctdb_getpnn_send(ctdb, destnode, set, &done),

diff --git a/libctdb/tst.c b/libctdb/tst.c
index d3afe8d8d173ec73efe33cbe1ac67af6c1339587..c8c08cfe7d1ae6162f27982a8cbbeea7b193d2eb 100644 (file)
--- a/libctdb/tst.c
+++ b/libctdb/tst.c
@@ -47,32 +47,32 @@ void msg_h(struct ctdb_connection *ctdb, uint64_t srvid, TDB_DATA data, void *pr
 static void pnn_cb(struct ctdb_connection *ctdb,
                   struct ctdb_request *req, void *private)
 {
-       int status;
+       bool status;
        uint32_t pnn;
 
        status = ctdb_getpnn_recv(ctdb, req, &pnn);
        ctdb_request_free(ctdb, req);
-       if (status != 0) {
+       if (!status) {
                printf("Error reading PNN\n");
                return;
        }
-       printf("status:%d pnn:%d\n", status, pnn);
+       printf("pnn:%d\n", pnn);
 }
 
 static void rm_cb(struct ctdb_connection *ctdb,
                  struct ctdb_request *req, void *private)
 {
-       int status;
+       bool status;
        uint32_t rm;
 
        status = ctdb_getrecmaster_recv(ctdb, req, &rm);
        ctdb_request_free(ctdb, req);
-       if (status != 0) {
+       if (!status) {
                printf("Error reading RECMASTER\n");
                return;
        }
 
-       printf("GETRECMASTER ASYNC: status:%d recmaster:%d\n", status, rm);
+       printf("GETRECMASTER ASYNC: recmaster:%d\n", rm);
 }
 
 /*
@@ -118,7 +118,7 @@ static bool registered = false;
 void message_handler_cb(struct ctdb_connection *ctdb,
                        struct ctdb_request *req, void *private)
 {
-       if (ctdb_set_message_handler_recv(ctdb, req) != 0) {
+       if (!ctdb_set_message_handler_recv(ctdb, req)) {
                err(1, "registering message");
        }
        ctdb_request_free(ctdb, req);
@@ -133,7 +133,6 @@ int main(int argc, char *argv[])
        struct ctdb_db *ctdb_db_context;
        struct pollfd pfd;
        uint32_t recmaster;
-       int ret;
        TDB_DATA msg;
        bool rrl_cb_called = false;
 
@@ -160,8 +159,7 @@ int main(int argc, char *argv[])
        msg.dptr="HelloWorld";
        msg.dsize = strlen(msg.dptr);
 
-       ret = ctdb_send_message(ctdb_connection, 0, 55, msg);
-       if (ret != 0) {
+       if (!ctdb_send_message(ctdb_connection, 0, 55, msg)) {
                printf("Failed to send message. Aborting\n");
                exit(10);
        }
@@ -183,12 +181,11 @@ int main(int argc, char *argv[])
         * calls the blocking sync function.
         * Avoid this mode for performance critical tasks
         */
-       ret = ctdb_getrecmaster(ctdb_connection, CTDB_CURRENT_NODE, &recmaster);
-       if (ret != 0) {
+       if (!ctdb_getrecmaster(ctdb_connection, CTDB_CURRENT_NODE, &recmaster)) {
                printf("Failed to receive response to getrecmaster\n");
                exit(10);
        }
-       printf("GETRECMASTER SYNC: status:%d recmaster:%d\n", ret, recmaster);
+       printf("GETRECMASTER SYNC: recmaster:%d\n", recmaster);
 
 
        handle = ctdb_getpnn_send(ctdb_connection, CTDB_CURRENT_NODE,