rename ctdb_set_message_handler to ctdb_client_set_message_handler

to avoid a colission with the function of the same name in libctdb

diff --git a/client/ctdb_client.c b/client/ctdb_client.c
index ba8d2fd9e03560bb3e2cc25be2d5af22ef8b2d0c..9ce5c020ac79df3f1efbd28db04064858a0de337 100644 (file)
--- a/client/ctdb_client.c
+++ b/client/ctdb_client.c
@@ -474,7 +474,7 @@ int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call)
   tell the daemon what messaging srvid we will use, and register the message
   handler function in the client
 */
-int ctdb_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid, 
+int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid, 
                             ctdb_message_fn_t handler,
                             void *private_data)
                                    
@@ -1849,7 +1849,7 @@ int ctdb_traverse(struct ctdb_db_context *ctdb_db, ctdb_traverse_func fn, void *
        state.private_data = private_data;
        state.fn = fn;
 
-       ret = ctdb_set_message_handler(ctdb_db->ctdb, srvid, traverse_handler, &state);
+       ret = ctdb_client_set_message_handler(ctdb_db->ctdb, srvid, traverse_handler, &state);
        if (ret != 0) {
                DEBUG(DEBUG_ERR,("Failed to setup traverse handler\n"));
                return -1;

diff --git a/include/ctdb_client.h b/include/ctdb_client.h
index a158cbde1db8c3afcb9a1c8c4c20b8a9a5dc35d7..6777b4900c7237585949a4d2c6212f248931bf4b 100644 (file)
--- a/include/ctdb_client.h
+++ b/include/ctdb_client.h
@@ -154,7 +154,7 @@ uint32_t ctdb_get_num_nodes(struct ctdb_context *ctdb);
 /* setup a handler for ctdb messages */
 typedef void (*ctdb_message_fn_t)(struct ctdb_context *, uint64_t srvid,
                                  TDB_DATA data, void *);
-int ctdb_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
+int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
                             ctdb_message_fn_t handler,
                             void *private_data);
 

diff --git a/server/ctdb_recoverd.c b/server/ctdb_recoverd.c
index 5b7bdb7d5e909f61181aaec919acd7997e4d0c38..3a2242e5c9f17343576719532caa282225e8f955 100644 (file)
--- a/server/ctdb_recoverd.c
+++ b/server/ctdb_recoverd.c
@@ -2904,31 +2904,31 @@ static void monitor_cluster(struct ctdb_context *ctdb)
        rec->priority_time = timeval_current();
 
        /* register a message port for sending memory dumps */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_MEM_DUMP, mem_dump_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_MEM_DUMP, mem_dump_handler, rec);
 
        /* register a message port for recovery elections */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_RECOVERY, election_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_RECOVERY, election_handler, rec);
 
        /* when nodes are disabled/enabled */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_SET_NODE_FLAGS, monitor_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_SET_NODE_FLAGS, monitor_handler, rec);
 
        /* when we are asked to puch out a flag change */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_PUSH_NODE_FLAGS, push_flags_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_PUSH_NODE_FLAGS, push_flags_handler, rec);
 
        /* register a message port for vacuum fetch */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_VACUUM_FETCH, vacuum_fetch_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_VACUUM_FETCH, vacuum_fetch_handler, rec);
 
        /* register a message port for reloadnodes  */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_RELOAD_NODES, reload_nodes_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_RELOAD_NODES, reload_nodes_handler, rec);
 
        /* register a message port for performing a takeover run */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_TAKEOVER_RUN, ip_reallocate_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_TAKEOVER_RUN, ip_reallocate_handler, rec);
 
        /* register a message port for disabling the ip check for a short while */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_DISABLE_IP_CHECK, disable_ip_check_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_DISABLE_IP_CHECK, disable_ip_check_handler, rec);
 
        /* register a message port for updating the recovery daemons node assignment for an ip */
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_RECD_UPDATE_IP, recd_update_ip_handler, rec);
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_RECD_UPDATE_IP, recd_update_ip_handler, rec);
 
 again:
        if (mem_ctx) {

diff --git a/tests/src/ctdb_bench.c b/tests/src/ctdb_bench.c
index 294c1efad79b3d71f241eea7f6745df767199328..17153f5aa42c6da01017290626ba4506399f1676 100644 (file)
--- a/tests/src/ctdb_bench.c
+++ b/tests/src/ctdb_bench.c
@@ -235,7 +235,7 @@ int main(int argc, const char *argv[])
        ret = ctdb_set_call(ctdb_db, incr_func,  FUNC_INCR);
        ret = ctdb_set_call(ctdb_db, fetch_func, FUNC_FETCH);
 
-       if (ctdb_set_message_handler(ctdb, 0, ring_message_handler,&msg_count))
+       if (ctdb_client_set_message_handler(ctdb, 0, ring_message_handler,&msg_count))
                goto error;
 
        printf("Waiting for cluster\n");

diff --git a/tests/src/ctdb_fetch.c b/tests/src/ctdb_fetch.c
index 7fd45dec386fd79935eedcdbea35339912b4d9ad..0ab45aaa8d430f4f731689aa528e9185ec762b93 100644 (file)
--- a/tests/src/ctdb_fetch.c
+++ b/tests/src/ctdb_fetch.c
@@ -209,7 +209,7 @@ int main(int argc, const char *argv[])
 
        ctdb = ctdb_cmdline_client(ev);
 
-       ctdb_set_message_handler(ctdb, CTDB_SRVID_RECONFIGURE, reconfigure_handler, 
+       ctdb_client_set_message_handler(ctdb, CTDB_SRVID_RECONFIGURE, reconfigure_handler, 
                                 &cluster_ready);
 
        /* attach to a specific database */
@@ -219,7 +219,7 @@ int main(int argc, const char *argv[])
                exit(1);
        }
 
-       ctdb_set_message_handler(ctdb, 0, message_handler, &msg_count);
+       ctdb_client_set_message_handler(ctdb, 0, message_handler, &msg_count);
 
        printf("Waiting for cluster\n");
        while (1) {

diff --git a/tools/ctdb.c b/tools/ctdb.c
index e6dc3fadd6f2f2a7c15295d1d90dd481a326fd93..3fad1e1639fb04402e654d3a78c492ad3eaa2248 100644 (file)
--- a/tools/ctdb.c
+++ b/tools/ctdb.c
@@ -2001,7 +2001,7 @@ static int control_ipreallocate(struct ctdb_context *ctdb, int argc, const char
        /* register a message port for receiveing the reply so that we
           can receive the reply
        */
-       ctdb_set_message_handler(ctdb, rd.srvid, ip_reallocate_handler, NULL);
+       ctdb_client_set_message_handler(ctdb, rd.srvid, ip_reallocate_handler, NULL);
 
        data.dptr = (uint8_t *)&rd;
        data.dsize = sizeof(rd);
@@ -2773,7 +2773,7 @@ static int control_getlog(struct ctdb_context *ctdb, int argc, const char **argv
 
        DEBUG(DEBUG_ERR, ("Pulling logs from node %u\n", options.pnn));
 
-       ctdb_set_message_handler(ctdb, log_addr.srvid, log_handler, NULL);
+       ctdb_client_set_message_handler(ctdb, log_addr.srvid, log_handler, NULL);
        sleep(1);
 
        DEBUG(DEBUG_ERR,("Listen for response on %d\n", (int)log_addr.srvid));
@@ -4139,7 +4139,7 @@ static int control_rddumpmemory(struct ctdb_context *ctdb, int argc, const char
        /* register a message port for receiveing the reply so that we
           can receive the reply
        */
-       ctdb_set_message_handler(ctdb, rd.srvid, mem_dump_handler, NULL);
+       ctdb_client_set_message_handler(ctdb, rd.srvid, mem_dump_handler, NULL);
 
 
        data.dptr = (uint8_t *)&rd;
@@ -4212,7 +4212,7 @@ static int control_msglisten(struct ctdb_context *ctdb, int argc, const char **a
 
        /* register a message port and listen for messages
        */
-       ctdb_set_message_handler(ctdb, srvid, msglisten_handler, NULL);
+       ctdb_client_set_message_handler(ctdb, srvid, msglisten_handler, NULL);
        printf("Listening for messages on srvid:%d\n", (int)srvid);
 
        while (1) {