private boolean trashConnection(Connection connection) { if (!connection.state.compareAndSet(OPEN, TRASHED)) return true; // First, make sure we don't go below core connections for (; ; ) { int opened = open.get(); if (opened <= options().getCoreConnectionsPerHost(hostDistance)) { connection.state.set(OPEN); return false; } if (open.compareAndSet(opened, opened - 1)) break; } logger.trace("Trashing {}", connection); connection.maxIdleTime = System.currentTimeMillis() + options().getIdleTimeoutSeconds() * 1000; doTrashConnection(connection); return true; }
void ensureCoreConnections() { if (isClosed()) return; if (!host.convictionPolicy.canReconnectNow()) 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.blockingExecutor().submit(newConnectionTask); } }
/** If we have more active connections than needed, trash some of them */ private void shrinkIfBelowCapacity() { int currentLoad = maxTotalInFlight.getAndSet(totalInFlight.get()); int maxRequestsPerConnection = options().getMaxRequestsPerConnection(hostDistance); int needed = currentLoad / maxRequestsPerConnection + 1; if (currentLoad % maxRequestsPerConnection > options().getNewConnectionThreshold(hostDistance)) needed += 1; needed = Math.max(needed, options().getCoreConnectionsPerHost(hostDistance)); int actual = open.get(); int toTrash = Math.max(0, actual - needed); logger.trace( "Current inFlight = {}, {} connections needed, {} connections available, trashing {}", currentLoad, needed, actual, toTrash); if (toTrash <= 0) return; for (Connection connection : connections) if (trashConnection(connection)) { toTrash -= 1; if (toTrash == 0) return; } }
@Test(groups = "unit") public void should_leave_connection_options_unset_until_protocol_version_known() { PoolingOptions options = new PoolingOptions(); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getCoreConnectionsPerHost(REMOTE)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getMaxConnectionsPerHost(REMOTE)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getNewConnectionThreshold(LOCAL)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getNewConnectionThreshold(REMOTE)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getMaxRequestsPerConnection(LOCAL)).isEqualTo(PoolingOptions.UNSET); assertThat(options.getMaxRequestsPerConnection(REMOTE)).isEqualTo(PoolingOptions.UNSET); }
@Test(groups = "unit") public void should_initialize_to_v2_defaults_if_v2_or_below() { PoolingOptions options = new PoolingOptions(); options.setProtocolVersion(ProtocolVersion.V1); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(2); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(8); assertThat(options.getCoreConnectionsPerHost(REMOTE)).isEqualTo(1); assertThat(options.getMaxConnectionsPerHost(REMOTE)).isEqualTo(2); assertThat(options.getNewConnectionThreshold(LOCAL)).isEqualTo(100); assertThat(options.getNewConnectionThreshold(REMOTE)).isEqualTo(100); assertThat(options.getMaxRequestsPerConnection(LOCAL)).isEqualTo(128); assertThat(options.getMaxRequestsPerConnection(REMOTE)).isEqualTo(128); }
@Test(groups = "unit") public void should_initialize_to_v3_defaults_if_v3_or_above() { PoolingOptions options = new PoolingOptions(); options.setProtocolVersion(ProtocolVersion.V3); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(1); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(1); assertThat(options.getCoreConnectionsPerHost(REMOTE)).isEqualTo(1); assertThat(options.getMaxConnectionsPerHost(REMOTE)).isEqualTo(1); assertThat(options.getNewConnectionThreshold(LOCAL)).isEqualTo(800); assertThat(options.getNewConnectionThreshold(REMOTE)).isEqualTo(200); assertThat(options.getMaxRequestsPerConnection(LOCAL)).isEqualTo(1024); assertThat(options.getMaxRequestsPerConnection(REMOTE)).isEqualTo(256); }
@Test(groups = "unit") public void should_set_core_and_max_connections_simultaneously() { PoolingOptions options = new PoolingOptions(); options.setProtocolVersion(ProtocolVersion.V2); options.setConnectionsPerHost(LOCAL, 10, 15); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(10); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(15); }
public static int numberOfLocalCoreConnections(Cluster cluster) { Configuration configuration = cluster.getConfiguration(); return configuration.getPoolingOptions().getCoreConnectionsPerHost(HostDistance.LOCAL); }
final int coreSize = options().getCoreConnectionsPerHost(hostDistance); final List<Connection> connections = Lists.newArrayListWithCapacity(coreSize); final List<ListenableFuture<Void>> connectionFutures = Lists.newArrayListWithCapacity(coreSize);
int coreSize = options().getCoreConnectionsPerHost(hostDistance); if (coreSize == 0) { maybeSpawnNewConnection(); if (connectionCount < options().getCoreConnectionsPerHost(hostDistance)) { maybeSpawnNewConnection(); } else if (connectionCount < options().getMaxConnectionsPerHost(hostDistance)) {
Assert.assertEquals(configuration.getSocketOptions().getTcpNoDelay().booleanValue(), true); Assert.assertEquals(configuration.getPoolingOptions().getCoreConnectionsPerHost(distance), 5); Assert.assertEquals(configuration.getPoolingOptions().getMaxConnectionsPerHost(distance), 12); Assert.assertEquals(configuration.getPoolingOptions()
Assert.assertEquals(configuration.getSocketOptions().getTcpNoDelay().booleanValue(), true); Assert.assertEquals(configuration.getPoolingOptions().getCoreConnectionsPerHost(distance), 5); Assert.assertEquals(configuration.getPoolingOptions().getMaxConnectionsPerHost(distance), 12); Assert.assertEquals(configuration.getPoolingOptions()
Assert.assertEquals(configuration.getSocketOptions().getTcpNoDelay().booleanValue(), true); Assert.assertEquals(configuration.getPoolingOptions().getCoreConnectionsPerHost(distance), 5); Assert.assertEquals(configuration.getPoolingOptions().getMaxConnectionsPerHost(distance), 12); Assert.assertEquals(configuration.getPoolingOptions()
Assert.assertEquals(configuration.getSocketOptions().getTcpNoDelay().booleanValue(), true); Assert.assertEquals(configuration.getPoolingOptions().getCoreConnectionsPerHost(distance), 5); Assert.assertEquals(configuration.getPoolingOptions().getMaxConnectionsPerHost(distance), 12); Assert.assertEquals(configuration.getPoolingOptions()
Assert.assertEquals(configuration.getSocketOptions().getTcpNoDelay().booleanValue(), true); Assert.assertEquals(configuration.getPoolingOptions().getCoreConnectionsPerHost(distance), 5); Assert.assertEquals(configuration.getPoolingOptions().getMaxConnectionsPerHost(distance), 12); Assert.assertEquals(configuration.getPoolingOptions()
@Test(groups = "unit") public void should_enforce_invariants_once_protocol_version_known() { // OK for v2 (default max = 8) PoolingOptions options = new PoolingOptions().setCoreConnectionsPerHost(LOCAL, 3); options.setCoreConnectionsPerHost(LOCAL, 3); options.setProtocolVersion(ProtocolVersion.V2); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(3); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(8); // KO for v3 (default max = 1) options = new PoolingOptions().setCoreConnectionsPerHost(LOCAL, 3); try { options.setProtocolVersion(ProtocolVersion.V3); fail("Expected an IllegalArgumentException"); } catch (IllegalArgumentException e) { /*expected*/ } // OK for v3 (up to 32K stream ids) options = new PoolingOptions().setMaxRequestsPerConnection(LOCAL, 5000); options.setProtocolVersion(ProtocolVersion.V3); assertThat(options.getMaxRequestsPerConnection(LOCAL)).isEqualTo(5000); // KO for v2 (up to 128) options = new PoolingOptions().setMaxRequestsPerConnection(LOCAL, 5000); try { options.setProtocolVersion(ProtocolVersion.V2); fail("Expected an IllegalArgumentException"); } catch (IllegalArgumentException e) { /*expected*/ } }
private boolean trashConnection(PooledConnection connection) { // First, make sure we don't go below core connections for(;;) { int opened = open.get(); if (opened <= options().getCoreConnectionsPerHost(hostDistance)) return false; if (open.compareAndSet(opened, opened - 1)) break; } doTrashConnection(connection); return true; }
public RxSessionImpl(Session session) { this.session = session; this.loadBalancingPolicy = session.getCluster().getConfiguration().getPolicies().getLoadBalancingPolicy(); PoolingOptions poolingOptions = session.getCluster().getConfiguration().getPoolingOptions(); maxInFlightLocal = poolingOptions.getCoreConnectionsPerHost(HostDistance.LOCAL) * poolingOptions.getMaxRequestsPerConnection(HostDistance.LOCAL); maxInFlightRemote = poolingOptions.getCoreConnectionsPerHost(HostDistance.REMOTE) * poolingOptions.getMaxRequestsPerConnection(HostDistance.REMOTE); }
@Test(groups = "unit") public void should_set_core_and_max_connections_simultaneously() { PoolingOptions options = new PoolingOptions(); options.setProtocolVersion(ProtocolVersion.V2); options.setConnectionsPerHost(LOCAL, 10, 15); assertThat(options.getCoreConnectionsPerHost(LOCAL)).isEqualTo(10); assertThat(options.getMaxConnectionsPerHost(LOCAL)).isEqualTo(15); }
public RxSessionImpl(Session session) { this.session = session; this.loadBalancingPolicy = session.getCluster().getConfiguration().getPolicies().getLoadBalancingPolicy(); PoolingOptions poolingOptions = session.getCluster().getConfiguration().getPoolingOptions(); maxInFlightLocal = poolingOptions.getCoreConnectionsPerHost(HostDistance.LOCAL) * poolingOptions.getMaxRequestsPerConnection(HostDistance.LOCAL); maxInFlightRemote = poolingOptions.getCoreConnectionsPerHost(HostDistance.REMOTE) * poolingOptions.getMaxRequestsPerConnection(HostDistance.REMOTE); }