public void Test_Default()
{
var config = new ClientConfiguration();
Assert.AreEqual(1, config.BucketConfigs.Count);
var bucketConfig = config.BucketConfigs.First().Value;
IPAddress ipAddress;
IPAddress.TryParse("127.0.0.1", out ipAddress);
var endPoint = new IPEndPoint(ipAddress, bucketConfig.Port);
Assert.AreEqual(endPoint, bucketConfig.GetEndPoint());
Assert.IsEmpty(bucketConfig.Password);
Assert.IsEmpty(bucketConfig.Username);
Assert.AreEqual(11210, bucketConfig.Port);
Assert.AreEqual("default", bucketConfig.BucketName);
Assert.AreEqual(2, bucketConfig.PoolConfiguration.MaxSize);
Assert.AreEqual(1, bucketConfig.PoolConfiguration.MinSize);
Assert.AreEqual(2500, bucketConfig.PoolConfiguration.RecieveTimeout);
Assert.AreEqual(2500, bucketConfig.PoolConfiguration.OperationTimeout);
Assert.AreEqual(10000, bucketConfig.PoolConfiguration.ShutdownTimeout);
Assert.AreEqual(2500, bucketConfig.DefaultOperationLifespan);
Assert.AreEqual(75000, config.ViewRequestTimeout);
}
public async Task When_Observing_Key_During_RemoveAsync_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new DefaultConverter(),
new DefaultTranscoder(new DefaultConverter()));
var configInfo = provider.GetConfig("default");
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Transcoder).Returns(new DefaultTranscoder());
var pending = new ConcurrentDictionary<uint, IOperation>();
var observer = new KeyObserver(pending, configInfo, clusterController.Object, 10, 500);
using (var cts = new CancellationTokenSource(configuration.ObserveTimeout))
{
var constraintReached =
await observer.ObserveRemoveAsync("Test_Timeout_Remove_Async", 0, ReplicateTo.Zero, PersistTo.One, cts);
Assert.IsTrue(constraintReached);
}
}
static ConfigUtil()
{
ServerConfig = new FileSystemConfig(BootstrapPath);
ServerConfig.Initialize();
ClientConfig = new FakeClientConfig();
}
/// <summary>
/// Ctor for creating Cluster instance.
/// </summary>
/// <param name="configuration">The ClientCOnfiguration to use for initialization.</param>
/// <param name="clusterManager">The ClusterManager instance use.</param>
/// <remarks>
/// This overload is primarly added for testing.
/// </remarks>
internal ClusterHelper(ClientConfiguration configuration, IClusterController clusterManager, ILoggerFactory loggerFactory)
{
_loggerFactory = loggerFactory;
Log = _loggerFactory.CreateLogger<ClusterHelper>();
_configuration = configuration;
_clusterManager = clusterManager;
}
public static void Initialize()
{
var config = new ClientConfiguration();
config.BucketConfigs.Clear();
config.Servers = new List<Uri>(new Uri[] { new Uri(CouchbaseConfigHelper.Instance.Server) });
config.BucketConfigs.Add(
CouchbaseConfigHelper.Instance.Bucket,
new BucketConfiguration
{
BucketName = CouchbaseConfigHelper.Instance.Bucket,
Username = CouchbaseConfigHelper.Instance.User,
Password = CouchbaseConfigHelper.Instance.Password
});
config.BucketConfigs.Add(
"default",
new BucketConfiguration
{
BucketName = "default",
Username = CouchbaseConfigHelper.Instance.User,
Password = CouchbaseConfigHelper.Instance.Password
});
ClusterHelper.Initialize(config);
}
static void Main(string[] args)
{
File.Delete(@"C:\temp\log.txt");
var config = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri("http://127.0.0.1:8091/pools")
},
PoolConfiguration = new PoolConfiguration
{
MaxSize = 2,
MinSize = 1
},
UseSsl = false
};
using (_cluster = new CouchbaseCluster(config))
{
using (var bucket = _cluster.OpenBucket("default"))
{
const int n = 100000;
using (var timer = new OperationTimer())
{
//ThreadPoolInsert(bucket, n);
//ThreadPoolInsert(bucket, n);
//SynchronousInsert(bucket, n);
//ParallerInsert(bucket, n);
MultiThreaded(8, n, bucket);
}
}
}
Console.Read();
}
public ClusterController(ClientConfiguration clientConfig)
: this(clientConfig,
pool =>
{
Log.Debug(m => m("Creating DefaultIOStrategy"));
return new DefaultIOStrategy(pool);
},
(config, endpoint) =>
{
IConnectionPool connectionPool;
if (config.UseSsl)
{
connectionPool = new ConnectionPool<SslConnection>(config, endpoint);
}
else
{
connectionPool = new ConnectionPool<Connection>(config, endpoint);
}
connectionPool.Initialize();
return connectionPool;
},
SaslFactory.GetFactory3(),
clientConfig.Converter(),
clientConfig.Transcoder())
{
}
private static void Main(string[] args)
{
var count = 100;
var config = new ClientConfiguration
{
Servers = new List<Uri>
{
//change this to your cluster to bootstrap
new Uri("http://localhost:8091/pools")
}
};
ClusterHelper.Initialize(config);
var bucket = ClusterHelper.GetBucket("default");
//var items = new List<Person>();
//for (int i = 0; i < count; i++)
//{
// items.Add(new Person {Age = i, Name = "Bảo Address " + i, Id = i.ToString()});
// Console.WriteLine("++Person: {0}", i);
//}
var groups = new List<Group>();
for (int i = 0; i < count; i++)
{
groups.Add(new Group { ListPersonId = new List<string>(){i.ToString(), (i+1).ToString(), (i+2).ToString()},
Name = "Group " + i, GroupId = i.ToString() });
Console.WriteLine("++Group: {0}", i);
}
Task.Run(async () => await UpsertAllAsync(groups, bucket)).ConfigureAwait(false);
Console.Read();
ClusterHelper.Close();
}
public void When_Observing_Key_During_Remove_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<EapConnection>(config, endpoint),
SaslFactory.GetFactory3(),
new AutoByteConverter(),
new TypeSerializer(new AutoByteConverter()));
var configInfo = provider.GetConfig("default");
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = observer.ObserveRemove("Test_Timeout_Remove", 0, ReplicateTo.Zero, PersistTo.One);
Assert.IsTrue(constraintReached);
}
public void When_Observing_Key_During_Add_Durability_Constraint_Is_Reached()
{
var configuration = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(ConfigurationManager.AppSettings["bootstrapUrl"])
}
};
configuration.Initialize();
var provider = new CarrierPublicationProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<EapConnection>(config, endpoint),
SaslFactory.GetFactory3(),
new AutoByteConverter(),
new TypeSerializer(new AutoByteConverter()));
var configInfo = provider.GetConfig("default");
ulong cas = 0;
using (var cluster = new CouchbaseCluster(configuration))
{
using (var bucket = cluster.OpenBucket())
{
bucket.Remove("Test_Timeout_Add");
bucket.Insert("Test_Timeout_Add", "");
cas = bucket.Upsert("Test_Timeout_Add", "").Cas;
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = observer.ObserveAdd("Test_Timeout_Add", cas, ReplicateTo.One, PersistTo.One);
Assert.IsTrue(constraintReached);
}
public void Test_Custom()
{
var config = new ClientConfiguration
{
PoolConfiguration = new PoolConfiguration
{
MaxSize = 10,
MinSize = 10
}
};
config.Initialize();
Assert.AreEqual(1, config.BucketConfigs.Count);
var bucketConfig = config.BucketConfigs.First().Value;
IPAddress ipAddress;
IPAddress.TryParse("127.0.0.1", out ipAddress);
var endPoint = new IPEndPoint(ipAddress, bucketConfig.Port);
Assert.AreEqual(endPoint, bucketConfig.GetEndPoint());
Assert.IsEmpty(bucketConfig.Password);
Assert.IsEmpty(bucketConfig.Username);
Assert.AreEqual(11210, bucketConfig.Port);
Assert.AreEqual("default", bucketConfig.BucketName);
Assert.AreEqual(10, bucketConfig.PoolConfiguration.MaxSize);
Assert.AreEqual(10, bucketConfig.PoolConfiguration.MinSize);
Assert.AreEqual(2500, bucketConfig.PoolConfiguration.RecieveTimeout);
Assert.AreEqual(2500, bucketConfig.PoolConfiguration.OperationTimeout);
Assert.AreEqual(10000, bucketConfig.PoolConfiguration.ShutdownTimeout);
}
public void When_GetBaseViewUri_Is_Called_With_EncryptTraffic_True_Uri_Is_SSL_URI()
{
var configuration = new ClientConfiguration
{
UseSsl = true
};
configuration.Initialize();
var json = File.ReadAllText(@"Data\\Configuration\\cb4-config-4-nodes.json");
var config = JsonConvert.DeserializeObject<BucketConfig>(json);
var nodes = config.GetNodes();
var node = nodes.Find(x => x.Hostname.Equals("192.168.109.104"));
var ioStrategy = new FakeIOStrategy(UriExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue),
new FakeConnectionPool(), false);
using (var server = new Server(ioStrategy,
node,
configuration,
config,
new FakeTranscoder()))
{
var uri = server.CachedViewBaseUri;
Assert.AreEqual("https://192.168.109.104:18092/default", uri);
}
}
public SearchClient(IBucketConfig bucketConfig, ClientConfiguration clientConfig, IDataMapper dataMapper, ILogger logger)
{
_bucketConfig = bucketConfig;
_clientConfig = clientConfig;
DataMapper = dataMapper;
Log = logger;
}
public ClusterManager(ClientConfiguration clientConfig)
: this(clientConfig,
pool =>
{
Log.Debug(m => m("Creating DefaultIOStrategy"));
return new DefaultIOStrategy(pool);
},
(config, endpoint) =>
{
IConnectionPool connectionPool;
if (config.UseSsl)
{
connectionPool = new ConnectionPool<SslConnection>(config, endpoint);
}
else
{
connectionPool = new ConnectionPool<EapConnection>(config, endpoint);
}
return connectionPool;
},
SaslFactory.GetFactory3(),
new AutoByteConverter(),
new TypeSerializer(new AutoByteConverter(), clientConfig.DeserializationContractResolver, clientConfig.SerializationContractResolver))
{
}
public void TestFixtureSetup()
{
var configuration = new ClientConfiguration();
var connectionPool = new ConnectionPool<EapConnection>(new PoolConfiguration(), UriExtensions.GetEndPoint(Address));
var ioStrategy = new DefaultIOStrategy(connectionPool);
_server = new Server(ioStrategy, new Node(), configuration);
}
public void When_Configuration_Contains_Bad_Bucket_Password_It_Is_Used_And_Fails()
{
var config = new ClientConfiguration((CouchbaseClientSection) ConfigurationManager.GetSection("couchbaseClients/couchbase"));
config.BucketConfigs = new Dictionary<string, BucketConfiguration>
{
{
"default",
new BucketConfiguration
{
BucketName = "default",
Password = "******"
}
}
};
var cluster = new Cluster(config);
var bucketName = config.BucketConfigs.Single().Value.BucketName;
try
{
var bucket = cluster.OpenBucket(bucketName);
Assert.Fail("Unexpected GetBucket success");
}
catch (AggregateException e)
{
e = e.Flatten();
if (e.InnerExceptions.All(x => x.GetType() != typeof (AuthenticationException)))
{
Assert.Fail("Expected authentication exception, got " + e.InnerException);
}
//success
}
}
private static void Main(string[] args)
{
var count = 100000;
var config = new ClientConfiguration
{
Servers = new List<Uri>
{
//change this to your cluster to bootstrap
new Uri("http://localhost/:8091/pools")
}
};
ClusterHelper.Initialize(config);
var bucket = ClusterHelper.GetBucket("default");
var items = new List<Person>();
for (int i = 0; i < count; i++)
{
items.Add(new Person {Age = 21, Name = "Some name" + i, Id = i.ToString()});
}
Task.Run(async () => await UpsertAllAsync(items, bucket)).ConfigureAwait(false);
Console.Read();
ClusterHelper.Close();
}
public PoolConfiguration(ClientConfiguration clientConfiguration = null)
{
_maxSize = Defaults.MaxSize;
_minSize = Defaults.MinSize;
WaitTimeout = Defaults.WaitTimeout;
#pragma warning disable 612
RecieveTimeout = Defaults.ReceiveTimeout;
#pragma warning restore 612
ShutdownTimeout = Defaults.ShutdownTimeout;
#pragma warning disable 618
OperationTimeout = Defaults.OperationTimeout;
#pragma warning restore 618
MaxAcquireIterationCount = Defaults.MaxAcquireIterationCount;
SendTimeout = Defaults.SendTimeout;
BufferSize = Defaults.BufferSize;
ConnectTimeout = Defaults.ConnectTimeout;
EnableTcpKeepAlives = Defaults.EnableTcpKeepAlives;
TcpKeepAliveTime = Defaults.TcpKeepAliveTime;
TcpKeepAliveInterval = Defaults.TcpKeepAliveInterval;
CloseAttemptInterval = Defaults.CloseAttemptInterval;
MaxCloseAttempts = Defaults.MaxCloseAttempts;
UseEnhancedDurability = Defaults.UseEnhancedDurability;
//in some cases this is needed all the way down the stack
ClientConfiguration = clientConfiguration;
BufferAllocator = (p) => new BufferAllocator(p.MaxSize * p.BufferSize, p.BufferSize);
}
public PoolConfiguration(ILoggerFactory loggerFactory, int maxSize, int minSize, int waitTimeout, int receiveTimeout, int shutdownTimeout,
int operationTimeout, int maxAcquireIterationCount, int connectTimeout, ClientConfiguration clientConfiguration = null)
{
_loggerFactory = loggerFactory;
if (loggerFactory != null)
Log = _loggerFactory.CreateLogger<PoolConfiguration>();
//todo enable app.configuration
MaxSize = maxSize;
MinSize = minSize;
WaitTimeout = waitTimeout;
RecieveTimeout = receiveTimeout;
ShutdownTimeout = shutdownTimeout;
OperationTimeout = operationTimeout;
MaxAcquireIterationCount = maxAcquireIterationCount;
ClientConfiguration = clientConfiguration;
ConnectTimeout = connectTimeout;
BufferAllocator = (p) => new BufferAllocator(p.MaxSize * p.BufferSize, p.BufferSize, loggerFactory);
EnableTcpKeepAlives = true;
TcpKeepAliveTime = (uint)2 * 60 * 60 * 1000;
TcpKeepAliveInterval = (uint)1000;
CloseAttemptInterval = 100u;
MaxCloseAttempts = 5;
}
public PoolConfiguration(ILoggerFactory loggerFactory = null, ClientConfiguration clientConfiguration = null)
{
_loggerFactory = loggerFactory;
if (loggerFactory != null)
Log = _loggerFactory.CreateLogger<PoolConfiguration>();
MaxSize = Defaults.MaxSize;
MinSize = Defaults.MinSize;
WaitTimeout = Defaults.WaitTimeout;
RecieveTimeout = Defaults.ReceiveTimeout;
ShutdownTimeout = Defaults.ShutdownTimeout;
OperationTimeout = Defaults.OperationTimeout;
MaxAcquireIterationCount = Defaults.MaxAcquireIterationCount;
SendTimeout = Defaults.SendTimeout;
BufferSize = Defaults.BufferSize;
ConnectTimeout = Defaults.ConnectTimeout;
EnableTcpKeepAlives = Defaults.EnableTcpKeepAlives;
TcpKeepAliveTime = Defaults.TcpKeepAliveTime;
TcpKeepAliveInterval = Defaults.TcpKeepAliveInterval;
CloseAttemptInterval = Defaults.CloseAttemptInterval;
MaxCloseAttempts = Defaults.MaxCloseAttempts;
UseEnhancedDurability = Defaults.UseEnhancedDurability;
//in some cases this is needed all the way down the stack
ClientConfiguration = clientConfiguration;
BufferAllocator = (p) => new BufferAllocator(p.MaxSize * p.BufferSize, p.BufferSize, loggerFactory);
}
public Cluster Cluster()
{
var config = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri(hostName +":8091/pools"),
},
UseSsl = false,
BucketConfigs = new Dictionary<string, BucketConfiguration>
{
{
"default",
new BucketConfiguration
{
BucketName = bucketName,
UseSsl = false,
Password = password,
PoolConfiguration = new PoolConfiguration
{
MaxSize = 5,
MinSize = 1
}
}
}
}
};
return new Cluster(config);
}
public IBucket GetBucketForKey(string key)
{
var config = new ClientConfiguration();
var fakeServer = new FakeServer(_connectionPool, null, null, _endPoint,
new FakeIOStrategy(_endPoint, _connectionPool, false));
var mappedNode = new Mock<IMappedNode>();
mappedNode.Setup(x => x.LocatePrimary()).Returns(fakeServer);
var mockKeyMapper = new Mock<IKeyMapper>();
mockKeyMapper.Setup(x => x.MapKey(key)).Returns(mappedNode.Object);
var mockConfigInfo = new Mock<IConfigInfo>();
mockConfigInfo.Setup(x => x.GetKeyMapper()).Returns(mockKeyMapper.Object);
mockConfigInfo.Setup(x => x.BucketConfig).Returns(_bucketConfig);
mockConfigInfo.Setup(x => x.GetServer()).Returns(fakeServer);
var mockController = new Mock<IClusterController>();
mockController.Setup(x => x.Configuration).Returns(config);
mockController.Setup(x => x.CreateBucket("memcached", ""))
.Returns(new MemcachedBucket(mockController.Object, "memcached", _converter, _transcoder));
var cluster = new Cluster(config, mockController.Object);
var bucket = cluster.OpenBucket("memcached", "");
//simulate a config event
((IConfigObserver) bucket).NotifyConfigChanged(mockConfigInfo.Object);
return bucket;
}
public ConfigInfo(IServerConfig serverConfig, ClientConfiguration clientConfig)
{
ServerConfig = serverConfig;
ClientConfig = clientConfig;
CreationTime = DateTime.Now;
Initialize();
}
public void When_InValid_Credentials_Provided_Bucket_Created_UnSuccesfully()
{
try
{
var config = new ClientConfiguration
{
Servers = new List<Uri> { new Uri("http://127.0.0.1:8091") },
BucketConfigs = new Dictionary<string, BucketConfiguration>
{
{
"authenticated",
new BucketConfiguration
{
BucketName = "authenticated"
}
}
}
};
var cluster = new Cluster(config);
var bucket = cluster.OpenBucket("authenticated", "secretw");
cluster.CloseBucket(bucket);
Assert.IsNotNull(bucket);
}
catch (AggregateException e)
{
foreach (var exception in e.InnerExceptions)
{
if (exception.GetType() == typeof (AuthenticationException))
{
throw exception;
}
}
}
}
public void SetUp()
{
_endPoint = UriExtensions.GetEndPoint(_address);
CouchbaseClientSection section = (CouchbaseClientSection)ConfigurationManager.GetSection("couchbaseClients/couchbase");
_clientConfig = new ClientConfiguration(section);
_clusterManager = new ClusterController(_clientConfig);
}
public void SetUp()
{
var configuration = new ClientConfiguration
{
UseSsl = true
};
configuration.Initialize();
var json = File.ReadAllText(@"Data\\Configuration\\cb4-config-4-nodes.json");
var config = JsonConvert.DeserializeObject<BucketConfig>(json);
var nodes = config.GetNodes();
var node = nodes.Find(x => x.Hostname.Equals("192.168.109.104"));
var ioStrategy = new FakeIOStrategy(UriExtensions.GetEndPoint(node.Hostname + ":" + node.KeyValue),
new FakeConnectionPool(), false);
_configContext = new CouchbaseConfigContext(config,
configuration,
pool => ioStrategy,
(c, e) => new FakeConnectionPool(),
SaslFactory.GetFactory(),
new DefaultTranscoder(new DefaultConverter()));
_configContext.LoadConfig();
}
public IBucket GetBucketForKey(string key)
{
var config = new ClientConfiguration();
var fakeServer = new FakeServer(_connectionPool, null, null, _endPoint,
new FakeIOService(_endPoint, _connectionPool, false));
var mockVBucket = new Mock<IVBucket>();
mockVBucket.Setup(x => x.LocatePrimary()).Returns(fakeServer);
var mockKeyMapper = new Mock<IKeyMapper>();
mockKeyMapper.Setup(x => x.MapKey(key, It.IsAny<uint>())).Returns(mockVBucket.Object);
var mockConfigInfo = new Mock<IConfigInfo>();
mockConfigInfo.Setup(x => x.GetKeyMapper()).Returns(mockKeyMapper.Object);
mockConfigInfo.Setup(x => x.BucketConfig).Returns(_bucketConfig);
mockConfigInfo.Setup(x => x.GetServer()).Returns(fakeServer);
mockConfigInfo.Setup(x => x.IsDataCapable).Returns(true);
mockConfigInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var mockController = new Mock<IClusterController>();
mockController.Setup(x => x.Configuration).Returns(config);
mockController.Setup(x => x.CreateBucket("default", "", null))
.Returns(new CouchbaseBucket(mockController.Object, "default", _converter, _transcoder, null));
var cluster = new Cluster(config, mockController.Object);
var bucket = cluster.OpenBucket("default", "");
//simulate a config event
((IConfigObserver)bucket).NotifyConfigChanged(mockConfigInfo.Object);
return bucket;
}
public async void Test_Creating_A_Cluster()
{
var config = new ClientConfiguration
{
Servers = new List<Uri>
{
new Uri("http://192.168.77.101:8091/"),
new Uri("http://192.168.77.102:8091/"),
new Uri("http://192.168.77.103:8091/"),
new Uri("http://192.168.77.104:8091/")
}
};
var cluster = new Cluster(config);
var provisioner = new ClusterProvisioner(cluster, "Administrator", "password");
/* var results = await provisioner.ProvisionEntryPointAsync();
foreach (var res in results.Results)
{
Console.WriteLine(res.Message);
}
Assert.IsTrue(results.Success);
var result = await provisioner.ProvisionSampleBucketAsync("beer-sample");
Assert.IsTrue(result.Success);
result = await provisioner.ProvisionSampleBucketAsync("travel-sample");
Assert.IsTrue(result.Success);
result = await provisioner.ProvisionBucketAsync(new BucketSettings
{
Name = "authenticated",
SaslPassword = "******",
AuthType = AuthType.Sasl,
BucketType = BucketTypeEnum.Couchbase
});
Assert.IsTrue(result.Success);
result = await provisioner.ProvisionBucketAsync(new BucketSettings
{
Name = "memcached",
SaslPassword = "",
AuthType = AuthType.Sasl,
BucketType = BucketTypeEnum.Memcached
});
Assert.IsTrue(result.Success);*/
/*var results = await provisioner.ProvisionNodesAsync(CouchbaseService.Index,
CouchbaseService.KV,
CouchbaseService.N1QL);
foreach (var res in results.Results)
{
Console.WriteLine(res.Message);
}*/
var result = await provisioner.RebalanceClusterAsync();
Console.WriteLine(result.Message);
}
public CouchbaseConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig,
Func<IConnectionPool, IOStrategy> ioStrategyFactory,
Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory,
Func<string, string, IOStrategy, ITypeTranscoder, ISaslMechanism> saslFactory,
ITypeTranscoder transcoder)
: base(bucketConfig, clientConfig, ioStrategyFactory, connectionPoolFactory, saslFactory, transcoder)
{
}
public MemcachedConfigContext(IBucketConfig bucketConfig, ClientConfiguration clientConfig,
Func<IConnectionPool, IIOService> ioServiceFactory,
Func<PoolConfiguration, IPEndPoint, IConnectionPool> connectionPoolFactory,
Func<string, string, IIOService, ITypeTranscoder, ISaslMechanism> saslFactory,
ITypeTranscoder transcoder)
: base(bucketConfig, clientConfig, ioServiceFactory, connectionPoolFactory, saslFactory, transcoder)
{
}
public PoolConfiguration(int maxSize, int minSize, int waitTimeout, int receiveTimeout, int shutdownTimeout,
int operationTimeout, int maxAcquireIterationCount, int connectTimeout, string bucketName, ClientConfiguration clientConfiguration = null)
{
//todo enable app.configuration
ValidateConnectionValues(maxSize, minSize);
_maxSize = maxSize;
_minSize = minSize;
WaitTimeout = waitTimeout;
#pragma warning disable 612
RecieveTimeout = receiveTimeout;
#pragma warning restore 612
ShutdownTimeout = shutdownTimeout;
#pragma warning disable 618
OperationTimeout = operationTimeout;
#pragma warning restore 618
MaxAcquireIterationCount = maxAcquireIterationCount;
ClientConfiguration = clientConfiguration;
ConnectTimeout = connectTimeout;
BufferAllocator = (p) => new BufferAllocator(p.MaxSize * p.BufferSize, p.BufferSize);
EnableTcpKeepAlives = true;
TcpKeepAliveTime = (uint)2 * 60 * 60 * 1000;
TcpKeepAliveInterval = (uint)1000;
CloseAttemptInterval = 100u;
MaxCloseAttempts = 5;
BucketName = bucketName;
}
