along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-#include "lib/events/events.h"
+#include "lib/tevent/tevent.h"
#include "lib/tdb/include/tdb.h"
#include "lib/util/dlinklist.h"
#include "system/network.h"
struct ctdb_do_takeip_state *state =
talloc_get_type(private_data, struct ctdb_do_takeip_state);
int32_t ret;
+ TDB_DATA data;
if (status != 0) {
if (status == -ETIME) {
return;
}
+ data.dptr = (uint8_t *)ctdb_addr_to_str(&state->vnn->public_address);
+ data.dsize = strlen((char *)data.dptr) + 1;
+ DEBUG(DEBUG_INFO,(__location__ " sending TAKE_IP for '%s'\n", data.dptr));
+
+ ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_TAKE_IP, data);
+
+
/* the control succeeded */
ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
talloc_free(state);
return -1;
}
- if (vnn->iface == old) {
- DEBUG(DEBUG_ERR,("update of IP %s/%u trying to "
- "assin a same interface '%s'\n",
- ctdb_addr_to_str(&vnn->public_address),
- vnn->public_netmask_bits,
- old->name));
- return -1;
- }
-
state = talloc(vnn, struct ctdb_do_updateip_state);
CTDB_NO_MEMORY(ctdb, state);
return -1;
}
+ if (vnn->iface == NULL && vnn->pnn == -1 && have_ip && best_iface != NULL) {
+ DEBUG(DEBUG_ERR,("Taking over newly created ip\n"));
+ have_ip = false;
+ }
+
if (vnn->iface == NULL && have_ip) {
DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
- "but we have no interface assigned, has someone manually configured it?"
- "banning ourself\n",
+ "but we have no interface assigned, has someone manually configured it? Ignore for now.\n",
ctdb_addr_to_str(&vnn->public_address)));
- ctdb_ban_self(ctdb);
return -1;
}
- if (vnn->pnn != ctdb->pnn && have_ip) {
+ if (vnn->pnn != ctdb->pnn && have_ip && vnn->pnn != -1) {
DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
"and we have it on iface[%s], but it was assigned to node %d"
"and we are node %d, banning ourself\n",
return -1;
}
+ if (vnn->pnn == -1 && have_ip) {
+ vnn->pnn = ctdb->pnn;
+ DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
+ "and we already have it on iface[%s], update local daemon\n",
+ ctdb_addr_to_str(&vnn->public_address),
+ ctdb_vnn_iface_string(vnn)));
+ return 0;
+ }
+
if (vnn->iface) {
if (vnn->iface->link_up) {
/* only move when the rebalance gains something */
}
if (vnn->iface == NULL) {
- DEBUG(DEBUG_CRIT,(__location__ " release_ip of IP %s is known to the kernel, "
- "but we have no interface assigned, has someone manually configured it?"
- "banning ourself\n",
+ DEBUG(DEBUG_ERR,(__location__ " release_ip of IP %s is known to the kernel, "
+ "but we have no interface assigned, has someone manually configured it? Ignore for now.\n",
ctdb_addr_to_str(&vnn->public_address)));
- ctdb_ban_self(ctdb);
- return -1;
+ return 0;
}
DEBUG(DEBUG_NOTICE,("Release of IP %s/%u on interface %s node:%d\n",
vnn->public_address = *addr;
vnn->public_netmask_bits = mask;
vnn->pnn = -1;
+ if (ctdb_sys_have_ip(addr)) {
+ DEBUG(DEBUG_ERR,("We are already hosting public address '%s'. setting PNN to ourself:%d\n", ctdb_addr_to_str(addr), ctdb->pnn));
+ vnn->pnn = ctdb->pnn;
+ }
for (i=0; vnn->ifaces[i]; i++) {
ret = ctdb_add_local_iface(ctdb, vnn->ifaces[i]);
talloc_free(vnn);
return -1;
}
+ if (i == 0) {
+ vnn->iface = ctdb_find_iface(ctdb, vnn->ifaces[i]);
+ }
}
DLIST_ADD(ctdb->vnn, vnn);
const char *ip)
{
struct ctdb_vnn *svnn;
+ struct ctdb_iface *cur = NULL;
bool ok;
int ret;
return -1;
}
+ /* assume the single public ip interface is initially "good" */
+ cur = ctdb_find_iface(ctdb, iface);
+ if (cur == NULL) {
+ DEBUG(DEBUG_CRIT,("Can not find public interface %s used by --single-public-ip", iface));
+ return -1;
+ }
+ cur->link_up = true;
+
ret = ctdb_vnn_assign_iface(ctdb, svnn);
if (ret != 0) {
talloc_free(svnn);
static void *add_ip_callback(void *parm, void *data)
{
+ struct ctdb_public_ip_list *this_ip = parm;
+ struct ctdb_public_ip_list *prev_ip = data;
+
+ if (prev_ip == NULL) {
+ return parm;
+ }
+ if (this_ip->pnn == -1) {
+ this_ip->pnn = prev_ip->pnn;
+ }
+
return parm;
}
int i, num_healthy, retries;
struct ctdb_public_ip ip;
struct ctdb_public_ipv4 ipv4;
- uint32_t mask;
+ uint32_t mask, *nodes;
struct ctdb_public_ip_list *all_ips, *tmp_ip;
int maxnode, maxnum=0, minnode, minnum=0, num;
TDB_DATA data;
struct ctdb_client_control_state *state;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ /*
+ * ip failover is completely disabled, just send out the
+ * ipreallocated event.
+ */
+ if (ctdb->tunable.disable_ip_failover != 0) {
+ goto ipreallocated;
+ }
ZERO_STRUCT(ip);
return -1;
}
+ipreallocated:
+ /* tell all nodes to update natwg */
+ /* send the flags update natgw on all connected nodes */
+ data.dptr = discard_const("ipreallocated");
+ data.dsize = strlen((char *)data.dptr) + 1;
+ nodes = list_of_connected_nodes(ctdb, nodemap, tmp_ctx, true);
+ if (ctdb_client_async_control(ctdb, CTDB_CONTROL_RUN_EVENTSCRIPTS,
+ nodes, 0, TAKEOVER_TIMEOUT(),
+ false, data,
+ NULL, NULL,
+ NULL) != 0) {
+ DEBUG(DEBUG_ERR, (__location__ " ctdb_control to updatenatgw failed\n"));
+ }
+
talloc_free(tmp_ctx);
return 0;
}
struct ctdb_control_tcp_addr new_addr;
struct ctdb_control_tcp_addr *tcp_sock = NULL;
struct ctdb_tcp_list *tcp;
- struct ctdb_control_tcp_vnn t;
+ struct ctdb_tcp_connection t;
int ret;
TDB_DATA data;
struct ctdb_client_ip *ip;
DLIST_ADD(client->tcp_list, tcp);
- t.src = tcp_sock->src;
- t.dest = tcp_sock->dest;
+ t.src_addr = tcp_sock->src;
+ t.dst_addr = tcp_sock->dest;
data.dptr = (uint8_t *)&t;
data.dsize = sizeof(t);
return NULL;
}
+
+
/*
called by a daemon to inform us of a TCP connection that one of its
clients managing that should tickled with an ACK when IP takeover is
done
*/
-int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata)
+int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tcp_update_needed)
{
- struct ctdb_control_tcp_vnn *p = (struct ctdb_control_tcp_vnn *)indata.dptr;
+ struct ctdb_tcp_connection *p = (struct ctdb_tcp_connection *)indata.dptr;
struct ctdb_tcp_array *tcparray;
struct ctdb_tcp_connection tcp;
struct ctdb_vnn *vnn;
- vnn = find_public_ip_vnn(ctdb, &p->dest);
+ vnn = find_public_ip_vnn(ctdb, &p->dst_addr);
if (vnn == NULL) {
DEBUG(DEBUG_INFO,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
- ctdb_addr_to_str(&p->dest)));
+ ctdb_addr_to_str(&p->dst_addr)));
return -1;
}
tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_tcp_connection));
CTDB_NO_MEMORY(ctdb, tcparray->connections);
- tcparray->connections[tcparray->num].src_addr = p->src;
- tcparray->connections[tcparray->num].dst_addr = p->dest;
+ tcparray->connections[tcparray->num].src_addr = p->src_addr;
+ tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
tcparray->num++;
+
+ if (tcp_update_needed) {
+ vnn->tcp_update_needed = true;
+ }
return 0;
}
/* Do we already have this tickle ?*/
- tcp.src_addr = p->src;
- tcp.dst_addr = p->dest;
+ tcp.src_addr = p->src_addr;
+ tcp.dst_addr = p->dst_addr;
if (ctdb_tcp_find(vnn->tcp_array, &tcp) != NULL) {
DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n",
ctdb_addr_to_str(&tcp.dst_addr),
CTDB_NO_MEMORY(ctdb, tcparray->connections);
vnn->tcp_array = tcparray;
- tcparray->connections[tcparray->num].src_addr = p->src;
- tcparray->connections[tcparray->num].dst_addr = p->dest;
+ tcparray->connections[tcparray->num].src_addr = p->src_addr;
+ tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
tcparray->num++;
DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n",
ntohs(tcp.dst_addr.ip.sin_port),
vnn->pnn));
+ if (tcp_update_needed) {
+ vnn->tcp_update_needed = true;
+ }
+
return 0;
}
}
+/*
+ called by a daemon to inform us of a TCP connection that one of its
+ clients used are no longer needed in the tickle database
+ */
+int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
+{
+ struct ctdb_tcp_connection *conn = (struct ctdb_tcp_connection *)indata.dptr;
+
+ ctdb_remove_tcp_connection(ctdb, conn);
+
+ return 0;
+}
+
+
/*
called when a daemon restarts - send all tickes for all public addresses
we are serving immediately to the new node.
/* have tried too many times, just give up */
if (con->count >= 5) {
- talloc_free(con);
+ /* can't delete in traverse: reparent to delete_cons */
+ talloc_steal(param, con);
return;
}
struct timeval t, void *private_data)
{
struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
-
+ void *delete_cons = talloc_new(NULL);
/* loop over all connections sending tickle ACKs */
- trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, NULL);
+ trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, delete_cons);
+ /* now we've finished traverse, it's safe to do deletion. */
+ talloc_free(delete_cons);
/* If there are no more connections to kill we can remove the
entire killtcp structure
*/
static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
{
- killtcp->vnn->killtcp = NULL;
+ if (killtcp->vnn) {
+ killtcp->vnn->killtcp = NULL;
+ }
return 0;
}
if (killtcp->fde == NULL) {
killtcp->fde = event_add_fd(ctdb->ev, killtcp, killtcp->capture_fd,
- EVENT_FD_READ | EVENT_FD_AUTOCLOSE,
+ EVENT_FD_READ,
capture_tcp_handler, killtcp);
+ tevent_fd_set_auto_close(killtcp->fde);
/* We also need to set up some events to tickle all these connections
until they are all reset