sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-11 05:18:09 +03:00
Code

ctdb-daemon: Rename struct ctdb_public_ip_list to public_ip_list

Browse Source 
A private structure need not have ctdb_ prefix.

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>
This commit is contained in:
Amitay Isaacs 2015-10-28 17:10:54 +11:00 committed by Martin Schwenke
parent afc5d8a442
commit 2b76e58032
2 changed files with 71 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
ctdb/server/ctdb_takeover.c
View File

@ -1228,8 +1228,8 @@ int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
return 0; return 0;
} }
struct ctdb_public_ip_list { struct public_ip_list {
struct ctdb_public_ip_list *next; struct public_ip_list *next;
uint32_t pnn; uint32_t pnn;
ctdb_sock_addr addr; ctdb_sock_addr addr;
}; };
@ -1237,9 +1237,8 @@ struct ctdb_public_ip_list {
/* Given a physical node, return the number of /* Given a physical node, return the number of
public addresses that is currently assigned to this node. public addresses that is currently assigned to this node.
*/ */
static int node_ip_coverage(struct ctdb_context *ctdb, static int node_ip_coverage(struct ctdb_context *ctdb, int32_t pnn,
int32_t pnn, struct public_ip_list *ips)
struct ctdb_public_ip_list *ips)
{ {
int num=0; int num=0;
@ -1255,9 +1254,9 @@ static int node_ip_coverage(struct ctdb_context *ctdb,
/* Can the given node host the given IP: is the public IP known to the /* Can the given node host the given IP: is the public IP known to the
* node and is NOIPHOST unset? * node and is NOIPHOST unset?
*/ */
static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn, static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags, struct ctdb_ipflags ipflags,
struct ctdb_public_ip_list *ip) struct public_ip_list *ip)
{ {
struct ctdb_all_public_ips *public_ips; struct ctdb_all_public_ips *public_ips;
int i; int i;
@ -1282,9 +1281,9 @@ static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
return false; return false;
} }
static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn, static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags, struct ctdb_ipflags ipflags,
struct ctdb_public_ip_list *ip) struct public_ip_list *ip)
{ {
if (ipflags.noiptakeover) { if (ipflags.noiptakeover) {
return false; return false;
@ -1297,10 +1296,10 @@ static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
pick the node that currently are serving the least number of ips pick the node that currently are serving the least number of ips
so that the ips get spread out evenly. so that the ips get spread out evenly.
*/ */
static int find_takeover_node(struct ctdb_context *ctdb, static int find_takeover_node(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *ip, struct public_ip_list *ip,
struct ctdb_public_ip_list *all_ips) struct public_ip_list *all_ips)
{ {
int pnn, min=0, num; int pnn, min=0, num;
int i, numnodes; int i, numnodes;
@ -1366,8 +1365,8 @@ static uint32_t *ip_key(ctdb_sock_addr *ip)
static void *add_ip_callback(void *parm, void *data) static void *add_ip_callback(void *parm, void *data)
{ {
struct ctdb_public_ip_list *this_ip = parm; struct public_ip_list *this_ip = parm;
struct ctdb_public_ip_list *prev_ip = data; struct public_ip_list *prev_ip = data;
if (prev_ip == NULL) { if (prev_ip == NULL) {
return parm; return parm;
@ -1381,19 +1380,19 @@ static void *add_ip_callback(void *parm, void *data)
static int getips_count_callback(void *param, void *data) static int getips_count_callback(void *param, void *data)
{ {
struct ctdb_public_ip_list **ip_list = (struct ctdb_public_ip_list **)param; struct public_ip_list **ip_list = (struct public_ip_list **)param;
struct ctdb_public_ip_list *new_ip = (struct ctdb_public_ip_list *)data; struct public_ip_list *new_ip = (struct public_ip_list *)data;
new_ip->next = *ip_list; new_ip->next = *ip_list;
*ip_list = new_ip; *ip_list = new_ip;
return 0; return 0;
} }
static struct ctdb_public_ip_list * static struct public_ip_list *
create_merged_ip_list(struct ctdb_context *ctdb) create_merged_ip_list(struct ctdb_context *ctdb)
{ {
int i, j; int i, j;
struct ctdb_public_ip_list *ip_list; struct public_ip_list *ip_list;
struct ctdb_all_public_ips *public_ips; struct ctdb_all_public_ips *public_ips;
if (ctdb->ip_tree != NULL) { if (ctdb->ip_tree != NULL) {
@ -1415,9 +1414,9 @@ create_merged_ip_list(struct ctdb_context *ctdb)
} }
for (j=0;j<public_ips->num;j++) { for (j=0;j<public_ips->num;j++) {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
tmp_ip = talloc_zero(ctdb->ip_tree, struct ctdb_public_ip_list); tmp_ip = talloc_zero(ctdb->ip_tree, struct public_ip_list);
CTDB_NO_MEMORY_NULL(ctdb, tmp_ip); CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
/* Do not use information about IP addresses hosted /* Do not use information about IP addresses hosted
* on other nodes, it may not be accurate */ * on other nodes, it may not be accurate */
@ -1486,10 +1485,10 @@ static uint32_t ip_distance(ctdb_sock_addr *ip1, ctdb_sock_addr *ip2)
used in the main part of the algorithm. used in the main part of the algorithm.
*/ */
static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip, static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
struct ctdb_public_ip_list *ips, struct public_ip_list *ips,
int pnn) int pnn)
{ {
struct ctdb_public_ip_list *t; struct public_ip_list *t;
uint32_t d; uint32_t d;
uint32_t sum = 0; uint32_t sum = 0;
@ -1522,9 +1521,9 @@ static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
/* Return the LCP2 imbalance metric for addresses currently assigned /* Return the LCP2 imbalance metric for addresses currently assigned
to the given node. to the given node.
*/ */
static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn) static uint32_t lcp2_imbalance(struct public_ip_list * all_ips, int pnn)
{ {
struct ctdb_public_ip_list *t; struct public_ip_list *t;
uint32_t imbalance = 0; uint32_t imbalance = 0;
@ -1546,9 +1545,9 @@ static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn)
*/ */
static void basic_allocate_unassigned(struct ctdb_context *ctdb, static void basic_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips) struct public_ip_list *all_ips)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
/* loop over all ip's and find a physical node to cover for /* loop over all ip's and find a physical node to cover for
each unassigned ip. each unassigned ip.
@ -1567,12 +1566,12 @@ static void basic_allocate_unassigned(struct ctdb_context *ctdb,
*/ */
static void basic_failback(struct ctdb_context *ctdb, static void basic_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
int num_ips) int num_ips)
{ {
int i, numnodes; int i, numnodes;
int maxnode, maxnum, minnode, minnum, num, retries; int maxnode, maxnum, minnode, minnum, num, retries;
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags); numnodes = talloc_array_length(ipflags);
retries = 0; retries = 0;
@ -1638,7 +1637,7 @@ try_again:
*/ */
if ( (maxnum > minnum+1) if ( (maxnum > minnum+1)
&& (retries < (num_ips + 5)) ){ && (retries < (num_ips + 5)) ){
struct ctdb_public_ip_list *tmp; struct public_ip_list *tmp;
/* Reassign one of maxnode's VNNs */ /* Reassign one of maxnode's VNNs */
for (tmp=all_ips;tmp;tmp=tmp->next) { for (tmp=all_ips;tmp;tmp=tmp->next) {
@ -1654,13 +1653,13 @@ try_again:
static void lcp2_init(struct ctdb_context *tmp_ctx, static void lcp2_init(struct ctdb_context *tmp_ctx,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes, uint32_t *force_rebalance_nodes,
uint32_t **lcp2_imbalances, uint32_t **lcp2_imbalances,
bool **rebalance_candidates) bool **rebalance_candidates)
{ {
int i, numnodes; int i, numnodes;
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags); numnodes = talloc_array_length(ipflags);
@ -1712,15 +1711,15 @@ static void lcp2_init(struct ctdb_context *tmp_ctx,
*/ */
static void lcp2_allocate_unassigned(struct ctdb_context *ctdb, static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances) uint32_t *lcp2_imbalances)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
int dstnode, numnodes; int dstnode, numnodes;
int minnode; int minnode;
uint32_t mindsum, dstdsum, dstimbl, minimbl; uint32_t mindsum, dstdsum, dstimbl, minimbl;
struct ctdb_public_ip_list *minip; struct public_ip_list *minip;
bool should_loop = true; bool should_loop = true;
bool have_unassigned = true; bool have_unassigned = true;
@ -1810,7 +1809,7 @@ static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
*/ */
static bool lcp2_failback_candidate(struct ctdb_context *ctdb, static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
int srcnode, int srcnode,
uint32_t *lcp2_imbalances, uint32_t *lcp2_imbalances,
bool *rebalance_candidates) bool *rebalance_candidates)
@ -1818,8 +1817,8 @@ static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
int dstnode, mindstnode, numnodes; int dstnode, mindstnode, numnodes;
uint32_t srcimbl, srcdsum, dstimbl, dstdsum; uint32_t srcimbl, srcdsum, dstimbl, dstdsum;
uint32_t minsrcimbl, mindstimbl; uint32_t minsrcimbl, mindstimbl;
struct ctdb_public_ip_list *minip; struct public_ip_list *minip;
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
/* Find an IP and destination node that best reduces imbalance. */ /* Find an IP and destination node that best reduces imbalance. */
srcimbl = 0; srcimbl = 0;
@ -1927,7 +1926,7 @@ static int lcp2_cmp_imbalance_pnn(const void * a, const void * b)
*/ */
static void lcp2_failback(struct ctdb_context *ctdb, static void lcp2_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances, uint32_t *lcp2_imbalances,
bool *rebalance_candidates) bool *rebalance_candidates)
{ {
@ -1981,9 +1980,9 @@ try_again:
static void unassign_unsuitable_ips(struct ctdb_context *ctdb, static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips) struct public_ip_list *all_ips)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
/* verify that the assigned nodes can serve that public ip /* verify that the assigned nodes can serve that public ip
and set it to -1 if not and set it to -1 if not
@ -2005,9 +2004,9 @@ static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb, static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips) struct public_ip_list *all_ips)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
int i, numnodes; int i, numnodes;
numnodes = talloc_array_length(ipflags); numnodes = talloc_array_length(ipflags);
@ -2039,10 +2038,10 @@ static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb, static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips) struct public_ip_list *all_ips)
{ {
/* This should be pushed down into basic_failback. */ /* This should be pushed down into basic_failback. */
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
int num_ips = 0; int num_ips = 0;
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) { for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
num_ips++; num_ips++;
@ -2065,7 +2064,7 @@ static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
static void ip_alloc_lcp2(struct ctdb_context *ctdb, static void ip_alloc_lcp2(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list *all_ips, struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes) uint32_t *force_rebalance_nodes)
{ {
uint32_t *lcp2_imbalances; uint32_t *lcp2_imbalances;
@ -2128,7 +2127,7 @@ static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
/* The calculation part of the IP allocation algorithm. */ /* The calculation part of the IP allocation algorithm. */
static void ctdb_takeover_run_core(struct ctdb_context *ctdb, static void ctdb_takeover_run_core(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags, struct ctdb_ipflags *ipflags,
struct ctdb_public_ip_list **all_ips_p, struct public_ip_list **all_ips_p,
uint32_t *force_rebalance_nodes) uint32_t *force_rebalance_nodes)
{ {
/* since nodes only know about those public addresses that /* since nodes only know about those public addresses that
@ -2579,7 +2578,7 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
int i, j, ret; int i, j, ret;
struct ctdb_public_ip ip; struct ctdb_public_ip ip;
uint32_t *nodes; uint32_t *nodes;
struct ctdb_public_ip_list *all_ips, *tmp_ip; struct public_ip_list *all_ips, *tmp_ip;
TDB_DATA data; TDB_DATA data;
struct timeval timeout; struct timeval timeout;
struct client_async_data *async_data; struct client_async_data *async_data;
@ -4229,7 +4228,7 @@ int verify_remote_ip_allocation(struct ctdb_context *ctdb,
struct ctdb_all_public_ips *ips, struct ctdb_all_public_ips *ips,
uint32_t pnn) uint32_t pnn)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
int i; int i;
if (ctdb->ip_tree == NULL) { if (ctdb->ip_tree == NULL) {
@ -4268,7 +4267,7 @@ int verify_remote_ip_allocation(struct ctdb_context *ctdb,
int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip) int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip)
{ {
struct ctdb_public_ip_list *tmp_ip; struct public_ip_list *tmp_ip;
/* IP tree is never built if DisableIPFailover is set */ /* IP tree is never built if DisableIPFailover is set */
if (ctdb->tunable.disable_ip_failover != 0) { if (ctdb->tunable.disable_ip_failover != 0) {

44
ctdb/tests/src/ctdb_takeover_tests.c
View File

@ -26,16 +26,16 @@
/* Format of each line is "IP pnn" - the separator has to be at least /* Format of each line is "IP pnn" - the separator has to be at least
* 1 space (not a tab or whatever - a space!). * 1 space (not a tab or whatever - a space!).
*/ */
static struct ctdb_public_ip_list * static struct public_ip_list *
read_ctdb_public_ip_list(TALLOC_CTX *ctx) read_ctdb_public_ip_list(TALLOC_CTX *ctx)
{ {
char line[1024]; char line[1024];
ctdb_sock_addr addr; ctdb_sock_addr addr;
char *t; char *t;
int pnn; int pnn;
struct ctdb_public_ip_list *last = NULL; struct public_ip_list *last = NULL;
struct ctdb_public_ip_list *ret = NULL; struct public_ip_list *ret = NULL;
while (fgets(line, sizeof(line), stdin) != NULL) { while (fgets(line, sizeof(line), stdin) != NULL) {
@ -55,9 +55,9 @@ read_ctdb_public_ip_list(TALLOC_CTX *ctx)
if (parse_ip(line, NULL, 0, &addr)) { if (parse_ip(line, NULL, 0, &addr)) {
if (last == NULL) { if (last == NULL) {
last = talloc(ctx, struct ctdb_public_ip_list); last = talloc(ctx, struct public_ip_list);
} else { } else {
last->next = talloc(ctx, struct ctdb_public_ip_list); last->next = talloc(ctx, struct public_ip_list);
last = last->next; last = last->next;
} }
last->next = NULL; last->next = NULL;
@ -74,7 +74,7 @@ read_ctdb_public_ip_list(TALLOC_CTX *ctx)
return ret; return ret;
} }
static void print_ctdb_public_ip_list(struct ctdb_public_ip_list * ips) static void print_ctdb_public_ip_list(struct public_ip_list * ips)
{ {
while (ips) { while (ips) {
printf("%s %d\n", ctdb_addr_to_str(&(ips->addr)), ips->pnn); printf("%s %d\n", ctdb_addr_to_str(&(ips->addr)), ips->pnn);
@ -86,7 +86,7 @@ static void print_ctdb_public_ip_list(struct ctdb_public_ip_list * ips)
* them back out. */ * them back out. */
static void ctdb_test_read_ctdb_public_ip_list(void) static void ctdb_test_read_ctdb_public_ip_list(void)
{ {
struct ctdb_public_ip_list *l; struct public_ip_list *l;
TALLOC_CTX *tmp_ctx = talloc_new(NULL); TALLOC_CTX *tmp_ctx = talloc_new(NULL);
@ -102,17 +102,17 @@ static void ctdb_test_read_ctdb_public_ip_list(void)
static bool static bool
read_ctdb_public_ip_info(TALLOC_CTX *ctx, read_ctdb_public_ip_info(TALLOC_CTX *ctx,
int numnodes, int numnodes,
struct ctdb_public_ip_list ** all_ips, struct public_ip_list ** all_ips,
struct ctdb_all_public_ips *** avail) struct ctdb_all_public_ips *** avail)
{ {
char line[1024]; char line[1024];
ctdb_sock_addr addr; ctdb_sock_addr addr;
char *t, *tok; char *t, *tok;
struct ctdb_public_ip_list * ta; struct public_ip_list * ta;
int pnn, numips, curr, n, i; int pnn, numips, curr, n, i;
struct ctdb_all_public_ips * a; struct ctdb_all_public_ips * a;
struct ctdb_public_ip_list *last = NULL; 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_all_public_ips *), CTDB_TEST_MAX_NODES);
memset(*avail, 0, memset(*avail, 0,
@ -159,9 +159,9 @@ read_ctdb_public_ip_info(TALLOC_CTX *ctx,
/* Add address + pnn to all_ips */ /* Add address + pnn to all_ips */
if (last == NULL) { if (last == NULL) {
last = talloc(ctx, struct ctdb_public_ip_list); last = talloc(ctx, struct public_ip_list);
} else { } else {
last->next = talloc(ctx, struct ctdb_public_ip_list); last->next = talloc(ctx, struct public_ip_list);
last = last->next; last = last->next;
} }
last->next = NULL; last->next = NULL;
@ -233,7 +233,7 @@ static void print_ctdb_available_ips(int numnodes,
static void ctdb_test_read_ctdb_public_ip_info(const char nodestates[]) static void ctdb_test_read_ctdb_public_ip_info(const char nodestates[])
{ {
int numnodes; int numnodes;
struct ctdb_public_ip_list *l; struct public_ip_list *l;
struct ctdb_all_public_ips **avail; struct ctdb_all_public_ips **avail;
char *tok, *ns; char *tok, *ns;
@ -264,7 +264,7 @@ static void ctdb_test_read_ctdb_public_ip_info(const char nodestates[])
/* Read 2 IPs from stdin, calculate the IP distance and print it. */ /* Read 2 IPs from stdin, calculate the IP distance and print it. */
static void ctdb_test_ip_distance(void) static void ctdb_test_ip_distance(void)
{ {
struct ctdb_public_ip_list *l; struct public_ip_list *l;
uint32_t distance; uint32_t distance;
TALLOC_CTX *tmp_ctx = talloc_new(NULL); TALLOC_CTX *tmp_ctx = talloc_new(NULL);
@ -284,8 +284,8 @@ static void ctdb_test_ip_distance(void)
* the given node. The given IP must one of the ones in the list. */ * the given node. The given IP must one of the ones in the list. */
static void ctdb_test_ip_distance_2_sum(const char ip[], int pnn) static void ctdb_test_ip_distance_2_sum(const char ip[], int pnn)
{ {
struct ctdb_public_ip_list *l; struct public_ip_list *l;
struct ctdb_public_ip_list *t; struct public_ip_list *t;
ctdb_sock_addr addr; ctdb_sock_addr addr;
uint32_t distance; uint32_t distance;
@ -321,7 +321,7 @@ static void ctdb_test_ip_distance_2_sum(const char ip[], int pnn)
* IP distances between the first and the rest, and print it. */ * IP distances between the first and the rest, and print it. */
static void ctdb_test_lcp2_imbalance(int pnn) static void ctdb_test_lcp2_imbalance(int pnn)
{ {
struct ctdb_public_ip_list *l; struct public_ip_list *l;
uint32_t imbalance; uint32_t imbalance;
TALLOC_CTX *tmp_ctx = talloc_new(NULL); TALLOC_CTX *tmp_ctx = talloc_new(NULL);
@ -408,7 +408,7 @@ static enum ctdb_runstate *get_runstate(TALLOC_CTX *tmp_ctx,
*/ */
static void ctdb_test_init(const char nodestates[], static void ctdb_test_init(const char nodestates[],
struct ctdb_context **ctdb, struct ctdb_context **ctdb,
struct ctdb_public_ip_list **all_ips, struct public_ip_list **all_ips,
struct ctdb_ipflags **ipflags, struct ctdb_ipflags **ipflags,
bool read_ips_for_multiple_nodes) bool read_ips_for_multiple_nodes)
{ {
@ -505,7 +505,7 @@ static void ctdb_test_init(const char nodestates[],
static void ctdb_test_lcp2_allocate_unassigned(const char nodestates[]) static void ctdb_test_lcp2_allocate_unassigned(const char nodestates[])
{ {
struct ctdb_context *ctdb; struct ctdb_context *ctdb;
struct ctdb_public_ip_list *all_ips; struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags; struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances; uint32_t *lcp2_imbalances;
@ -528,7 +528,7 @@ static void ctdb_test_lcp2_allocate_unassigned(const char nodestates[])
static void ctdb_test_lcp2_failback(const char nodestates[]) static void ctdb_test_lcp2_failback(const char nodestates[])
{ {
struct ctdb_context *ctdb; struct ctdb_context *ctdb;
struct ctdb_public_ip_list *all_ips; struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags; struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances; uint32_t *lcp2_imbalances;
@ -551,7 +551,7 @@ static void ctdb_test_lcp2_failback(const char nodestates[])
static void ctdb_test_lcp2_failback_loop(const char nodestates[]) static void ctdb_test_lcp2_failback_loop(const char nodestates[])
{ {
struct ctdb_context *ctdb; struct ctdb_context *ctdb;
struct ctdb_public_ip_list *all_ips; struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags; struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances; uint32_t *lcp2_imbalances;
@ -577,7 +577,7 @@ static void ctdb_test_ctdb_takeover_run_core(const char nodestates[],
bool read_ips_for_multiple_nodes) bool read_ips_for_multiple_nodes)
{ {
struct ctdb_context *ctdb; struct ctdb_context *ctdb;
struct ctdb_public_ip_list *all_ips; struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags; struct ctdb_ipflags *ipflags;
ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags, ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags,