public void onUp(Host host) {
HostConnectionPool previous = addHost(host);
;
loadBalancer.onUp(host);
// This should not be necessary but it's harmless
if (previous != null) previous.shutdown();
}
private boolean shutdown(long timeout, TimeUnit unit) throws InterruptedException {
if (!isShutdown.compareAndSet(false, true)) return true;
long start = System.nanoTime();
boolean success = true;
for (HostConnectionPool pool : pools.values())
success &= pool.shutdown(timeout - Cluster.timeSince(start, unit), unit);
return success;
}
public void onAdd(Host host) {
HostConnectionPool previous = addHost(host);
;
loadBalancer.onAdd(host);
// This should not be necessary, especially since the host is
// supposed to be new, but it's safer to make that work correctly
// if the even is triggered multiple times.
if (previous != null) previous.shutdown();
}
/*
* When the set of live nodes change, the loadbalancer will change his
* mind on host distances. It might change it on the node that came/left
* but also on other nodes (for instance, if a node dies, another
* previously ignored node may be now considered).
*
* This method ensures that all hosts for which a pool should exist
* have one, and hosts that shouldn't don't.
*/
private void updateCreatedPools() {
for (Host h : cluster.getMetadata().allHosts()) {
HostDistance dist = loadBalancingPolicy().distance(h);
HostConnectionPool pool = pools.get(h);
if (pool == null) {
if (dist != HostDistance.IGNORED && h.getMonitor().isUp()) addOrRenewPool(h);
} else if (dist != pool.hostDistance) {
if (dist == HostDistance.IGNORED) {
removePool(h);
} else {
pool.hostDistance = dist;
}
}
}
}
public void onDown(Host host) {
loadBalancer.onDown(host);
HostConnectionPool pool = pools.remove(host);
// This should not be necessary but it's harmless
if (pool != null) pool.shutdown();
// If we've remove a host, the loadBalancer is allowed to change his mind on host distances.
for (Host h : cluster.getMetadata().allHosts()) {
if (!h.getMonitor().isUp()) continue;
HostDistance dist = loadBalancer.distance(h);
if (dist != HostDistance.IGNORED) {
HostConnectionPool p = pools.get(h);
if (p == null) addHost(host);
else p.hostDistance = dist;
}
}
}
private void removePool(Host host) {
HostConnectionPool pool = pools.remove(host);
if (pool != null) pool.shutdown();
}
public void onRemove(Host host) {
loadBalancer.onRemove(host);
HostConnectionPool pool = pools.remove(host);
if (pool != null) pool.shutdown();
}
private void shutdown() {
if (!isShutdown.compareAndSet(false, true)) return;
for (HostConnectionPool pool : pools.values()) pool.shutdown();
}
public void logState() {
Session s = sessions[0];
Cluster cluster = s.getCluster();
LoadBalancingPolicy lbPolicy =
cluster.getConfiguration().getPolicies().getLoadBalancingPolicy();
int count = 0;
String keyspace = null;
for (final Session session : sessions) {
SessionManager sessionM = (SessionManager) session;
Session.State sessionState = session.getState();
String newKeyspace = session.getLoggedKeyspace();
if (keyspace == null || !keyspace.equals(newKeyspace)) {
count = 0;
keyspace = newKeyspace;
}
int sessionKey = count++;
logger.info("Host States for Session {}#{}:", keyspace, sessionKey);
Collection<Host> hosts = sessionState.getConnectedHosts();
for (final Host host : hosts) {
HostConnectionPool pool = sessionM.pools.get(host);
HostDistance distance = lbPolicy.distance(host);
// Whether or not the host will reconnect while in a suspected state.
boolean isReconnectingFromSuspected =
host.getInitialReconnectionAttemptFuture() != null
&& !host.getInitialReconnectionAttemptFuture().isDone();
// Whether or not the host will reconnect while in a down state.
boolean isReconnectingFromDown =
host.getReconnectionAttemptFuture() != null
&& !host.getReconnectionAttemptFuture().isDone();
if (pool != null) {
String msg =
String.format(
"\t[%s:%s:%s] version=%s, state=%s, dist=%s, inFlight=%d, openConnections=%d, "
+ "trashedConnections=%d, reconnectFromSuspected=%s, reconnectFromDown=%s. pool=%s, poolClosed=%s",
host.getDatacenter(),
host.getRack(),
host.getAddress(),
host.getCassandraVersion(),
host.state,
distance,
sessionState.getInFlightQueries(host),
sessionState.getOpenConnections(host),
pool.trash.size(),
isReconnectingFromSuspected,
isReconnectingFromDown,
pool.hashCode(),
pool.isClosed());
logger.info(msg);
for (Connection connection : pool.connections) {
long now = System.currentTimeMillis();
Connection.State state = connection.state.get();
if (connection.isClosed()
|| connection.isDefunct()
|| state == Connection.State.TRASHED
|| state == Connection.State.GONE
|| connection.maxIdleTime > 0 && connection.maxIdleTime < now) {
logger.warn(
"\t\t{} defunct?={}, state={}, maxIdleTime={}",
connection,
connection.isDefunct(),
state,
new Date(connection.maxIdleTime));
} else {
logger.info(
"\t\t{} defunct?={}, state={}, maxIdleTime={}",
connection,
connection.isDefunct(),
state,
new Date(connection.maxIdleTime));
}
}
for (Connection connection : pool.trash) {
Connection.State state = connection.state.get();
if (connection.isClosed()
|| connection.isDefunct()
|| state == Connection.State.OPEN
|| state == Connection.State.GONE) {
logger.warn(
"\t\t{} defunct?={}, state={}, maxIdleTime={} [trash]",
connection,
connection.isDefunct(),
state,
new Date(connection.maxIdleTime));
} else {
logger.info(
"\t\t{} defunct?={}, state={}, maxIdleTime={} [trash]",
connection,
connection.isDefunct(),
state,
new Date(connection.maxIdleTime));
}
}
} else {
logger.error("Pool is null for {}.", host);
}
// Register by host / session metrics if not already registered.
// Replace periods with underscores (better graphite metric names) in host, also remove
// backslashes.
// If the host is no longer part of the session, it will return 0.
String prefix =
"Session."
+ sessionKey
+ "."
+ host.getAddress().toString().replaceAll("\\.", "_").replaceAll("/", "")
+ ".";
String inFlightKey = prefix + "inFlight";
String openConnectionsKey = prefix + "openConnections";
if (!metricRegistry.getMetrics().containsKey(inFlightKey)) {
metricRegistry.register(
inFlightKey,
new CachedGauge<Integer>(1, TimeUnit.SECONDS) {
@Override
protected Integer loadValue() {
Session.State sessionState = session.getState();
if (sessionState.getConnectedHosts().contains(host)) {
return sessionState.getInFlightQueries(host);
} else {
return 0;
}
}
});
}
if (!metricRegistry.getMetrics().containsKey(openConnectionsKey)) {
metricRegistry.register(
openConnectionsKey,
new CachedGauge<Integer>(1, TimeUnit.SECONDS) {
@Override
protected Integer loadValue() {
Session.State sessionState = session.getState();
if (sessionState.getConnectedHosts().contains(host)) {
return sessionState.getOpenConnections(host);
} else {
return 0;
}
}
});
}
}
}
ControlConnection connection = cluster.manager.controlConnection;
if (connection.isOpen()) {
logger.info("Control connection is open to {}.", connection.connectedHost());
} else {
logger.warn("Control connection is closed.");
}
List<Host> queryPlan = Lists.newArrayList(lbPolicy.newQueryPlan(null, new SimpleStatement("")));
if (queryPlan.size() == 0) {
logger.warn("Query Plan is empty!");
} else {
logger.info("Query Plan: {}", queryPlan);
}
}