public void When_Connecting_To_Dead_IP_Connection_Fails_After_n_Seconds()
{
const int connectionTimedOut = 10060;
const string ipThatDoesNotExist = "198.0.0.1:11210";
var ipEndpoint = UriExtensions.GetEndPoint(ipThatDoesNotExist);
var connectionPoolConfig = new PoolConfiguration
{
ConnectTimeout = 1000 //set really low for test
};
var connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
var stopWatch = new Stopwatch();
try
{
stopWatch.Start();
var connection = connectionPool.Acquire();
}
catch (SocketException e)
{
Assert.AreEqual(connectionTimedOut, e.ErrorCode);
}
finally
{
stopWatch.Stop();
Assert.AreEqual(1.0d, Math.Round((double)stopWatch.Elapsed.Seconds));
}
}
/// <summary>
/// Has to be implemented in implementation.
/// PoolBase will call this to figure out how big a pool should be dependent on the given configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns>The number of pooled objects this pool should support.</returns>
protected override int GetPoolSize(PoolConfiguration configuration)
{
int max = 1000;
// most if not all messages needs at least one string builder, if multiple targets, they need one or more each.
return(Math.Min(max, configuration.EstimatedLogEventsPerSecond * 4));
}
public void Test_Authenticate(bool isAuthenticated, bool isEncrypted, bool isSigned)
{
var endpoint = IPEndPointExtensions.GetEndPoint(TestConfiguration.Settings.Hostname, 11207);
var bootstrapUri = new Uri($@"https://{endpoint.Address}:8091/pools");
var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
socket.Connect(endpoint);
var poolConfig = new PoolConfiguration {
UseSsl = true, Uri = bootstrapUri, ClientConfiguration = new ClientConfiguration()
};
var sslStream = new Mock <SslStream>(new MemoryStream(), true, new RemoteCertificateValidationCallback(ServerCertificateValidationCallback));
sslStream.Setup(x => x.IsAuthenticated).Returns(isAuthenticated);
sslStream.Setup(x => x.IsEncrypted).Returns(isEncrypted);
sslStream.Setup(x => x.IsSigned).Returns(isSigned);
var connPool = new Mock <IConnectionPool <IConnection> >();
connPool.Setup(x => x.Configuration).Returns(poolConfig);
var conn = new SslConnection(connPool.Object, socket, sslStream.Object, new DefaultConverter(),
new BufferAllocator(1024, 1024));
if (isAuthenticated && isEncrypted && isSigned)
{
Assert.DoesNotThrow(conn.Authenticate);
}
else
{
Assert.Throws <AuthenticationException>(conn.Authenticate);
}
}
public void When_Connecting_To_Good_IP_Connection_Succeeds_Before_ConnectTimeout()
{
const int connectionTimedOut = 10060;
string ipThatDoesExist = ConfigurationManager.AppSettings["OperationTestAddress"];
var ipEndpoint = UriExtensions.GetEndPoint(ipThatDoesExist);
var connectionPoolConfig = new PoolConfiguration
{
ConnectTimeout = 5000 //set really low for test
};
var connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
IConnection connection = null;
var stopWatch = new Stopwatch();
try
{
stopWatch.Start();
connection = connectionPool.Acquire();
}
catch (SocketException e)
{
Assert.AreEqual(connectionTimedOut, e.ErrorCode);
}
finally
{
stopWatch.Stop();
Assert.IsNotNull(connection);
Assert.IsTrue(connection.Socket.Connected);
connection.Dispose();
}
}
/// <summary>
/// CTOR for testing/dependency injection.
/// </summary>
/// <param name="configuration">The <see cref="PoolConfiguration"/> to use.</param>
/// <param name="endPoint">The <see cref="IPEndPoint"/> of the Couchbase Server.</param>
/// <param name="factory">A functory for creating <see cref="IConnection"/> objects./></param>
public ConnectionPool(PoolConfiguration configuration, IPEndPoint endPoint, Func <ConnectionPool <T>, IByteConverter, T> factory, IByteConverter converter)
{
_configuration = configuration;
_factory = factory;
_converter = converter;
EndPoint = endPoint;
}
/// <summary>
/// Implementations of pools can inspect the pool configuration and tweak their configuration based on the new configuration.
/// Do not copy the configuration to a local variable.
/// </summary>
/// <param name="configuration">The new configuration to use.</param>
protected override void PoolLimitsChanged(PoolConfiguration configuration)
{
this.individualArraySize = DefaultIndividualArraySize;
if (configuration.LoggingConfiguration != null)
{
this.numberOfTargets = configuration.LoggingConfiguration.AllTargets.Count;
InternalLogger.Info("Setting numberOfTargets to be:{0}", this.numberOfTargets);
int maxQueue = 0;
for (int x = 0; x < configuration.LoggingConfiguration.AllTargets.Count; x++)
{
var target = configuration.LoggingConfiguration.AllTargets[x] as AsyncTargetWrapper;
if (target != null)
{
if (target.BatchSize > maxQueue)
{
maxQueue = target.BatchSize;
}
}
}
InternalLogger.Info("Setting individual array size for AsyncContinuationListPool to be:{0}", maxQueue);
// Set a good default array size to accomodate the highest batchsize of the async targets.
this.individualArraySize = maxQueue;
}
}
/// <summary>
/// Has to be implemented in implementation.
/// PoolBase will call this to figure out how big a pool should be dependent on the given configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns>The number of pooled objects this pool should support.</returns>
protected override int GetPoolSize(PoolConfiguration configuration)
{
var size = this.NumberOfTargets * 100;
InternalLogger.Info("Setting PoolSize for:{0} to be:{1}", this.GetType().FullName, size.AsString());
return(size);
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
}
protected override void PoolLimitsChanged(PoolConfiguration configuration)
{
this.IndividualArraySize = 100;
if (configuration.LoggingConfiguration != null)
{
this.NumberOfTargets = configuration.LoggingConfiguration.AllTargets.Count;
InternalLogger.Info("Setting numberOfTargets for:{0} to be:{1}", this.GetType().FullName, this.NumberOfTargets);
this.MaxQueueSize = 0;
for (int x = 0; x < configuration.LoggingConfiguration.AllTargets.Count; x++)
{
var target = configuration.LoggingConfiguration.AllTargets[x] as AsyncTargetWrapper;
if (target != null)
{
if (target.BatchSize > this.MaxQueueSize)
{
this.MaxQueueSize = target.BatchSize;
}
}
}
InternalLogger.Info("Setting individual array size for {0} to be:{1}", this.GetType().FullName, this.MaxQueueSize);
// Set a good default array size to accomodate the highest batchsize of the async targets.
this.IndividualArraySize = this.MaxQueueSize;
}
}
/// <summary>
/// Sets the initial size of the memory stream, by guessing a good initial size based on the estimated max message size and the number of log events per second.
/// </summary>
/// <param name="configuration">The pool configuration.</param>
private void SetStreamSize(PoolConfiguration configuration)
{
this.initialStreamSize = configuration.EstimatedMaxMessageSize * configuration.EstimatedLogEventsPerSecond * 4;
if (this.initialStreamSize < 0)
{
this.initialStreamSize = 16384;
}
}
public void OneTimeSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
_ioService = new PooledIOService(_connectionPool);
}
public void TestFixtureSetUp()
{
_endPoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new DefaultConnectionPool(connectionPoolConfig, _endPoint);
_ioStrategy = new AwaitableIOStrategy(_connectionPool);
}
/// <summary>
/// CTOR for testing/dependency injection.
/// </summary>
/// <param name="configuration">The <see cref="PoolConfiguration"/> to use.</param>
/// <param name="endPoint">The <see cref="IPEndPoint"/> of the Couchbase Server.</param>
/// <param name="factory">A functory for creating <see cref="IConnection"/> objects./></param>
internal ConnectionPool(PoolConfiguration configuration, IPEndPoint endPoint, Func <ConnectionPool <T>, IByteConverter, BufferAllocator, T> factory, IByteConverter converter)
{
_configuration = configuration;
_factory = factory;
_converter = converter;
_bufferAllocator = Configuration.BufferAllocator(Configuration);
EndPoint = endPoint;
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
_ioStrategy = new DefaultIOStrategy(_connectionPool);
}
/// <summary>
/// CTOR for testing/dependency injection.
/// </summary>
/// <param name="configuration">The <see cref="PoolConfiguration"/> to use.</param>
/// <param name="endPoint">The <see cref="IPEndPoint"/> of the Couchbase Server.</param>
/// <param name="factory">A functory for creating <see cref="IConnection"/> objects./></param>
/// <param name="converter">The <see cref="IByteConverter"/>that this instance is using.</param>
internal ConnectionPoolBase(PoolConfiguration configuration, IPEndPoint endPoint, Func <IConnectionPool <T>, IByteConverter, BufferAllocator, T> factory, IByteConverter converter)
{
Configuration = configuration;
Factory = factory;
Converter = converter;
BufferAllocator = Configuration.BufferAllocator(Configuration);
EndPoint = endPoint;
}
/// <summary>
/// Implementations of pools can inspect the pool configuration and tweak their configuration based on the new configuration.
/// Do not copy the configuration to a local variable.
/// </summary>
/// <param name="configuration">The new configuration to use.</param>
protected override void PoolLimitsChanged(PoolConfiguration configuration)
{
base.PoolLimitsChanged(configuration);
// hard coded to 180k to be put into LOH immediately
// bigger buffers give better performance when converting to bytes, via encoding.
this.IndividualArraySize = 180000;
}
/// <summary>
/// Implementations of pools can inspect the pool configuration and tweak their configuration based on the new configuration.
/// Do not copy the configuration to a local variable.
/// </summary>
/// <param name="configuration">The new configuration to use.</param>
protected override void PoolLimitsChanged(PoolConfiguration configuration)
{
base.PoolLimitsChanged(configuration);
// set array size to be at least 90k to get above 85k elements, so it gets put into LOH immediately
int min = 90000 * 8;
this.IndividualArraySize = Math.Max(min, this.MaxQueueSize);
}
public void OneTimeSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var connectionPoolConfig = new PoolConfiguration {
UseSsl = false
};
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
}
public virtual void TestFixtureSetUp()
{
EndPoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, EndPoint);
_ioService = new PooledIOService(_connectionPool);
Transcoder = new DefaultTranscoder();
}
IConnectionPool CreateConnectionPool(PoolConfiguration poolConfiguration, IPEndPoint endpoint)
{
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
connectionPool.SaslMechanism = SaslFactory(UserName, Password, connectionPool, Transcoder);
connectionPool.Initialize();
return(connectionPool);
}
public virtual void TestFixtureSetUp()
{
EndPoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <EapConnection>(connectionPoolConfig, EndPoint);
_ioStrategy = new DefaultIOStrategy(_connectionPool);
Transcoder = new DefaultTranscoder(Converter);
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration();
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
_connectionPool.Initialize();
_ioService = new PooledIOService(_connectionPool, null);
}
public void SetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var factory = DefaultConnectionFactory.GetGeneric <Connection>();
_configuration = new PoolConfiguration(MaxSize, MinSize, WaitTimeout, RecieveTimeout, ShutdownTimeout, SendTimeout, ConnectTimeout, MaxConnectionAcquireCount, BucketName);
_connectionPool = new ConnectionPool <Connection>(_configuration, ipEndpoint, factory, new DefaultConverter());
_connectionPool.Initialize();
}
public void SetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(Address);
var factory = DefaultConnectionFactory.GetDefault();
_configuration = new PoolConfiguration(MaxSize, MinSize, WaitTimeout, RecieveTimeout, ShutdownTimeout, SendTimeout);
_connectionPool = new DefaultConnectionPool(_configuration, ipEndpoint, factory);
_connectionPool.Initialize();
}
/// <summary>
/// Implementations of pools can inspect the pool configuration and tweak their configuration based on the new configuration.
/// Do not copy the configuration to a local variable.
/// </summary>
/// <param name="configuration">The new configuration to use.</param>
protected override void PoolLimitsChanged(PoolConfiguration configuration)
{
base.PoolLimitsChanged(configuration);
// set array size to be at least 90k to get above 85k elements, so it gets put into LOH immediately
int min = 90000;
this.IndividualArraySize = Math.Max(min, this.MaxQueueSize);
InternalLogger.Info("Setting IndividualArraySize for:{0} to be:{1}", this.GetType().FullName, this.IndividualArraySize.AsString());
}
/// <summary>
/// Restarts the pool with the new settings
/// </summary>
/// <param name="configuration">The configuration with the new settings.</param>
private void Restart(PoolConfiguration configuration)
{
this.preFill = configuration.PrefillPools;
this.autoIncrease = configuration.AutoIncreasePoolSizes;
this.poolSize = this.GetPoolSize(configuration);
this.enabled = configuration.Enabled;
this.RestartPool(configuration);
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address);
var connectionPoolConfig = new PoolConfiguration {
UseSsl = false
};
_connectionPool = new ConnectionPool <Connection>(connectionPoolConfig, ipEndpoint);
_ioService = new PooledIOService(_connectionPool);
}
protected IIOService CreateIOService(PoolConfiguration poolConfiguration, IPEndPoint endpoint)
{
var connectionPool = ConnectionPoolFactory(poolConfiguration, endpoint);
connectionPool.SaslMechanism = SaslFactory(UserName, Password, connectionPool, Transcoder);
var ioService = IOServiceFactory(connectionPool);
connectionPool.Initialize();
return(ioService);
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(Address);
var connectionPoolConfig = new PoolConfiguration
{
UseSsl = true
};
_connectionPool = new ConnectionPool <SslConnection>(connectionPoolConfig, ipEndpoint);
_connectionPool.Initialize();
_ioStrategy = new DefaultIOStrategy(_connectionPool, null);
}
public void TestFixtureSetUp()
{
var ipEndpoint = UriExtensions.GetEndPoint(_address.Replace("11210", "11207"));
var connectionPoolConfig = new PoolConfiguration
{
UseSsl = true
};
_connectionPool = new ConnectionPool <SslConnection>(connectionPoolConfig, ipEndpoint);
_connectionPool.Initialize();
_ioService = new PooledIOService(_connectionPool, null);
}
internal MemoryManager(PoolConfiguration configuration)
{
_configuration = configuration;
}
