/* Format of each line is "IP pnn" - the separator has to be at least
* 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)
{
char line[1024];
ctdb_sock_addr addr;
char *t;
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) {
if (parse_ip(line, NULL, 0, &addr)) {
if (last == NULL) {
- last = talloc(ctx, struct ctdb_public_ip_list);
+ last = talloc(ctx, struct public_ip_list);
} else {
- last->next = talloc(ctx, struct ctdb_public_ip_list);
+ last->next = talloc(ctx, struct public_ip_list);
last = last->next;
}
last->next = NULL;
return ret;
}
-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) {
printf("%s %d\n", ctdb_addr_to_str(&(ips->addr)), ips->pnn);
/* Read some IPs from stdin, 1 per line, parse them and then print
* them back out. */
-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);
static bool
read_ctdb_public_ip_info(TALLOC_CTX *ctx,
int numnodes,
- struct ctdb_public_ip_list ** all_ips,
+ struct public_ip_list ** all_ips,
struct ctdb_all_public_ips *** avail)
{
char line[1024];
ctdb_sock_addr addr;
char *t, *tok;
- struct ctdb_public_ip_list * ta;
+ struct public_ip_list * ta;
int pnn, numips, curr, n, i;
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);
memset(*avail, 0,
/* Add address + pnn to all_ips */
if (last == NULL) {
- last = talloc(ctx, struct ctdb_public_ip_list);
+ last = talloc(ctx, struct public_ip_list);
} else {
- last->next = talloc(ctx, struct ctdb_public_ip_list);
+ last->next = talloc(ctx, struct public_ip_list);
last = last->next;
}
last->next = NULL;
return true;
}
-void print_ctdb_available_ips(int numnodes, struct ctdb_all_public_ips **avail)
+static void print_ctdb_available_ips(int numnodes,
+ struct ctdb_all_public_ips **avail)
{
int n, i;
}
}
-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;
- struct ctdb_public_ip_list *l;
+ struct public_ip_list *l;
struct ctdb_all_public_ips **avail;
char *tok, *ns;
}
/* Read 2 IPs from stdin, calculate the IP distance and print it. */
-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;
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
/* Read some IPs from stdin, calculate the sum of the squares of the
* IP distances between the 1st argument and those read that are on
* the given node. The given IP must one of the ones in the list. */
-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 ctdb_public_ip_list *t;
+ struct public_ip_list *l;
+ struct public_ip_list *t;
ctdb_sock_addr addr;
uint32_t distance;
/* Read some IPs from stdin, calculate the sume of the squares of the
* IP distances between the first and the rest, and print it. */
-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;
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
* create_merged_ip_list(), so should only be used in tests of
* ctdb_takeover_run_core(). Yes, it is a hack... :-)
*/
-void ctdb_test_init(const char nodestates[],
- struct ctdb_context **ctdb,
- struct ctdb_public_ip_list **all_ips,
- struct ctdb_ipflags **ipflags,
- bool read_ips_for_multiple_nodes)
+static void ctdb_test_init(const char nodestates[],
+ struct ctdb_context **ctdb,
+ struct public_ip_list **all_ips,
+ struct ctdb_ipflags **ipflags,
+ bool read_ips_for_multiple_nodes)
{
struct ctdb_all_public_ips **avail;
int i, numnodes;
uint32_t nodeflags[CTDB_TEST_MAX_NODES];
char *tok, *ns, *t;
- struct ctdb_node_map *nodemap;
+ struct ctdb_node_map_old *nodemap;
uint32_t *tval_noiptakeover;
uint32_t *tval_noiptakeoverondisabled;
enum ctdb_runstate *runstate;
while (tok != NULL) {
nodeflags[numnodes] = (uint32_t) strtol(tok, NULL, 0);
numnodes++;
- if (numnodes > CTDB_TEST_MAX_NODES) {
+ if (numnodes >= CTDB_TEST_MAX_NODES) {
DEBUG(DEBUG_ERR, ("ERROR: Exceeding CTDB_TEST_MAX_NODES: %d\n", CTDB_TEST_MAX_NODES));
exit(1);
}
runstate = get_runstate(*ctdb, numnodes);
- nodemap = talloc_array(*ctdb, struct ctdb_node_map, numnodes);
+ nodemap = talloc_array(*ctdb, struct ctdb_node_map_old, numnodes);
nodemap->num = numnodes;
if (!read_ips_for_multiple_nodes) {
}
/* IP layout is read from stdin. */
-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_public_ip_list *all_ips;
+ struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances;
ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags, false);
- lcp2_init(ctdb, ipflags, all_ips, &lcp2_imbalances, &newly_healthy);
+ lcp2_init(ctdb, ipflags, all_ips, NULL,
+ &lcp2_imbalances, &newly_healthy);
lcp2_allocate_unassigned(ctdb, ipflags,
all_ips, lcp2_imbalances);
}
/* IP layout is read from stdin. */
-void ctdb_test_lcp2_failback(const char nodestates[])
+static void ctdb_test_lcp2_failback(const char nodestates[])
{
struct ctdb_context *ctdb;
- struct ctdb_public_ip_list *all_ips;
+ struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances;
ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags, false);
- lcp2_init(ctdb, ipflags, all_ips, &lcp2_imbalances, &newly_healthy);
+ lcp2_init(ctdb, ipflags, all_ips, NULL,
+ &lcp2_imbalances, &newly_healthy);
lcp2_failback(ctdb, ipflags,
all_ips, lcp2_imbalances, newly_healthy);
}
/* IP layout is read from stdin. */
-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_public_ip_list *all_ips;
+ struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags;
uint32_t *lcp2_imbalances;
ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags, false);
- lcp2_init(ctdb, ipflags, all_ips, &lcp2_imbalances, &newly_healthy);
+ lcp2_init(ctdb, ipflags, all_ips, NULL,
+ &lcp2_imbalances, &newly_healthy);
lcp2_failback(ctdb, ipflags,
all_ips, lcp2_imbalances, newly_healthy);
/* IP layout is read from stdin. See comment for ctdb_test_init() for
* explanation of read_ips_for_multiple_nodes.
*/
-void ctdb_test_ctdb_takeover_run_core(const char nodestates[],
- bool read_ips_for_multiple_nodes)
+static void ctdb_test_ctdb_takeover_run_core(const char nodestates[],
+ bool read_ips_for_multiple_nodes)
{
struct ctdb_context *ctdb;
- struct ctdb_public_ip_list *all_ips;
+ struct public_ip_list *all_ips;
struct ctdb_ipflags *ipflags;
ctdb_test_init(nodestates, &ctdb, &all_ips, &ipflags,
read_ips_for_multiple_nodes);
- ctdb_takeover_run_core(ctdb, ipflags, &all_ips);
+ ctdb_takeover_run_core(ctdb, ipflags, &all_ips, NULL);
print_ctdb_public_ip_list(all_ips);
talloc_free(ctdb);
}
-void usage(void)
+static void usage(void)
{
fprintf(stderr, "usage: ctdb_takeover_tests <op>\n");
exit(1);
int main(int argc, const char *argv[])
{
- LogLevel = DEBUG_DEBUG;
+ DEBUGLEVEL = DEBUG_DEBUG;
if (getenv("CTDB_TEST_LOGLEVEL")) {
- LogLevel = atoi(getenv("CTDB_TEST_LOGLEVEL"));
+ DEBUGLEVEL = atoi(getenv("CTDB_TEST_LOGLEVEL"));
}
if (argc < 2) {
git.samba.org / kai / samba-autobuild / .git / blobdiff