ctdb-daemon: Rename struct ctdb_all_public_ips to ctdb_public_ip_list_old

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

diff --git a/ctdb/client/ctdb_client.c b/ctdb/client/ctdb_client.c
index 68392c8b6d3e1a2c5c3e9db5d7ee29749f2d6962..5f1fa61fb08bb31e7637a0b510a4ff8fbcf303af 100644 (file)
--- a/ctdb/client/ctdb_client.c
+++ b/ctdb/client/ctdb_client.c
@@ -2774,7 +2774,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
                                   struct timeval timeout, uint32_t destnode,
                                   TALLOC_CTX *mem_ctx,
                                   uint32_t flags,
-                                  struct ctdb_all_public_ips **ips)
+                                  struct ctdb_public_ip_list_old **ips)
 {
        int ret;
        TDB_DATA outdata;
@@ -2790,7 +2790,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
                return -1;
        }
 
-       *ips = (struct ctdb_all_public_ips *)talloc_memdup(mem_ctx, outdata.dptr, outdata.dsize);
+       *ips = (struct ctdb_public_ip_list_old *)talloc_memdup(mem_ctx, outdata.dptr, outdata.dsize);
        talloc_free(outdata.dptr);
 
        return 0;
@@ -2799,7 +2799,7 @@ int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
 int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
                             struct timeval timeout, uint32_t destnode,
                             TALLOC_CTX *mem_ctx,
-                            struct ctdb_all_public_ips **ips)
+                            struct ctdb_public_ip_list_old **ips)
 {
        return ctdb_ctrl_get_public_ips_flags(ctdb, timeout,
                                              destnode, mem_ctx,

diff --git a/ctdb/include/ctdb_client.h b/ctdb/include/ctdb_client.h
index aa28a20d863738ff56f1cbe08975afca189966f8..51bb359d675089c83775d1c43944466e99e11d0e 100644 (file)
--- a/ctdb/include/ctdb_client.h
+++ b/ctdb/include/ctdb_client.h
@@ -370,11 +370,11 @@ int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
 int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
                                   struct timeval timeout, uint32_t destnode,
                                   TALLOC_CTX *mem_ctx, uint32_t flags,
-                                  struct ctdb_all_public_ips **ips);
+                                  struct ctdb_public_ip_list_old **ips);
 int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
                             struct timeval timeout, uint32_t destnode,
                             TALLOC_CTX *mem_ctx,
-                            struct ctdb_all_public_ips **ips);
+                            struct ctdb_public_ip_list_old **ips);
 int ctdb_ctrl_get_public_ip_info(struct ctdb_context *ctdb,
                                 struct timeval timeout, uint32_t destnode,
                                 TALLOC_CTX *mem_ctx,

diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index 09279198782a303273145ed373ac1d1c604b307e..63b85eb6129f14516a151fed5d5a3167d1e4dded 100644 (file)
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -130,8 +130,8 @@ struct ctdb_node {
           across the nodes.  it needs to know which public ip's can be handled
           by each node.
        */
-       struct ctdb_all_public_ips *known_public_ips;
-       struct ctdb_all_public_ips *available_public_ips;
+       struct ctdb_public_ip_list_old *known_public_ips;
+       struct ctdb_public_ip_list_old *available_public_ips;
        /* used by the recovery dameon to track when a node should be banned */
        struct ctdb_banning_state *ban_state; 
 };
@@ -1008,7 +1008,7 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
                                        TDB_DATA recdata, bool *async_reply);
 
 int verify_remote_ip_allocation(struct ctdb_context *ctdb,
-                               struct ctdb_all_public_ips *ips,
+                               struct ctdb_public_ip_list_old *ips,
                                uint32_t pnn);
 int update_ip_assignment_tree(struct ctdb_context *ctdb,
                                struct ctdb_public_ip *ip);

diff --git a/ctdb/include/ctdb_protocol.h b/ctdb/include/ctdb_protocol.h
index d1e13a41fdc4c6aba9ef47fe6d61a432c086be6f..9c38385cacdf42e09489be6817b683969c6af6e7 100644 (file)
--- a/ctdb/include/ctdb_protocol.h
+++ b/ctdb/include/ctdb_protocol.h
@@ -596,7 +596,7 @@ struct ctdb_public_ip {
        ctdb_sock_addr addr;
 };
 
-struct ctdb_all_public_ips {
+struct ctdb_public_ip_list_old {
        uint32_t num;
        struct ctdb_public_ip ips[1];
 };

diff --git a/ctdb/server/ctdb_recoverd.c b/ctdb/server/ctdb_recoverd.c
index 61006bf0396945d6e17f0e091000d61c770b963a..69a9a2ca89cbd05e744a8834b044eb1ea1c9e7b5 100644 (file)
--- a/ctdb/server/ctdb_recoverd.c
+++ b/ctdb/server/ctdb_recoverd.c
@@ -3379,7 +3379,7 @@ static int verify_local_ip_allocation(struct ctdb_context *ctdb, struct ctdb_rec
           we also request a ip reallocation.
        */
        if (ctdb->tunable.disable_ip_failover == 0) {
-               struct ctdb_all_public_ips *ips = NULL;
+               struct ctdb_public_ip_list_old *ips = NULL;
 
                /* read the *available* IPs from the local node */
                ret = ctdb_ctrl_get_public_ips_flags(ctdb, CONTROL_TIMEOUT(), CTDB_CURRENT_NODE, mem_ctx, CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE, &ips);

diff --git a/ctdb/server/ctdb_takeover.c b/ctdb/server/ctdb_takeover.c
index 5ca786d7c3035b27129ca73b71251d2f00d1c7bf..3a817bb813c6351ecae6d1add3a6da02cdfa1d5f 100644 (file)
--- a/ctdb/server/ctdb_takeover.c
+++ b/ctdb/server/ctdb_takeover.c
@@ -1258,7 +1258,7 @@ static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
                             struct ctdb_ipflags ipflags,
                             struct public_ip_list *ip)
 {
-       struct ctdb_all_public_ips *public_ips;
+       struct ctdb_public_ip_list_old *public_ips;
        int i;
 
        if (ipflags.noiphost) {
@@ -1393,7 +1393,7 @@ create_merged_ip_list(struct ctdb_context *ctdb)
 {
        int i, j;
        struct public_ip_list *ip_list;
-       struct ctdb_all_public_ips *public_ips;
+       struct ctdb_public_ip_list_old *public_ips;
 
        if (ctdb->ip_tree != NULL) {
                talloc_free(ctdb->ip_tree);
@@ -3199,7 +3199,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
                                    struct ctdb_req_control_old *c, TDB_DATA *outdata)
 {
        int i, num, len;
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
        struct ctdb_vnn *vnn;
        bool only_available = false;
 
@@ -3213,7 +3213,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
                num++;
        }
 
-       len = offsetof(struct ctdb_all_public_ips, ips) + 
+       len = offsetof(struct ctdb_public_ip_list_old, ips) +
                num*sizeof(struct ctdb_public_ip);
        ips = talloc_zero_size(outdata, len);
        CTDB_NO_MEMORY(ctdb, ips);
@@ -3228,7 +3228,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
                i++;
        }
        ips->num = i;
-       len = offsetof(struct ctdb_all_public_ips, ips) +
+       len = offsetof(struct ctdb_public_ip_list_old, ips) +
                i*sizeof(struct ctdb_public_ip);
 
        outdata->dsize = len;
@@ -4225,7 +4225,7 @@ int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
    This is verified against ctdb->ip_tree
 */
 int verify_remote_ip_allocation(struct ctdb_context *ctdb,
-                               struct ctdb_all_public_ips *ips,
+                               struct ctdb_public_ip_list_old *ips,
                                uint32_t pnn)
 {
        struct public_ip_list *tmp_ip;
@@ -4349,7 +4349,7 @@ static void ctdb_reloadips_child_handler(struct tevent_context *ev,
 static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 {
        TALLOC_CTX *mem_ctx = talloc_new(NULL);
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
        struct ctdb_vnn *vnn;
        struct client_async_data *async_data;
        struct timeval timeout;

diff --git a/ctdb/tests/src/ctdb_takeover_tests.c b/ctdb/tests/src/ctdb_takeover_tests.c
index dbc25a63258325998f4dc3f1b646c3c9086ae092..6ba45bb86b011822c57e11394be6034df4601a6a 100644 (file)
--- a/ctdb/tests/src/ctdb_takeover_tests.c
+++ b/ctdb/tests/src/ctdb_takeover_tests.c
@@ -103,20 +103,21 @@ static bool
 read_ctdb_public_ip_info(TALLOC_CTX *ctx,
                         int numnodes,
                         struct public_ip_list ** all_ips,
-                        struct ctdb_all_public_ips *** avail)
+                        struct ctdb_public_ip_list_old *** avail)
 {
        char line[1024];
        ctdb_sock_addr addr;
        char *t, *tok;
        struct public_ip_list * ta;
        int pnn, numips, curr, n, i;
-       struct ctdb_all_public_ips * a;
+       struct ctdb_public_ip_list_old * a;
 
        struct public_ip_list *last = NULL;
 
-       *avail = talloc_array_size(ctx, sizeof(struct ctdb_all_public_ips *), CTDB_TEST_MAX_NODES);
+       *avail = talloc_array_size(ctx, sizeof(struct ctdb_public_ip_list_old *),
+                                  CTDB_TEST_MAX_NODES);
        memset(*avail, 0,
-              sizeof(struct ctdb_all_public_ips *) * CTDB_TEST_MAX_NODES);
+              sizeof(struct ctdb_public_ip_list_old *) * CTDB_TEST_MAX_NODES);
 
        numips = 0;
        *all_ips = NULL;
@@ -181,7 +182,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
                while (t != NULL) {
                        n = (int) strtol(t, (char **) NULL, 10);
                        if ((*avail)[n] == NULL) {
-                               (*avail)[n] = talloc_array(ctx, struct ctdb_all_public_ips, CTDB_TEST_MAX_IPS);
+                               (*avail)[n] = talloc_array(ctx, struct ctdb_public_ip_list_old, CTDB_TEST_MAX_IPS);
                                (*avail)[n]->num = 0;
                        }
                        curr = (*avail)[n]->num;
@@ -195,7 +196,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
        }
 
        /* Build list of all allowed IPs */
-       a = talloc_array(ctx, struct ctdb_all_public_ips, CTDB_TEST_MAX_IPS);
+       a = talloc_array(ctx, struct ctdb_public_ip_list_old, CTDB_TEST_MAX_IPS);
        a->num = numips;
        for (ta = *all_ips, i=0; ta != NULL && i < numips ; ta = ta->next, i++) {
                a->ips[i].pnn = ta->pnn;
@@ -213,7 +214,7 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
 }
 
 static void print_ctdb_available_ips(int numnodes,
-                                    struct ctdb_all_public_ips **avail)
+                                    struct ctdb_public_ip_list_old **avail)
 {
        int n, i;
 
@@ -234,7 +235,7 @@ static void ctdb_test_read_ctdb_public_ip_info(const char nodestates[])
 {
        int numnodes;
        struct public_ip_list *l;
-       struct ctdb_all_public_ips **avail;
+       struct ctdb_public_ip_list_old **avail;
        char *tok, *ns;
 
        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
@@ -412,7 +413,7 @@ static void ctdb_test_init(const char nodestates[],
                           struct ctdb_ipflags **ipflags,
                           bool read_ips_for_multiple_nodes)
 {
-       struct ctdb_all_public_ips **avail;
+       struct ctdb_public_ip_list_old **avail;
        int i, numnodes;
        uint32_t nodeflags[CTDB_TEST_MAX_NODES];
        char *tok, *ns, *t;

diff --git a/ctdb/tools/ctdb.c b/ctdb/tools/ctdb.c
index 184321fbdaf0bd9ef1f98ad0f13ba1203541ed30..57d2e0057592f9cb030a1daf8343b87726de1bf3 100644 (file)
--- a/ctdb/tools/ctdb.c
+++ b/ctdb/tools/ctdb.c
@@ -1748,7 +1748,7 @@ static int control_get_tickles(struct ctdb_context *ctdb, int argc, const char *
 
 static int move_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr, uint32_t pnn)
 {
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
        struct ctdb_public_ip ip;
        int i, ret;
        uint32_t *nodes;
@@ -1843,7 +1843,7 @@ static int
 find_other_host_for_public_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
 {
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
        struct ctdb_node_map_old *nodemap=NULL;
        int i, j, ret;
        int pnn;
@@ -2077,7 +2077,7 @@ static int control_rebalanceip(struct ctdb_context *ctdb, int argc, const char *
 static int getips_store_callback(void *param, void *data)
 {
        struct ctdb_public_ip *node_ip = (struct ctdb_public_ip *)data;
-       struct ctdb_all_public_ips *ips = param;
+       struct ctdb_public_ip_list_old *ips = param;
        int i;
 
        i = ips->num++;
@@ -2127,9 +2127,9 @@ static void *add_ip_callback(void *parm, void *data)
 }
 
 static int
-control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struct ctdb_all_public_ips **ips)
+control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struct ctdb_public_ip_list_old **ips)
 {
-       struct ctdb_all_public_ips *tmp_ips;
+       struct ctdb_public_ip_list_old *tmp_ips;
        struct ctdb_node_map_old *nodemap=NULL;
        trbt_tree_t *ip_tree;
        int i, j, len, ret;
@@ -2177,7 +2177,7 @@ control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struc
        count = 0;
        trbt_traversearray32(ip_tree, IP_KEYLEN, getips_count_callback, &count);
 
-       len = offsetof(struct ctdb_all_public_ips, ips) + 
+       len = offsetof(struct ctdb_public_ip_list_old, ips) +
                count*sizeof(struct ctdb_public_ip);
        tmp_ips = talloc_zero_size(tmp_ctx, len);
        trbt_traversearray32(ip_tree, IP_KEYLEN, getips_store_callback, tmp_ips);
@@ -2378,7 +2378,7 @@ static int control_addip(struct ctdb_context *ctdb, int argc, const char **argv)
        ctdb_sock_addr addr;
        struct ctdb_control_ip_iface *pub;
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
 
 
        if (argc != 2) {
@@ -2482,7 +2482,7 @@ static int control_delip_all(struct ctdb_context *ctdb, int argc, const char **a
 {
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
        struct ctdb_node_map_old *nodemap=NULL;
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
        int ret, i, j;
 
        ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, tmp_ctx, &nodemap);
@@ -2557,7 +2557,7 @@ static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv)
        ctdb_sock_addr addr;
        struct ctdb_control_ip_iface pub;
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
 
        if (argc != 1) {
                talloc_free(tmp_ctx);
@@ -2964,7 +2964,7 @@ static int control_ip(struct ctdb_context *ctdb, int argc, const char **argv)
 {
        int i, ret;
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-       struct ctdb_all_public_ips *ips;
+       struct ctdb_public_ip_list_old *ips;
 
        if (argc == 1 && strcmp(argv[0], "all") == 0) {
                options.pnn = CTDB_BROADCAST_ALL;