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(); }