private ISession GetSession( ISpeculativeExecutionPolicy speculativeExecutionPolicy = null, bool warmup = true, ILoadBalancingPolicy lbp = null, PoolingOptions pooling = null) { if (_testCluster == null) { throw new Exception("Test cluster not initialized"); } var builder = Cluster.Builder() .AddContactPoint(_testCluster.InitialContactPoint) .WithSpeculativeExecutionPolicy(speculativeExecutionPolicy) .WithLoadBalancingPolicy(lbp ?? Cassandra.Policies.DefaultLoadBalancingPolicy) .WithRetryPolicy(DowngradingConsistencyRetryPolicy.Instance) .WithSocketOptions(new SocketOptions().SetReadTimeoutMillis(0)); if (pooling != null) { builder.WithPoolingOptions(pooling); } var cluster = builder.Build(); _clusters.Add(cluster); var session = cluster.Connect(); if (warmup) { TestHelper.ParallelInvoke(() => session.Execute(QueryLocal), 10); } _addressNode1 = IPAddress.Parse(_testCluster.ClusterIpPrefix + "1"); return session; }
internal Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthInfoProvider authProvider) { this._policies = policies; this._protocolOptions = protocolOptions; this._poolingOptions = poolingOptions; this._socketOptions = socketOptions; this._clientOptions = clientOptions; this._authProvider = authProvider; }
public Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthInfoProvider authProvider, bool metricsEnabled) { this._policies = policies; this._protocolOptions = protocolOptions; this._poolingOptions = poolingOptions; this._socketOptions = socketOptions; this._clientOptions = clientOptions; this._authProvider = authProvider; this._metricsEnabled = metricsEnabled; }
private static Configuration GetConfig(int coreConnections = 3, int maxConnections = 8) { var pooling = new PoolingOptions() .SetCoreConnectionsPerHost(HostDistance.Local, coreConnections) .SetMaxConnectionsPerHost(HostDistance.Local, maxConnections); var config = new Configuration(Policies.DefaultPolicies, new ProtocolOptions(), pooling, new SocketOptions(), new ClientOptions(), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator()); config.BufferPool = new Microsoft.IO.RecyclableMemoryStreamManager(); return config; }
internal Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthProvider authProvider, IAuthInfoProvider authInfoProvider, QueryOptions queryOptions) { _policies = policies; _protocolOptions = protocolOptions; _poolingOptions = poolingOptions; _socketOptions = socketOptions; _clientOptions = clientOptions; _authProvider = authProvider; _authInfoProvider = authInfoProvider; _queryOptions = queryOptions; }
public void SpeculativeExecution_Pause_Using_All_Stream_Ids() { var maxProtocolVersion = Cluster.MaxProtocolVersion; _testCluster = TestClusterManager.GetNonShareableTestCluster(2, 1, true, false); Cluster.MaxProtocolVersion = 2; try { var pooling = new PoolingOptions().SetCoreConnectionsPerHost(HostDistance.Local, 1); var session = GetSession(new ConstantSpeculativeExecutionPolicy(50L, 1), true, null, pooling); const int pauseThreshold = 140 * 2; var tasks = new List<Task<IPAddress>>(); var semaphore = new SemaphoreSlim(150 * 2); for (var i = 0; i < 512; i++) { //Pause after the stream ids are in use for the connections if (i == pauseThreshold) { _testCluster.PauseNode(1); } semaphore.Wait(); tasks.Add(session .ExecuteAsync(new SimpleStatement(QueryLocal).SetIdempotence(true)) .Continue(t => { semaphore.Release(); return t.Result.Info.QueriedHost.Address; })); } Task.WaitAll(tasks.Select(t => (Task)t).ToArray()); _testCluster.ResumeNode(1); //There shouldn't be any query using node1 as coordinator passed the threshold. Assert.AreEqual(0, tasks.Skip(pauseThreshold).Count(t => t.Result.Equals(_addressNode1))); Thread.Sleep(1000); } finally { Cluster.MaxProtocolVersion = maxProtocolVersion; } }
private static Configuration GetConfig(QueryOptions queryOptions = null, Cassandra.Policies policies = null, PoolingOptions poolingOptions = null) { return(new TestConfigurationBuilder { Policies = policies ?? new Cassandra.Policies(), PoolingOptions = poolingOptions, QueryOptions = queryOptions ?? DefaultQueryOptions }.Build()); }
/// <summary> /// Gets the pooling options. If not specified, gets the default by protocol version /// </summary> internal PoolingOptions GetPoolingOptions(byte protocolVersion) { if (this._poolingOptions != null) { return this._poolingOptions; } this._poolingOptions = PoolingOptions.GetDefault(protocolVersion); return this._poolingOptions; }
public void GetRequest_Batch_With_Empty_Timestamp_Generator() { var batch = new BatchStatement(); batch.Add(new SimpleStatement("QUERY")); var policies = new Cassandra.Policies( Cassandra.Policies.DefaultLoadBalancingPolicy, Cassandra.Policies.DefaultReconnectionPolicy, Cassandra.Policies.DefaultRetryPolicy, Cassandra.Policies.DefaultSpeculativeExecutionPolicy, new NoTimestampGenerator()); var config = RequestHandlerTests.GetConfig(new QueryOptions(), policies, PoolingOptions.Create()); var request = RequestHandler.GetRequest(batch, Serializer, config.DefaultRequestOptions); var bodyBuffer = GetBodyBuffer(request); // The batch request is composed by: // <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>] var offset = 1 + 2 + 1; var queryLength = BeConverter.ToInt32(bodyBuffer, offset); Assert.AreEqual(5, queryLength); // skip query, n_params and consistency offset += 4 + queryLength + 2 + 2; var flags = GetQueryFlags(bodyBuffer, ref offset); Assert.False(flags.HasFlag(QueryFlags.WithDefaultTimestamp)); // Only serial consistency left Assert.AreEqual(bodyBuffer.Length, offset + 2); }
public void GetRequest_Batch_With_Provided_Timestamp() { var batch = new BatchStatement(); batch.Add(new SimpleStatement("QUERY")); var providedTimestamp = DateTimeOffset.Now; // To microsecond precision providedTimestamp = providedTimestamp.Subtract(TimeSpan.FromTicks(providedTimestamp.Ticks % 10)); batch.SetTimestamp(providedTimestamp); var config = RequestHandlerTests.GetConfig(new QueryOptions(), Cassandra.Policies.DefaultPolicies, PoolingOptions.Create()); var request = RequestHandler.GetRequest(batch, Serializer, config.DefaultRequestOptions); var bodyBuffer = GetBodyBuffer(request); // The batch request is composed by: // <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>] var offset = 1 + 2 + 1; var queryLength = BeConverter.ToInt32(bodyBuffer, offset); Assert.AreEqual(5, queryLength); // skip query, n_params and consistency offset += 4 + queryLength + 2 + 2; var flags = GetQueryFlags(bodyBuffer, ref offset); Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp)); // Skip serial consistency offset += 2; var timestamp = TypeSerializer.UnixStart.AddTicks(BeConverter.ToInt64(bodyBuffer, offset) * 10); Assert.AreEqual(providedTimestamp, timestamp); }
private Connection CreateConnection(ProtocolOptions protocolOptions = null, SocketOptions socketOptions = null, PoolingOptions poolingOptions = null) { if (socketOptions == null) { socketOptions = new SocketOptions(); } if (protocolOptions == null) { protocolOptions = new ProtocolOptions(); } var config = new Configuration( new Cassandra.Policies(), protocolOptions, poolingOptions, socketOptions, new ClientOptions(false, 20000, null), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator(), new StartupOptionsFactory(), new SessionFactoryBuilder(), new Dictionary <string, IExecutionProfile>(), new RequestOptionsMapper(), null); return(CreateConnection(GetProtocolVersion(), config)); }
public void GetRequest_Batch_With_Timestamp_Generator() { var batch = new BatchStatement(); batch.Add(new SimpleStatement("QUERY")); var startDate = DateTimeOffset.Now; // To microsecond precision startDate = startDate.Subtract(TimeSpan.FromTicks(startDate.Ticks % 10)); var config = RequestHandlerTests.GetConfig(new QueryOptions(), Cassandra.Policies.DefaultPolicies, PoolingOptions.Create()); var request = RequestHandler.GetRequest(batch, Serializer, config.DefaultRequestOptions); var bodyBuffer = GetBodyBuffer(request); // The batch request is composed by: // <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>] var offset = 1; // n = 1 Assert.AreEqual(1, BeConverter.ToInt16(bodyBuffer, offset)); // Query_1 <kind><string><n_params> offset += 2; // kind = 0, not prepared Assert.AreEqual(0, bodyBuffer[offset++]); var queryLength = BeConverter.ToInt32(bodyBuffer, offset); Assert.AreEqual(5, queryLength); // skip query, n_params and consistency offset += 4 + queryLength + 2 + 2; var flags = GetQueryFlags(bodyBuffer, ref offset); Assert.True(flags.HasFlag(QueryFlags.WithDefaultTimestamp)); // Skip serial consistency offset += 2; var timestamp = TypeSerializer.UnixStart.AddTicks(BeConverter.ToInt64(bodyBuffer, offset) * 10); Assert.GreaterOrEqual(timestamp, startDate); Assert.LessOrEqual(timestamp, DateTimeOffset.Now.Add(TimeSpan.FromMilliseconds(100))); }
internal FakeObjectPool(PoolManager poolManager, PoolingOptions <T> options) : base(poolManager, new PoolingOptions <T>(options.Instantiator, 0, 0)) { }
private Connection CreateConnection(ProtocolOptions protocolOptions = null, SocketOptions socketOptions = null, PoolingOptions poolingOptions = null) { if (socketOptions == null) { socketOptions = new SocketOptions(); } if (protocolOptions == null) { protocolOptions = new ProtocolOptions(); } var config = new Configuration( new Dse.Policies(), protocolOptions, poolingOptions, socketOptions, new ClientOptions(false, 20000, null), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator()); return(CreateConnection(GetLatestProtocolVersion(), config)); }
internal FakeSimpleObjectPool(PoolManager poolManager, PoolingOptions <T> options) : base(poolManager, 0, options.Instantiator) { }
private Connection CreateConnection(ProtocolOptions protocolOptions = null, SocketOptions socketOptions = null, PoolingOptions poolingOptions = null) { if (socketOptions == null) { socketOptions = new SocketOptions(); } if (protocolOptions == null) { protocolOptions = new ProtocolOptions(); } var config = new Configuration( new Cassandra.Policies(), protocolOptions, poolingOptions, socketOptions, new ClientOptions(false, 20000, null), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator()); config.BufferPool = new RecyclableMemoryStreamManager(); config.Timer = new HashedWheelTimer(); return(CreateConnection(GetLatestProtocolVersion(), config)); }
public async Task Should_Throw_NoHostAvailableException_When_All_Host_Are_Busy() { const int connectionLength = 2; const int maxRequestsPerConnection = 50; var lbp = new TestHelper.OrderedLoadBalancingPolicy().UseRoundRobin(); var builder = Cluster.Builder() .WithPoolingOptions( PoolingOptions.Create() .SetCoreConnectionsPerHost(HostDistance.Local, connectionLength) .SetMaxConnectionsPerHost(HostDistance.Local, connectionLength) .SetHeartBeatInterval(0) .SetMaxRequestsPerConnection(maxRequestsPerConnection)) .WithSocketOptions(new SocketOptions().SetReadTimeoutMillis(0)) .WithLoadBalancingPolicy(lbp); using (var testCluster = SimulacronCluster.CreateNew(new SimulacronOptions { Nodes = "3" })) using (var cluster = builder.AddContactPoint(testCluster.InitialContactPoint).Build()) { const string query = "SELECT * FROM simulated_ks.table1"; testCluster.Prime(new { when = new { query }, then = new { result = "success", delay_in_ms = 3000 } }); var session = await cluster.ConnectAsync().ConfigureAwait(false); var hosts = cluster.AllHosts().ToArray(); await TestHelper.TimesLimit(() => session.ExecuteAsync(new SimpleStatement("SELECT key FROM system.local")), 100, 16).ConfigureAwait(false); // Wait until all connections to all host are created await TestHelper.WaitUntilAsync(() => { var state = session.GetState(); return(state.GetConnectedHosts().All(h => state.GetInFlightQueries(h) == connectionLength)); }).ConfigureAwait(false); lbp.UseFixedOrder(); const int busyExceptions = 10; var length = maxRequestsPerConnection * connectionLength * hosts.Length + Environment.ProcessorCount + busyExceptions; var tasks = new List <Task <Exception> >(length); for (var i = 0; i < length; i++) { tasks.Add(TestHelper.EatUpException(session.ExecuteAsync(new SimpleStatement(query)))); } var results = await Task.WhenAll(tasks).ConfigureAwait(false); // Only successful responses or NoHostAvailableException expected Assert.Null(results.FirstOrDefault(e => e != null && !(e is NoHostAvailableException))); // At least the first n (maxRequestsPerConnection * connectionLength * hosts.length) succeeded Assert.That(results.Count(e => e == null), Is.GreaterThanOrEqualTo(maxRequestsPerConnection * connectionLength * hosts.Length)); // At least the following m (busyExceptions) failed var failed = results.Where(e => e is NoHostAvailableException).Cast <NoHostAvailableException>() .ToArray(); Assert.That(failed, Has.Length.GreaterThanOrEqualTo(busyExceptions)); foreach (var ex in failed) { Assert.That(ex.Errors, Has.Count.EqualTo(hosts.Length)); foreach (var kv in ex.Errors) { Assert.IsInstanceOf <BusyPoolException>(kv.Value); var busyException = (BusyPoolException)kv.Value; Assert.AreEqual(kv.Key, busyException.Address); Assert.That(busyException.ConnectionLength, Is.EqualTo(connectionLength)); Assert.That(busyException.MaxRequestsPerConnection, Is.EqualTo(maxRequestsPerConnection)); Assert.That(busyException.Message, Is.EqualTo( $"All connections to host {busyException.Address} are busy, {maxRequestsPerConnection}" + $" requests are in-flight on each {connectionLength} connection(s)")); } } } }
public void GetRequest_Batch_With_64K_Queries() { var batch = new BatchStatement(); for (var i = 0; i < ushort.MaxValue; i++) { batch.Add(new SimpleStatement("QUERY")); } var config = RequestHandlerTests.GetConfig(new QueryOptions(), Cassandra.Policies.DefaultPolicies, PoolingOptions.Create()); var request = RequestHandler.GetRequest(batch, Serializer, config.DefaultRequestOptions); var bodyBuffer = GetBodyBuffer(request); // The batch request is composed by: // <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>] CollectionAssert.AreEqual(new byte[] { 0xff, 0xff }, bodyBuffer.Skip(1).Take(2)); }
private Connection CreateConnection(ProtocolOptions protocolOptions = null, SocketOptions socketOptions = null, PoolingOptions poolingOptions = null) { if (socketOptions == null) { socketOptions = new SocketOptions(); } if (protocolOptions == null) { protocolOptions = new ProtocolOptions(); } var config = new TestConfigurationBuilder { ProtocolOptions = protocolOptions, PoolingOptions = poolingOptions, SocketOptions = socketOptions, ClientOptions = new ClientOptions(false, 20000, null) }.Build(); return(CreateConnection(GetProtocolVersion(), config)); }