public void shutdown() {
try {
shutdown(0, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
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();
}
private boolean addConnectionIfUnderMaximum() {
// First, make sure we don't cross the allowed limit of open connections
for (; ; ) {
int opened = open.get();
if (opened >= options().getMaxConnectionsPerHost(hostDistance)) return false;
if (open.compareAndSet(opened, opened + 1)) break;
}
if (isShutdown()) {
open.decrementAndGet();
return false;
}
// Now really open the connection
try {
connections.add(manager.connectionFactory().open(host));
signalAvailableConnection();
return true;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
// Skip the open but ignore otherwise
open.decrementAndGet();
return false;
} catch (ConnectionException e) {
open.decrementAndGet();
logger.debug("Connection error to {} while creating additional connection", host);
if (host.getMonitor().signalConnectionFailure(e)) shutdown();
return false;
} catch (AuthenticationException e) {
// This shouldn't really happen in theory
open.decrementAndGet();
logger.error(
"Authentication error while creating additional connection (error is: {})",
e.getMessage());
shutdown();
return false;
}
}
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;
}
}
}
public void returnConnection(Connection connection) {
int inFlight = connection.inFlight.decrementAndGet();
if (connection.isDefunct()) {
if (host.getMonitor().signalConnectionFailure(connection.lastException())) shutdown();
else replace(connection);
} else {
if (trash.contains(connection) && inFlight == 0) {
if (trash.remove(connection)) close(connection);
return;
}
if (connections.size() > options().getCoreConnectionsPerHost(hostDistance)
&& inFlight <= options().getMinSimultaneousRequestsPerConnectionThreshold(hostDistance)) {
trashConnection(connection);
} else {
signalAvailableConnection();
}
}
}
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();
}
