public HostConnectionPool(Host host, HostDistance hostDistance, Session.Manager manager)
throws ConnectionException {
assert hostDistance != HostDistance.IGNORED;
this.host = host;
this.hostDistance = hostDistance;
this.manager = manager;
this.newConnectionTask =
new Runnable() {
@Override
public void run() {
addConnectionIfUnderMaximum();
scheduledForCreation.decrementAndGet();
}
};
// Create initial core connections
List<Connection> l =
new ArrayList<Connection>(options().getCoreConnectionsPerHost(hostDistance));
try {
for (int i = 0; i < options().getCoreConnectionsPerHost(hostDistance); i++)
l.add(manager.connectionFactory().open(host));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
// If asked to interrupt, we can skip opening core connections, the pool will still work.
// But we ignore otherwise cause I'm not sure we can do much better currently.
}
this.connections = new CopyOnWriteArrayList<Connection>(l);
this.open = new AtomicInteger(connections.size());
logger.trace("Created connection pool to host {}", host);
}
private void maybeSpawnNewConnection() {
while (true) {
int inCreation = scheduledForCreation.get();
if (inCreation >= MAX_SIMULTANEOUS_CREATION) return;
if (scheduledForCreation.compareAndSet(inCreation, inCreation + 1)) break;
}
logger.debug("Creating new connection on busy pool to {}", host);
manager.executor().submit(newConnectionTask);
}
private void close(final Connection connection) {
manager
.executor()
.submit(
new Runnable() {
@Override
public void run() {
connection.close();
}
});
}
private void replace(final Connection connection) {
connections.remove(connection);
manager
.executor()
.submit(
new Runnable() {
@Override
public void run() {
connection.close();
addConnectionIfUnderMaximum();
}
});
}
// This creates connections if we have less than core connections (if we
// have more than core, connection will just get trash when we can).
public void ensureCoreConnections() {
if (isShutdown()) return;
// Note: this process is a bit racy, but it doesn't matter since we're still guaranteed to not
// create
// more connection than maximum (and if we create more than core connection due to a race but
// this isn't
// justified by the load, the connection in excess will be quickly trashed anyway)
int opened = open.get();
for (int i = opened; i < options().getCoreConnectionsPerHost(hostDistance); i++) {
// We don't respect MAX_SIMULTANEOUS_CREATION here because it's only to
// protect against creating connection in excess of core too quickly
scheduledForCreation.incrementAndGet();
manager.executor().submit(newConnectionTask);
}
}
public Connection borrowConnection(long timeout, TimeUnit unit)
throws ConnectionException, TimeoutException {
if (isShutdown.get())
// Note: throwing a ConnectionException is probably fine in practice as it will trigger the
// creation of a new host.
// That being said, maybe having a specific exception could be cleaner.
throw new ConnectionException(host.getAddress(), "Pool is shutdown");
if (connections.isEmpty()) {
for (int i = 0; i < options().getCoreConnectionsPerHost(hostDistance); i++) {
// We don't respect MAX_SIMULTANEOUS_CREATION here because it's only to
// protect against creating connection in excess of core too quickly
scheduledForCreation.incrementAndGet();
manager.executor().submit(newConnectionTask);
}
Connection c = waitForConnection(timeout, unit);
c.setKeyspace(manager.poolsState.keyspace);
return c;
}
int minInFlight = Integer.MAX_VALUE;
Connection leastBusy = null;
for (Connection connection : connections) {
int inFlight = connection.inFlight.get();
if (inFlight < minInFlight) {
minInFlight = inFlight;
leastBusy = connection;
}
}
if (minInFlight >= options().getMaxSimultaneousRequestsPerConnectionThreshold(hostDistance)
&& connections.size() < options().getMaxConnectionsPerHost(hostDistance))
maybeSpawnNewConnection();
while (true) {
int inFlight = leastBusy.inFlight.get();
if (inFlight >= Connection.MAX_STREAM_PER_CONNECTION) {
leastBusy = waitForConnection(timeout, unit);
break;
}
if (leastBusy.inFlight.compareAndSet(inFlight, inFlight + 1)) break;
}
leastBusy.setKeyspace(manager.poolsState.keyspace);
return leastBusy;
}
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;
}
}
private PoolingOptions options() {
return manager.configuration().getPoolingOptions();
}