private HostConnectionPool addHost(Host host) { try { HostDistance distance = loadBalancer.distance(host); if (distance == HostDistance.IGNORED) { return pools.get(host); } else { logger.debug("Adding {} to list of queried hosts", host); return pools.put(host, new HostConnectionPool(host, distance, this)); } } catch (AuthenticationException e) { logger.error("Error creating pool to {} ({})", host, e.getMessage()); host.getMonitor() .signalConnectionFailure(new ConnectionException(e.getHost(), e.getMessage())); return pools.get(host); } catch (ConnectionException e) { logger.debug("Error creating pool to {} ({})", host, e.getMessage()); host.getMonitor().signalConnectionFailure(e); return pools.get(host); } }
/* * 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; } } }
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 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; } }