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; }