public void Test_Timed_Execution_Parallel_Client()
{
var options = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
var n = 1000;//set to a higher # if needed
using (var cluster = new CouchbaseCluster())
{
using (var bucket = cluster.OpenBucket())
{
using (new OperationTimer())
{
var temp = bucket;
Parallel.For(0, n, options, i =>
{
var key = string.Format("key{0}", i);
var result = temp.Upsert(key, i);
Assert.IsTrue(result.Success);
var result1 = temp.Get <int>(key);
Assert.IsTrue(result1.Success);
Assert.AreEqual(i, result1.Value);
});
}
}
}
}
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 void Test_Programmatic_Config_Construction_Using_Custom_Settings()
{
using (var cluster = new CouchbaseCluster("couchbaseClients/couchbase_1"))
{
var configuration = cluster.Configuration;
Assert.AreEqual(443, configuration.SslPort);
Assert.AreEqual(8095, configuration.MgmtPort);
Assert.AreEqual(8094, configuration.ApiPort);
Assert.AreEqual(18099, configuration.HttpsMgmtPort);
Assert.AreEqual(18098, configuration.HttpsApiPort);
Assert.AreEqual(11219, configuration.DirectPort);
Assert.IsTrue(configuration.UseSsl);
var server = configuration.Servers.First();
Assert.AreEqual(new Uri("https://localhost2:18099/pools"), server);
var bucketKvp = configuration.BucketConfigs.First();
Assert.AreEqual("testbucket", bucketKvp.Key);
Assert.AreEqual("shhh!", bucketKvp.Value.Password);
Assert.IsTrue(bucketKvp.Value.UseSsl);
Assert.AreEqual("testbucket", bucketKvp.Value.BucketName);
var poolConfiguration = bucketKvp.Value.PoolConfiguration;
Assert.IsTrue(poolConfiguration.UseSsl);
Assert.AreEqual(10, poolConfiguration.MaxSize);
Assert.AreEqual(5, poolConfiguration.MinSize);
Assert.AreEqual(5000, poolConfiguration.WaitTimeout);
Assert.AreEqual(3000, poolConfiguration.ShutdownTimeout);
}
}
public void When_UseSsl_Is_False_At_Bucket_Level_Ssl_Is_Not_Used()
{
var remoteHost = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration
{
BucketConfigs = new Dictionary <string, BucketConfiguration>
{
{ "beer-sample", new BucketConfiguration
{
UseSsl = false
} }
},
Servers = new List <Uri>
{
new Uri(remoteHost)
}
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket("beer-sample"))
{
//only the customers bucket will not use SSL
Assert.IsFalse(bucket.IsSecure);
}
}
public DesignDocManager(CouchbaseClientConfiguration config)
{
if (_cluster == null)
{
_cluster = new CouchbaseCluster(config);
}
}
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_Programmatic_Config_Construction_Using_Default_Settings()
{
var cluster = new CouchbaseCluster("couchbaseClients/couchbase");
var configuration = cluster.Configuration;
Assert.AreEqual(11207, configuration.SslPort);
Assert.AreEqual(8091, configuration.MgmtPort);
Assert.AreEqual(8092, configuration.ApiPort);
Assert.AreEqual(18091, configuration.HttpsMgmtPort);
Assert.AreEqual(18092, configuration.HttpsApiPort);
Assert.AreEqual(11210, configuration.DirectPort);
Assert.IsFalse(configuration.UseSsl);
var server = configuration.Servers.First();
Assert.AreEqual(new Uri("http://localhost:8091/pools"), server);
var bucketKvp = configuration.BucketConfigs.First();
Assert.AreEqual("default", bucketKvp.Key);
Assert.AreEqual(string.Empty, bucketKvp.Value.Password);
Assert.IsFalse(bucketKvp.Value.UseSsl);
Assert.AreEqual("default", bucketKvp.Value.BucketName);
var poolConfiguration = bucketKvp.Value.PoolConfiguration;
Assert.IsFalse(poolConfiguration.UseSsl);
Assert.AreEqual(2, poolConfiguration.MaxSize);
Assert.AreEqual(1, poolConfiguration.MinSize);
Assert.AreEqual(2500, poolConfiguration.WaitTimeout);
Assert.AreEqual(10000, poolConfiguration.ShutdownTimeout);
}
public DesignDocManager(string sectionName = "couchbase")
{
if (_cluster == null)
{
_config = ConfigurationManager.GetSection(sectionName) as CouchbaseClientSection;
_cluster = new CouchbaseCluster(_config);
}
}
public void TestTearDown()
{
_cluster.Dispose();
_cluster = null;
_mreConfig.Dispose();
_mreConfig = null;
}
public void When_Flushing_Bucket_Data_Are_Removed()
{
var storedConfig = ConfigurationManager.GetSection("couchbase") as ICouchbaseClientConfiguration;
var config = new CouchbaseClientConfiguration();
config.Bucket = "Bucket-" + DateTime.Now.Ticks;
config.Username = storedConfig.Username;
config.Password = storedConfig.Password;
config.Urls.Add(storedConfig.Urls[0]);
var cluster = new CouchbaseCluster(config);
cluster.CreateBucket(new Bucket
{
Name = config.Bucket,
AuthType = AuthTypes.Sasl,
BucketType = BucketTypes.Membase,
Quota = new Quota {
RAM = 100
},
ReplicaNumber = ReplicaNumbers.Zero,
FlushOption = FlushOptions.Enabled
}
);
Bucket bucket = null;
for (int i = 0; i < 10; i++) //wait for bucket to be ready to accept ops
{
bucket = waitForBucket(config.Bucket);
if (bucket.Nodes.First().Status == "healthy")
{
break;
}
Thread.Sleep(1000);
}
Assert.That(bucket, Is.Not.Null);
var client = new CouchbaseClient(config);
var storeResult = client.ExecuteStore(StoreMode.Set, "SomeKey", "SomeValue");
Assert.That(storeResult.Success, Is.True, "Message: " + storeResult.Message);
var getResult = client.ExecuteGet <string>("SomeKey");
Assert.That(getResult.Success, Is.True);
Assert.That(getResult.Value, Is.StringMatching("SomeValue"));
cluster.FlushBucket(config.Bucket);
getResult = client.ExecuteGet <string>("SomeKey");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Value, Is.Null);
_Cluster.DeleteBucket(config.Bucket);
}
public void TestFixtureSetUp()
{
_cluster = new CouchbaseCluster();
using (var bucket = _cluster.OpenBucket())
{
bucket.Upsert(TestKeys.KeyWithInt32Value.Key, TestKeys.KeyWithInt32Value.Value);
}
}
public void When_Listing_Buckets_With_Invalid_Config_Argument_Exception_Is_Thrown()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri(ConfigurationManager.AppSettings["CouchbaseServerUrl"] + "/doesnotexist/"));
config.Bucket = "default";
var server = new CouchbaseCluster(config);
var buckets = server.ListBuckets();
}
public void When_Listing_Buckets_With_Invalid_Config_Argument_Exception_Is_Thrown()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/doesnotexist/"));
config.Bucket = "default";
var server = new CouchbaseCluster(config);
var buckets = server.ListBuckets();
}
public static CouchbaseCluster CreateCouchbaseCluster()
{
if (_cluster == null)
{
_cluster = new CouchbaseCluster("couchbase");
}
return(_cluster);
}
public void When_Disposing_StreamingProvider_Worker_Thread_Does_Not_Hang_No_Buckets_Open()
{
//remove CCCP provider because we want to bootstrap off of the StreamingProvider
var cccp = _clusterManager.ConfigProviders.Find(x => x is CarrierPublicationProvider);
_clusterManager.ConfigProviders.Remove(cccp);
var cluster = new CouchbaseCluster(_clientConfig, _clusterManager);
cluster.Dispose();
}
public void TestFixtureSetUp()
{
_cluster = new CouchbaseCluster();
using (var bucket = _cluster.OpenBucket())
{
bucket.Upsert(TestKeys.KeyWithInt32Value.Key, TestKeys.KeyWithInt32Value.Value);
}
}
public void When_Disposing_StreamingProvider_Worker_Thread_Does_Not_Hang_No_Buckets_Open()
{
//remove CCCP provider because we want to bootstrap off of the StreamingProvider
var cccp = _clusterManager.ConfigProviders.Find(x => x is CarrierPublicationProvider);
_clusterManager.ConfigProviders.Remove(cccp);
var cluster = new CouchbaseCluster(_clientConfig, _clusterManager);
cluster.Dispose();
}
public void Set()
{
using (var cluster = new CouchbaseCluster())
{
using (var bucket = cluster.OpenBucket())
{
var key = string.Format("key{0}", 1);
var result = bucket.Upsert(key, 12);
Console.WriteLine(result.Value);
}
}
}
public void Get()
{
using (var cluster = new CouchbaseCluster())
{
using (var bucket = cluster.OpenBucket())
{
var key = string.Format("key{0}", 1);
var result = bucket.Get<int>(key);
Console.WriteLine(result.Value);
}
}
}
public void TestSetUp()
{
_counters = new TestCounters();
_mreConfig = new ManualResetEventSlim();
_cluster = new CouchbaseCluster(new MemcacheClientConfiguration()
{
TransportConnectTimerPeriod = Timeout.InfiniteTimeSpan
}, "Some.Bucket", new[] { new IPEndPoint(0, 0) });
_cluster.NodeAdded += _ => _counters.IncrementNodesAdded();
_cluster.NodeRemoved += _ => _counters.IncrementNodesRemoved();
_cluster.OnError += e => { _counters.IncrementErrors(); Console.Error.WriteLine(e.Message); Console.Error.WriteLine(e.StackTrace); };
_cluster.OnConfig += () => _mreConfig.Set();
}
private void LoadBaseConfig(string sectionName)
{
var config = ConfigurationManager.GetSection(sectionName) as CouchbaseClientSection;
if (config == null)
{
throw new NullReferenceException(
"Couchbase configuration cannot be null. Add it to App.Config file or pass a custom one via parameter.");
}
_bucket = config.Servers.Bucket;
_isDevMode = config.DocumentNameTransformer.Type == typeof(DevelopmentModeNameTransformer);
_cluster = new CouchbaseCluster(config);
}
public void SetUp()
{
_Client = CouchbaseClientFactory.CreateCouchbaseClient();
//TODO: uncomment this line when next NuGet (1.2.7) is pushed
//log4net.Config.XmlConfigurator.Configure();
var cluster = new CouchbaseCluster("couchbase");
var stream = File.Open(@"Data\\ThingViews.json", FileMode.Open);
cluster.CreateDesignDocument("default", "things", stream);
}
public void Test_UseSsl2()
{
var config = new ClientConfiguration
{
UseSsl = true
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
//all buckets opened with this configuration will use SSL
}
}
public void When_Try_Listing_Buckets_With_Invalid_Config_No_Exception_Is_Thrown_And_Return_Value_Is_False()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri(ConfigurationManager.AppSettings["CouchbaseServerUrl"] + "/doesnotexist/"));
config.Bucket = "default";
var server = new CouchbaseCluster(config);
Bucket[] buckets;
var result = server.TryListBuckets(out buckets);
Assert.That(result, Is.False);
}
public void When_Initialize_Called_With_AppConfig_Settings_Bucket_Can_Be_Opened()
{
using (var cluster = new CouchbaseCluster("couchbaseClients/couchbase"))
{
var bucket = cluster.OpenBucket();
Assert.AreEqual("default", bucket.Name);
var result = bucket.Upsert("testkey", "testvalue");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
var result2 = bucket.Get <string>("testkey");
Assert.IsTrue(result2.Success);
Assert.AreEqual(ResponseStatus.Success, result2.Status);
Assert.AreEqual("testvalue", result2.Value);
}
}
public void Test_ClientConnection_With_Ssl()
{
var bootstrapUrl = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration
{
UseSsl = true,
Servers = new List<Uri>
{
new Uri(bootstrapUrl)
}};
config.Initialize();
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
Assert.IsNotNull(bucket);
}
}
public void TestSetUp()
{
_counters = new TestCounters();
_mreConfig = new ManualResetEventSlim();
var config = new MemcacheClientConfiguration()
{
TransportConnectTimerPeriod = Timeout.InfiniteTimeSpan,
NodeFactory = (ipendpoint, _) => new NodeMock {
EndPoint = ipendpoint, DefaultResponse = Status.NoError
},
};
_cluster = new CouchbaseCluster(config, "Some.Bucket", TimeSpan.FromSeconds(30), new[] { new IPEndPoint(0, 0) });
_cluster.NodeAdded += _ => _counters.IncrementNodesAdded();
_cluster.NodeRemoved += _ => _counters.IncrementNodesRemoved();
_cluster.OnError += e => { _counters.IncrementErrors(); Console.Error.WriteLine(e.Message); Console.Error.WriteLine(e.StackTrace); };
_cluster.OnConfig += () => _mreConfig.Set();
}
public void Test_UseSsl3()
{
var config = new ClientConfiguration
{
BucketConfigs = new Dictionary <string, BucketConfiguration>
{
{ "customers", new BucketConfiguration
{
UseSsl = true
} }
}
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket("customers"))
{
//only the customers bucket will use SSL
}
}
public void When_UseSsl_Is_False_At_Config_Level_Ssl_Is_Not_Used()
{
var remoteHost = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration()
{
UseSsl = false,
Servers = new List <Uri>
{
new Uri(remoteHost)
}
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
//all buckets opened with this configuration will not use SSL
Assert.IsFalse(bucket.IsSecure);
}
}
public void Test_ClientConnection_With_Ssl()
{
var config = new ClientConfiguration
{
UseSsl = true,
Servers = new List <Uri>
{
new Uri("http://localhost:8091/pools")
}
};
config.Initialize();
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
Assert.IsNotNull(bucket);
}
}
/// <summary>
/// Construct a sink posting to the specified database.
/// </summary>
/// <param name="couchbaseUriList">A list of a Couchbase database servers.</param>
/// <param name="bucketName">The bucket to store batches in.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
public CouchbaseSink(string[] couchbaseUriList, string bucketName, int batchPostingLimit, TimeSpan period, IFormatProvider formatProvider)
: base(batchPostingLimit, period)
{
if (couchbaseUriList == null)
{
throw new ArgumentNullException("couchbaseUriList");
}
if (couchbaseUriList.Length == 0)
{
throw new ArgumentException("couchbaseUriList");
}
if (couchbaseUriList[0] == null)
{
throw new ArgumentNullException("couchbaseUriList");
}
if (bucketName == null)
{
throw new ArgumentNullException("bucketName");
}
var config = new global::Couchbase.Configuration.CouchbaseClientConfiguration();
foreach (var uri in couchbaseUriList)
{
config.Urls.Add(new Uri(uri));
}
config.Bucket = bucketName;
var cluster = new CouchbaseCluster(config);
Bucket bucket;
if (!cluster.TryGetBucket(bucketName, out bucket))
{
throw new InvalidOperationException("bucket '" + bucketName + "' does not exist");
}
_couchbaseClient = new global::Couchbase.CouchbaseClient(config);
_formatProvider = formatProvider;
}
public void When_InValid_Credentials_Provided_Bucket_Created_UnSuccesfully()
{
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 CouchbaseCluster(config);
var bucket = cluster.OpenBucket("authenticated", "secretw");
cluster.CloseBucket(bucket);
Assert.IsNotNull(bucket);
}
public void Test_ClientConnection_With_Ssl()
{
var bootstrapUrl = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration
{
UseSsl = true,
Servers = new List <Uri>
{
new Uri(bootstrapUrl)
}
};
config.Initialize();
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
Assert.IsNotNull(bucket);
}
}
public void Test_Dispose_On_Many_Threads()
{
using (var cluster = new CouchbaseCluster())
{
Random random = new Random(100);
int n = 100;
var options = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
Parallel.For(0, n, options, i =>
{
try
{
using (IBucket bucket = cluster.OpenBucket())
{
var key = "key_" + i;
var set = bucket.Upsert(key, i);
Console.WriteLine("Inserted {0}: {1} Thread: {2}", key, set.Success,
Thread.CurrentThread.ManagedThreadId);
var get = bucket.Get <int>(key);
Console.WriteLine("Getting {0} - {1}: {2} Thread: {3}", key, get.Value, get.Success,
Thread.CurrentThread.ManagedThreadId);
var sleep = random.Next(0, 100);
Console.WriteLine("Sleep for {0}ms", sleep);
Thread.Sleep(sleep);
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
Console.WriteLine(e);
return(true);
});
}
});
}
}
public void When_Valid_Credentials_Provided_Bucket_Created_Succesfully()
{
var config = new ClientConfiguration
{
BucketConfigs = new Dictionary<string, BucketConfiguration>
{
{
"authenticated",
new BucketConfiguration
{
BucketName = "authenticated"
}
}
}
};
var cluster = new CouchbaseCluster(config);
var bucket = cluster.OpenBucket("authenticated", "secret");
cluster.CloseBucket(bucket);
Assert.IsNotNull(bucket);
cluster.CloseBucket(bucket);
}
public void When_Mutation_Happens_Observe_Fails()
{
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("When_Mutation_Happens_Observe_Fails");
cas = bucket.Insert("When_Mutation_Happens_Observe_Fails", "").Cas;
bucket.Upsert("When_Mutation_Happens_Observe_Fails", "");
}
}
var observer = new KeyObserver(configInfo, 10, 500);
var constraintReached = observer.ObserveAdd("When_Mutation_Happens_Observe_Fails", cas, ReplicateTo.One, PersistTo.One);
Assert.IsFalse(constraintReached);
}
public void When_Valid_Credentials_Provided_Bucket_Created_Succesfully()
{
var config = new ClientConfiguration
{
BucketConfigs = new Dictionary <string, BucketConfiguration>
{
{
"authenticated",
new BucketConfiguration
{
BucketName = "authenticated"
}
}
}
};
var cluster = new CouchbaseCluster(config);
var bucket = cluster.OpenBucket("authenticated", "secret");
cluster.CloseBucket(bucket);
Assert.IsNotNull(bucket);
cluster.CloseBucket(bucket);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_cluster = new CouchbaseCluster();
}
public void Test_Programmatic_Config_Construction_Using_Custom_Settings()
{
using (var cluster = new CouchbaseCluster("couchbaseClients/couchbase_1"))
{
var configuration = cluster.Configuration;
Assert.AreEqual(443, configuration.SslPort);
Assert.AreEqual(8095, configuration.MgmtPort);
Assert.AreEqual(8094, configuration.ApiPort);
Assert.AreEqual(18099, configuration.HttpsMgmtPort);
Assert.AreEqual(18098, configuration.HttpsApiPort);
Assert.AreEqual(11219, configuration.DirectPort);
Assert.IsTrue(configuration.UseSsl);
var server = configuration.Servers.First();
Assert.AreEqual(new Uri("https://localhost2:18099/pools"), server);
var bucketKvp = configuration.BucketConfigs.First();
Assert.AreEqual("testbucket", bucketKvp.Key);
Assert.AreEqual("shhh!", bucketKvp.Value.Password);
Assert.IsTrue(bucketKvp.Value.UseSsl);
Assert.AreEqual("testbucket", bucketKvp.Value.BucketName);
var poolConfiguration = bucketKvp.Value.PoolConfiguration;
Assert.IsTrue(poolConfiguration.UseSsl);
Assert.AreEqual(10, poolConfiguration.MaxSize);
Assert.AreEqual(5, poolConfiguration.MinSize);
Assert.AreEqual(5000, poolConfiguration.WaitTimeout);
Assert.AreEqual(3000, poolConfiguration.ShutdownTimeout);
}
}
public void Test_Dispose_On_Many_Threads()
{
using (var cluster = new CouchbaseCluster())
{
Random random = new Random(100);
int n = 100;
var options = new ParallelOptions {MaxDegreeOfParallelism = 4};
Parallel.For(0, n, options, i =>
{
try
{
using (IBucket bucket = cluster.OpenBucket())
{
var key = "key_" + i;
var set = bucket.Upsert(key, i);
Console.WriteLine("Inserted {0}: {1} Thread: {2}", key, set.Success,
Thread.CurrentThread.ManagedThreadId);
var get = bucket.Get<int>(key);
Console.WriteLine("Getting {0} - {1}: {2} Thread: {3}", key, get.Value, get.Success,
Thread.CurrentThread.ManagedThreadId);
var sleep = random.Next(0, 100);
Console.WriteLine("Sleep for {0}ms", sleep);
Thread.Sleep(sleep);
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
Console.WriteLine(e);
return true;
});
}
});
}
}
public void Test_Programmatic_Config_Construction_Using_Default_Settings()
{
var cluster = new CouchbaseCluster("couchbaseClients/couchbase");
var configuration = cluster.Configuration;
Assert.AreEqual(11207, configuration.SslPort);
Assert.AreEqual(8091, configuration.MgmtPort);
Assert.AreEqual(8092, configuration.ApiPort);
Assert.AreEqual(18091, configuration.HttpsMgmtPort);
Assert.AreEqual(18092, configuration.HttpsApiPort);
Assert.AreEqual(11210, configuration.DirectPort);
Assert.IsFalse(configuration.UseSsl);
var server = configuration.Servers.First();
Assert.AreEqual(new Uri("http://localhost:8091/pools"), server);
var bucketKvp = configuration.BucketConfigs.First();
Assert.AreEqual("default", bucketKvp.Key);
Assert.AreEqual(string.Empty, bucketKvp.Value.Password);
Assert.IsFalse(bucketKvp.Value.UseSsl);
Assert.AreEqual("default", bucketKvp.Value.BucketName);
var poolConfiguration = bucketKvp.Value.PoolConfiguration;
Assert.IsFalse(poolConfiguration.UseSsl);
Assert.AreEqual(2, poolConfiguration.MaxSize);
Assert.AreEqual(1, poolConfiguration.MinSize);
Assert.AreEqual(2500, poolConfiguration.WaitTimeout);
Assert.AreEqual(10000, poolConfiguration.ShutdownTimeout);
}
public void Setup()
{
_cluster = new CouchbaseCluster("localhost", 16, 1, 1);
Thread.Sleep(1000);
}
public void Test_Timed_Execution_Parallel_Client()
{
var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
var n = 1000;//set to a higher # if needed
using (var cluster = new CouchbaseCluster())
{
using (var bucket = cluster.OpenBucket())
{
using (new OperationTimer())
{
var temp = bucket;
Parallel.For(0, n, options, i =>
{
var key = string.Format("key{0}", i);
var result = temp.Upsert(key, i);
Assert.IsTrue(result.Success);
var result1 = temp.Get<int>(key);
Assert.IsTrue(result1.Success);
Assert.AreEqual(i, result1.Value);
});
}
}
}
}
public void Setup()
{
_target = new CouchbaseCluster("localhost", 16, 1, 1);
}
public void TestFixtureSetUp()
{
_cluster = new CouchbaseCluster();
}
public void When_UseSsl_Is_False_At_Config_Level_Ssl_Is_Not_Used()
{
var remoteHost = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration()
{
UseSsl = false,
Servers = new List<Uri>
{
new Uri(remoteHost)
}
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket())
{
//all buckets opened with this configuration will not use SSL
Assert.IsFalse(bucket.IsSecure);
}
}
public void When_Initialize_Called_With_AppConfig_Settings_Bucket_Can_Be_Opened()
{
using (var cluster = new CouchbaseCluster("couchbaseClients/couchbase"))
{
var bucket = cluster.OpenBucket();
Assert.AreEqual("default", bucket.Name);
var result = bucket.Upsert("testkey", "testvalue");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
var result2 = bucket.Get<string>("testkey");
Assert.IsTrue(result2.Success);
Assert.AreEqual(ResponseStatus.Success, result2.Status);
Assert.AreEqual("testvalue", result2.Value);
}
}
public void When_UseSsl_Is_False_At_Bucket_Level_Ssl_Is_Not_Used()
{
var remoteHost = ConfigurationManager.AppSettings["bootstrapUrl"];
var config = new ClientConfiguration
{
BucketConfigs = new Dictionary<string, BucketConfiguration>
{
{"beer-sample", new BucketConfiguration
{
UseSsl = false
}}
},
Servers = new List<Uri>
{
new Uri(remoteHost)
}
};
var cluster = new CouchbaseCluster(config);
using (var bucket = cluster.OpenBucket("beer-sample"))
{
//only the customers bucket will not use SSL
Assert.IsFalse(bucket.IsSecure);
}
}
