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);
}
static void ParallerInsert(CouchbaseClient client, int n)
{
var options = new ParallelOptions {
MaxDegreeOfParallelism = 4
};
Parallel.For(0, n, options, i =>
{
var key = "key" + i;
var value = "value" + i;
var result = client.ExecuteStore(StoreMode.Set, key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = client.ExecuteGet <string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
});
}
static void SynchronousInsert(CouchbaseClient client, int n)
{
for (int i = 0; i < n; i++)
{
var key = "key" + i;
var value = "value" + i;
var result = client.ExecuteStore(StoreMode.Set, key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = client.ExecuteGet <string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
}
}
static void SynchronousInsert(CouchbaseClient client, int n)
{
for (int i = 0; i < n; i++)
{
var key = "key" + i;
var value = "value" + i;
var result = client.ExecuteStore(StoreMode.Set, key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = client.ExecuteGet<string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
}
}
static void ParallerInsert(CouchbaseClient client, int n)
{
var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
Parallel.For(0, n, options, i =>
{
var key = "key" + i;
var value = "value" + i;
var result = client.ExecuteStore(StoreMode.Set, key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = client.ExecuteGet<string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
});
}
/// <summary>
/// Gets a list of documents.
/// </summary>
/// <param name="documentKey">The document key.</param>
/// <param name="isRetry">if set to <c>true</c> [is retry].</param>
/// <returns>List{`0}.</returns>
public virtual List <T> GetListDocument(string documentKey, bool isRetry = false)
{
// make sure the document key is actually set
if (string.IsNullOrEmpty(documentKey))
{
return(null);
}
var getResult = Client.ExecuteGet <string>(documentKey);
// make sure the get operation succeeded
if (getResult.Success && getResult.HasValue)
{
var result = getResult.Value;
var docList = result.FromJson <List <T> >();
return(docList);
}
if (!isRetry)
{
LogCouchbaseOperationResult(documentKey, ToString(), "Failed to Get a list of documents", getResult);
GetListDocument(documentKey, true);
}
return(null);
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://*****:*****@cia.gov",
Password = "******",
Logins = 0
};
var user2 = new User
{
Username = "******",
Name = "Nicholas Brody",
Email = "*****@*****.**",
Password = "******",
Logins = 0
};
//store the user - ExecuteStore returns detailed error info, if any
var result1 = client.ExecuteStore(StoreMode.Set, user1.Email, user1);
if (!result1.Success)
{
Console.WriteLine("Store failed with message {0} and status code {1}", result1.Message, result1.StatusCode);
if (result1.Exception != null)
{
throw result1.Exception;
}
}
var result2 = client.ExecuteStore(StoreMode.Set, user2.Email, user2);
//same check as result1 would be useful
var doc = client.Get<User>(user1.Email);
Console.WriteLine(doc.Name);
//get doc with extended info
var result = client.ExecuteGet<User>(user1.Email);
//update login count
doc.Logins += 1;
//update document (ignore errors for lab)
client.ExecuteStore(StoreMode.Replace, user1.Email, doc);
doc = client.Get<User>(user1.Email);
Console.WriteLine("User {0} had {1} logins", doc.Name, doc.Logins);
client.Remove(user1.Email);
client.Remove(user2.Email);
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var post = new Post
{
Title = "Using Couchbase and .NET",
Body = "Start by getting the client at Nuget.",
Comments = new List <string> {
"Great post!"
},
Slug = "Using_Couchbase_Net"
};
client.ExecuteStore(StoreMode.Set, post.Slug, post);
var get1 = client.ExecuteGet <Post>(post.Slug);
var get2 = client.ExecuteGet <Post>(post.Slug);
Console.WriteLine("-------------------------------------");
Console.WriteLine("Set the Data, then Retrieve Two Copies of the Document");
Console.WriteLine();
Console.WriteLine("Both v1 and v2 are identical and have identical CAS [(cas1) {0} == {1} (cas2)]", get1.Cas, get2.Cas);
Console.WriteLine();
Console.WriteLine("-------------------------------------");
Console.WriteLine("Now We'll update the document which results in a new CAS");
Console.WriteLine();
get1.Value.Comments.Add("Wicked good post!");
var result = client.ExecuteStore(StoreMode.Set, post.Slug, get1.Value);
get1 = client.ExecuteGet <Post>(post.Slug);
Console.WriteLine("Now CAS has changed [(cas1) {0} != {1} (cas2)]", get1.Cas, get2.Cas);
Console.WriteLine();
Console.WriteLine("-------------------------------------");
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Root_Uri()
{
var config = ConfigSectionUtils.GetConfigSection<CouchbaseClientSection>("pools-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Heartbeat_Is_Not_Configured()
{
var config = ConfigSectionUtils.GetConfigSection<CouchbaseClientSection>("min-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void When_Getting_A_Key_From_A_Down_Node_No_Exception_Is_Thrown_And_Success_Is_False()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://doesnotexist:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var getResult = client.ExecuteGet("foo");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Message, Is.StringContaining(ClientErrors.FAILURE_NODE_NOT_FOUND));
}
private static void PerformGetSet(CouchbaseClient client, int i)
{
var key = string.Format("key{0}", i);
var document = string.Concat("{\"value\":\"", i, "\"}");
var set = client.ExecuteStore(StoreMode.Set, key, document);
Console.WriteLine("Set: {0} - {1} - {2}", key, set.Success, Thread.CurrentThread.ManagedThreadId);
var get = client.ExecuteGet <dynamic>(key);
Console.WriteLine("Get: {0} - {1} - {2}", key, get.Success, Thread.CurrentThread.ManagedThreadId);
}
public void Client_Operations_Succeed_When_Heartbeat_Is_Disabled()
{
var config = ConfigSectionUtils.GetConfigSection<CouchbaseClientSection>("heartbeat-config-off");
using (var client = new CouchbaseClient(config))
{
string key = TestUtils.GetUniqueKey(), value = TestUtils.GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
TestUtils.StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
TestUtils.GetAssertPass(getResult, value);
}
}
public void When_Getting_A_Key_From_A_Down_Node_No_Exception_Is_Thrown_And_Success_Is_False()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://doesnotexist:8091/pools/"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var getResult = client.ExecuteGet("foo");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Message, Is.StringContaining(ClientErrors.FAILURE_NODE_NOT_FOUND));
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Default_Root_Uri()
{
var config = ConfigSectionUtils.GetConfigSection<CouchbaseClientSection>("pools-default-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
Assert.That(storeResult.Success, Is.True, "Success was false");
Assert.That(storeResult.Message, Is.Null.Or.Empty, "Message was not empty");
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Root_Uri()
{
var config = ConfigSectionUtils.GetConfigSection <CouchbaseClientSection>("pools-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Heartbeat_Is_Disabled()
{
var config = ConfigSectionUtils.GetConfigSection <CouchbaseClientSection>("heartbeat-config-off");
using (var client = new CouchbaseClient(config))
{
string key = TestUtils.GetUniqueKey(), value = TestUtils.GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
TestUtils.StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
TestUtils.GetAssertPass(getResult, value);
}
}
public void When_Flushing_Bucket_Data_Are_Removed()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools/default"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var storeResult = client.ExecuteStore(StoreMode.Set, "SomeKey", "SomeValue");
Assert.That(storeResult.Success, Is.True);
var getResult = client.ExecuteGet <string>("SomeKey");
Assert.That(getResult.Success, Is.True);
Assert.That(getResult.Value, Is.StringMatching("SomeValue"));
_Cluster.FlushBucket("default");
getResult = client.ExecuteGet <string>("SomeKey");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Value, Is.Null);
}
public void Client_Operations_Succeed_When_Heartbeat_Is_Not_Configured()
{
var config = ConfigSectionUtils.GetConfigSection <CouchbaseClientSection>("min-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
//---------------------------------------------------------------------
public bool executeGet(string db_key, out string json_data)
{
Enyim.Caching.Memcached.Results.IGetOperationResult <string> ret = mCouchbaseClient.ExecuteGet <string>(db_key);
if (ret.Success)
{
json_data = ret.Value;
return(true);
}
else
{
json_data = null;
return(false);
}
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Root_Uri()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Default_Root_Uri()
{
var config = ConfigSectionUtils.GetConfigSection <CouchbaseClientSection>("pools-default-config");
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
Assert.That(storeResult.Success, Is.True, "Success was false");
Assert.That(storeResult.Message, Is.Null.Or.Empty, "Message was not empty");
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void Client_Operations_Succeed_When_Bootstrapping_To_Pools_Default_Root_Uri()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools/default"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
Assert.That(storeResult.Success, Is.True, "Success was false");
Assert.That(storeResult.Message, Is.Null.Or.Empty, "Message was not empty");
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
public void When_ExecuteGet_Is_Called_With_Invalid_Configuration_Errors_Are_Returned()
{
using (var client = new CouchbaseClient("bad-config"))
{
var keys = new[] { "exist1", "exist2" };
var results = client.ExecuteGet(keys);
Assert.AreEqual(keys.Count(), results.Count);
foreach (var result in results)
{
Assert.IsFalse(result.Value.HasValue);
Assert.IsFalse(result.Value.Success);
Assert.AreEqual(StatusCode.UnableToLocateNode.ToInt(), result.Value.StatusCode);
}
}
}
public void When_ExecuteGet_Is_Called_With_Invalid_Configuration_Errors_Are_Returned()
{
using (var client = new CouchbaseClient("bad-config"))
{
var keys = new[] { "exist1", "exist2" };
var results = client.ExecuteGet(keys);
Assert.AreEqual(keys.Count(), results.Count);
foreach (var result in results)
{
Assert.IsFalse(result.Value.HasValue);
Assert.IsFalse(result.Value.Success);
Assert.AreEqual(StatusCode.UnableToLocateNode.ToInt(), result.Value.StatusCode);
}
}
}
public void Client_Operations_Succeed_When_Heartbeat_Is_Configured()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://localhost:8091/pools"));
config.Bucket = "default";
config.HeartbeatMonitor = new HeartbeatMonitorElement();
config.HeartbeatMonitor.Enabled = true;
config.HeartbeatMonitor.Interval = 100;
config.HeartbeatMonitor.Uri = "http://localhost:8091/pools";
var client = new CouchbaseClient(config);
string key = GetUniqueKey(), value = GetRandomString();
var storeResult = client.ExecuteStore(StoreMode.Add, key, value);
StoreAssertPass(storeResult);
var getResult = client.ExecuteGet(key);
GetAssertPass(getResult, value);
}
/// <summary>
/// Gets a document from the database with the specified id.
/// </summary>
/// <param name="id">The id of the document to retrieve.</param>
/// <returns>The document with the specified id, or null if there was an error, or the id does not exist.</returns>
public override dynamic Get(string id)
{
if (!string.IsNullOrWhiteSpace(id))
{
var result = client.ExecuteGet(id);
if (result.Success)
{
return(result.Value);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public override void Run()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://*****:*****@cia.gov",
Password = "******",
Logins = 0
};
var user2 = new User
{
Username = "******",
Name = "Nicholas Brody",
Email = "*****@*****.**",
Password = "******",
Logins = 0
};
//store the user - ExecuteStore returns detailed error info, if any
var result1 = client.ExecuteStore(StoreMode.Set, user1.Email, user1);
if (!result1.Success)
{
Console.WriteLine("Store failed with message {0} and status code {1}", result1.Message, result1.StatusCode);
if (result1.Exception != null)
{
throw result1.Exception;
}
}
var result2 = client.ExecuteStore(StoreMode.Set, user2.Email, user2);
//same check as result1 would be useful
var doc = client.Get <User>(user1.Email);
Console.WriteLine(doc.Name);
//get doc with extended info
var result = client.ExecuteGet <User>(user1.Email);
//update login count
doc.Logins += 1;
//update document (ignore errors for lab)
client.ExecuteStore(StoreMode.Replace, user1.Email, doc);
doc = client.Get <User>(user1.Email);
Console.WriteLine("User {0} had {1} logins", doc.Name, doc.Logins);
client.Remove(user1.Email);
client.Remove(user2.Email);
}
public void When_Flushing_Bucket_Data_Are_Removed()
{
var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://10.0.0.79:8091/pools/default"));
config.Bucket = "default";
var client = new CouchbaseClient(config);
var storeResult = client.ExecuteStore(StoreMode.Set, "SomeKey", "SomeValue");
Assert.That(storeResult.Success, Is.True);
var getResult = client.ExecuteGet<string>("SomeKey");
Assert.That(getResult.Success, Is.True);
Assert.That(getResult.Value, Is.StringMatching("SomeValue"));
_Cluster.FlushBucket("default");
getResult = client.ExecuteGet<string>("SomeKey");
Assert.That(getResult.Success, Is.False);
Assert.That(getResult.Value, Is.Null);
}
public IGetOperationResult Get(string key)
{
return(_client.ExecuteGet(key));
}
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
}
);
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);
using (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);
}
}