clusterBuilder.withLoadBalancingPolicy(loadPolicy);
.setMaxQueueSize(m_clusterConfiguration.getMaxQueueSize())) .withReconnectionPolicy(new ExponentialReconnectionPolicy(100, 5 * 1000)) .withLoadBalancingPolicy(new SelectiveLoadBalancingPolicy(readLoadBalancePolicy, m_writeLoadBalancingPolicy)) .withCompression(ProtocolOptions.Compression.LZ4) .withoutJMXReporting()
.withMaxSchemaAgreementWaitSeconds(45) .withCompression(ProtocolOptions.Compression.LZ4) .withLoadBalancingPolicy(loadBalancingPolicy) .withPoolingOptions(poolingOptions) .withQueryOptions(queryOptions)
.addContactPointsWithPorts(sCluster.address(3)) .withPort(sCluster.getBinaryPort()) .withLoadBalancingPolicy(new WhiteListPolicy(new RoundRobinPolicy(), whiteList)) .withNettyOptions(nonQuietClusterCloseOptions) .build();
.withPort(ccm().getBinaryPort()) .withReconnectionPolicy(reconnectionPolicy) .withLoadBalancingPolicy(loadBalancingPolicy) .build()); cluster.init();
.addContactPoints(sCluster.address(1).getAddress()) .withPort(sCluster.getBinaryPort()) .withLoadBalancingPolicy(new RoundRobinPolicy()) .withNettyOptions(nonQuietClusterCloseOptions) .build();
@BeforeMethod(groups = "short") public void beforeMethod() { scassandras = ScassandraCluster.builder().withNodes(3).build(); scassandras.init(); cluster = Cluster.builder() .addContactPoints(scassandras.address(1).getAddress()) .withPort(scassandras.getBinaryPort()) .withRetryPolicy(retryPolicy) .withLoadBalancingPolicy(new SortingLoadBalancingPolicy()) .withPoolingOptions( new PoolingOptions() .setCoreConnectionsPerHost(HostDistance.LOCAL, 1) .setMaxConnectionsPerHost(HostDistance.LOCAL, 1) .setHeartbeatIntervalSeconds(0)) .withNettyOptions(nonQuietClusterCloseOptions) // Mark everything as idempotent by default so RetryPolicy is exercised. .withQueryOptions(new QueryOptions().setDefaultIdempotence(true)) .build(); session = cluster.connect(); host1 = TestUtils.findHost(cluster, 1); host2 = TestUtils.findHost(cluster, 2); host3 = TestUtils.findHost(cluster, 3); errors = cluster.getMetrics().getErrorMetrics(); Mockito.reset(retryPolicy); for (Scassandra node : scassandras.nodes()) { node.activityClient().clearAllRecordedActivity(); } }
/** * Ensures that when a cluster is initialized that {@link LoadBalancingPolicy#init(Cluster, * Collection)} is called with each reachable contact point. * * @test_category load_balancing:notification * @expected_result init() is called for each of two contact points. */ @Test(groups = "short") public void should_init_policy_with_up_contact_points() throws Exception { HistoryPolicy policy = new HistoryPolicy(new RoundRobinPolicy()); Cluster cluster = register( Cluster.builder() .addContactPoints(getContactPoints()) .withPort(ccm().getBinaryPort()) .withLoadBalancingPolicy(policy) .build()); try { cluster.init(); assertThat(policy.history) .containsOnly( entry(INIT, TestUtils.findHost(cluster, 1)), entry(INIT, TestUtils.findHost(cluster, 2))); } finally { cluster.close(); } }
@BeforeMethod(groups = "short") public void beforeMethod() { scassandra = ScassandraCluster.builder().withNodes(3).build(); scassandra.init(); queryOptions = new QueryOptions(); loadBalancingPolicy = new SortingLoadBalancingPolicy(); cluster = Cluster.builder() .addContactPoints(scassandra.address(2).getAddress()) .withPort(scassandra.getBinaryPort()) .withLoadBalancingPolicy(loadBalancingPolicy) .withQueryOptions(queryOptions) .withNettyOptions(nonQuietClusterCloseOptions) .build(); session = cluster.connect(); host1 = TestUtils.findHost(cluster, 1); host2 = TestUtils.findHost(cluster, 2); host3 = TestUtils.findHost(cluster, 3); // Make sure there are no prepares for (int host : Lists.newArrayList(1, 2, 3)) { assertThat(scassandra.node(host).activityClient().retrievePreparedStatementPreparations()) .hasSize(0); scassandra.node(host).activityClient().clearAllRecordedActivity(); } }
@BeforeMethod(groups = "short") public void beforeMethod() { scassandras = ScassandraCluster.builder().withNodes(3).build(); scassandras.init(); int speculativeExecutionDelay = 200; loadBalancingPolicy = new SortingLoadBalancingPolicy(); cluster = Cluster.builder() .addContactPoints(scassandras.address(2).getAddress()) .withPort(scassandras.getBinaryPort()) .withLoadBalancingPolicy(loadBalancingPolicy) .withSpeculativeExecutionPolicy( new ConstantSpeculativeExecutionPolicy(speculativeExecutionDelay, 1)) .withQueryOptions(new QueryOptions().setDefaultIdempotence(true)) .withRetryPolicy(new CustomRetryPolicy()) .withNettyOptions(nonQuietClusterCloseOptions) .build(); session = cluster.connect(); host1 = TestUtils.findHost(cluster, 1); host2 = TestUtils.findHost(cluster, 2); host3 = TestUtils.findHost(cluster, 3); errors = cluster.getMetrics().getErrorMetrics(); }
private void deleteNode2RpcAddressFromNode1() throws Exception { InetSocketAddress firstHost = ccm().addressOfNode(1); Cluster cluster = register( Cluster.builder() .addContactPoints(firstHost.getAddress()) .withPort(ccm().getBinaryPort()) // ensure we will only connect to node1 .withLoadBalancingPolicy( new WhiteListPolicy( Policies.defaultLoadBalancingPolicy(), Lists.newArrayList(firstHost))) .build()); Session session = cluster.connect(); String deleteStmt = String.format( "DELETE rpc_address FROM system.peers WHERE peer = '%s'", ccm().addressOfNode(2).getHostName()); session.execute(deleteStmt); session.close(); cluster.close(); } }
@BeforeMethod(groups = "short") public void setUp() { sCluster = ScassandraCluster.builder().withNodes(4).build(); sCluster.init(); cluster = Cluster.builder() .addContactPoints(sCluster.address(1).getAddress()) .withPort(sCluster.getBinaryPort()) .withLoadBalancingPolicy(lbSpy) .withNettyOptions(nonQuietClusterCloseOptions) .build(); session = cluster.connect(); // Reset invocations before entering test. Mockito.reset(lbSpy); }
/** * @return a {@link Cluster} instance that connects only to the control host of the given cluster. */ public static Cluster buildControlCluster(Cluster cluster, CCMAccess ccm) { Host controlHost = cluster.manager.controlConnection.connectedHost(); List<InetSocketAddress> singleAddress = Collections.singletonList(controlHost.getSocketAddress()); return Cluster.builder() .addContactPoints(controlHost.getSocketAddress().getAddress()) .withPort(ccm.getBinaryPort()) .withLoadBalancingPolicy(new WhiteListPolicy(new RoundRobinPolicy(), singleAddress)) .build(); }
@Override public Cluster.Builder createClusterBuilder() { return Cluster.builder() .withLoadBalancingPolicy(loadBalancingPolicy) .withSpeculativeExecutionPolicy(speculativeExecutionPolicy) .withRetryPolicy(retryPolicy); }
@SuppressWarnings("unused") private Cluster.Builder updatablePolicy() { policy = new UpdatablePolicy(); return Cluster.builder().withLoadBalancingPolicy(policy); } }
@Override public Cluster.Builder createClusterBuilder() { // Only connect to node 1, which makes it easier to query system tables in // should_expose_tokens_per_host() LoadBalancingPolicy lbp = new WhiteListPolicy(new RoundRobinPolicy(), Collections.singleton(ccm().addressOfNode(1))); return Cluster.builder() .addContactPoints(getContactPoints().get(0)) .withPort(ccm().getBinaryPort()) .withLoadBalancingPolicy(lbp); }
private Cluster.Builder builder(LoadBalancingPolicy lbp) { return Cluster.builder() .withNettyOptions(nonQuietClusterCloseOptions) .addContactPoints(sCluster.address(1).getAddress()) .withPort(sCluster.getBinaryPort()) .withLoadBalancingPolicy(lbp); }
@Override public Cluster.Builder createClusterBuilder() { policy = new CloseMonitoringPolicy(Policies.defaultLoadBalancingPolicy()); return Cluster.builder() .addContactPoints(getContactPoints().get(0)) .withLoadBalancingPolicy(policy); }
builder = builder.withLoadBalancingPolicy(loadBalancingPlc);
cassandraConf.getReconnectionPolicyBaseMs(), cassandraConf.getReconnectionPolicyMaxMs())) .withLoadBalancingPolicy(cassandraConf.getLoadBalancingPolicy()); cluster.getConfiguration().getSocketOptions().setReadTimeoutMillis((int) cassandraConf.getSocketReadTimeoutMillis()); cluster.getConfiguration().getSocketOptions().setConnectTimeoutMillis((int) cassandraConf.getSocketConnectTimeoutMillis());