public User ProjectAddUser(string username, string projectId)
{
var userDocument = _bucket.Get <User>(username);
if (!userDocument.Success)
{
throw new ArgumentException("The user does not exists");
}
var projectDocument = _bucket.Get <Project>(projectId);
if (!projectDocument.Success)
{
throw new ArgumentException("The project does not exist");
}
var project = projectDocument.Value;
if (!project.Users.Contains(username))
{
project.Users.Add(username);
}
_bucket.Upsert(new Document <Project>
{
Id = projectDocument.Id,
Content = project
});
return(userDocument.Value);
}
/// <summary>
/// Function to add a new item to the output cache. If there is already a value in the cache for the
/// specified key, the provider must return that value and must not store the data passed by using the Add method
/// parameters. The Add method stores the data if it is not already in the cache and returns the value
/// read from the cache if it already exists.
/// </summary>
/// <param name="key">A unique identifier for entry</param>
/// <param name="entry">The content to add to the output cache</param>
/// <param name="utcExpiry">The time and date on which the cached entry expires</param>
/// <returns>
/// The value that identifies what was in the cache, or the value that was just added if it was not
/// </returns>
public override object Add(
string key,
object entry,
DateTime utcExpiry)
{
// Fix the key
key = SanitizeKey(key);
// We should only store the item if it's not in the cache. So try to add it and if it
// succeeds, return the value we just stored
var expiration = ToExpiration(utcExpiry);
if (_bucket.Insert(key, Serialize(entry), expiration).Success)
{
return(entry);
}
// If it's in the cache we should return it
var retval = DeSerialize(_bucket.Get <byte[]>(key).Value);
// If the item got evicted between the Add and the Get (very rare) we store it anyway,
// but this time with Set to make sure it always gets into the cache
if (retval == null)
{
_bucket.Insert(key, entry, expiration);
retval = entry;
}
// Return the value read from the cache if it was present
return(retval);
}
public void Test_Dequeue()
{
var key = "CouchbaseQueueTests.Test_Dequeue";
_bucket.Remove(key);
var queue = new CouchbaseQueue <Poco>(_bucket, key);
queue.Enqueue(new Poco {
Name = "pcoco1"
});
queue.Enqueue(new Poco {
Name = "pcoco2"
});
queue.Enqueue(new Poco {
Name = "pcoco3"
});
var item = queue.Dequeue();
Assert.AreEqual("pcoco1", item.Name);
var items = _bucket.Get <List <Poco> >(key).Value;
Assert.AreEqual(2, items.Count);
}
public void Test_Get()
{
var key = "thekey";
var value = "thevalue";
_bucket.Remove(key);
_bucket.Insert(key, value);
var result = _bucket.Get <string>(key);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public T Update <T>(long id, T data) where T : BaseModel
{
var result = _bucket.Get <T>(id.ToString()).Value;
result = data;
var doc = new Document <T> {
Id = data.Id.ToString(), Content = data
};
_bucket.Insert(doc);
return(data);
}
private void Rollback(IOperationResult <Barn> source, IOperationResult <Barn> destination, int amountToTransfer, IDocumentResult <TransactionRecord> transaction, Exception ex)
{
Console.WriteLine("Handling a rollback");
Console.ReadLine();
var transactionRecord = _bucket.Get <TransactionRecord>(transaction.Id);
switch (transactionRecord.Value.State)
{
case TransactionStates.Committed:
case TransactionStates.Pending:
// #1 -> switch to 'cancelling' state
// tag::cancelling[]
UpdateWithCas <TransactionRecord>(transaction.Id, x => x.State = TransactionStates.Cancelling, transactionRecord.Cas);
// end::cancelling[]
Console.WriteLine($"Switch transaction to {TransactionStates.Cancelling}");
Console.ReadLine();
// #2 -> revent changes if they were applied
// tag::reventbarn1[]
UpdateWithCas <Barn>(source.Id, x =>
{
if (x.Transaction != null)
{
x.Chickens += transactionRecord.Value.Amount;
x.Transaction = null;
}
});
// end::reventbarn1[]
Console.WriteLine($"If necessary: Add {amountToTransfer} to {source.Value.Name} (and remove transaction {transaction.Id})");
Console.ReadLine();
// tag::reventbarn2[]
UpdateWithCas <Barn>(destination.Id, x =>
{
if (x.Transaction != null)
{
x.Chickens -= transactionRecord.Value.Amount;
x.Transaction = null;
}
});
// end::reventbarn2[]
Console.WriteLine($"If necessary: Remove {amountToTransfer} from {destination.Value.Name} (and remove transaction {transaction.Id})");
Console.ReadLine();
// #3 -> switch to cancelled state
// tag::cancelled[]
UpdateWithCas <TransactionRecord>(transaction.Id, x => x.State = TransactionStates.Cancelled);
// end::cancelled[]
Console.WriteLine($"Switch transaction to {TransactionStates.Cancelled}");
Console.ReadLine();
break;
}
}
public void RetrieveAndUpdate()
{
var key = "SampleApp-" + DateTime.Now.Ticks;
var data = new Data
{
Number = 42,
Text = "Life, the Universe, and Everything",
Date = DateTime.UtcNow
};
// Get non-existent document.
// Note that it's enough to check the Status property,
// We're only checking all three to show they exist.
var notFound = _bucket.Get <dynamic>(key);
if (!notFound.Success &&
notFound.Status == ResponseStatus.KeyNotFound)
{
Console.WriteLine("Document doesn't exist!");
}
// Prepare a JSON document value
_bucket.Upsert(key, data);
// Get a JSON document string value
var docResult = _bucket.Get <Data>(key);
Console.WriteLine("Found: " + docResult.Value);
// Change the data
data.Number++;
data.Text = "What's 7 * 6 + 1?";
data.Date = DateTime.UtcNow;
// Try to insert under the same key should fail
var insertResult = _bucket.Insert(key, data);
if (!insertResult.Success)
{
Console.WriteLine("Inserting under an existing key fails as expected.");
}
// Replace existing document
// Note this only works if the key already exists
var replaceResult = _bucket.Replace(key, data);
// Check that the data was updated
var res = _bucket.Remove(key);
Console.WriteLine("Got: " + res.Status);
}
/// <summary>
/// Loads a session state item from the bucket. This function is publicly accessible
/// so that you have direct access to session data from another application if necesssary.
/// We use this so our front end code can determine if an employee is logged into our back
/// end application to give them special permissions, without the session data being actually common
/// between the two applications.
/// </summary>
/// <param name="headerPrefix">Prefix for the header data</param>
/// <param name="dataPrefix">Prefix for the real data</param>
/// <param name="bucket">Couchbase bucket to load from</param>
/// <param name="id">Session ID</param>
/// <param name="metaOnly">True to load only meta data</param>
/// <returns>Session store item read, null on failure</returns>
public static SessionStateItem Load(
string headerPrefix,
string dataPrefix,
IBucket bucket,
string id,
bool metaOnly)
{
// Read the header value from Couchbase
var header = bucket.Get <byte[]>(CouchbaseSessionStateProvider.HeaderPrefix + id);
if (header.Status != ResponseStatus.Success)
{
return(null);
}
// Deserialize the header values
SessionStateItem entry;
using (var ms = new MemoryStream(header.Value))
{
entry = LoadHeader(ms);
}
entry.HeadCas = header.Cas;
// Bail early if we are only loading the meta data
if (metaOnly)
{
return(entry);
}
// Read the data for the item from Couchbase
var data = bucket.Get <byte[]>(CouchbaseSessionStateProvider.DataPrefix + id);
if (data.Value == null)
{
return(null);
}
entry.DataCas = data.Cas;
// Deserialize the data
using (var ms = new MemoryStream(data.Value))
{
using (var br = new BinaryReader(ms))
{
entry.Data = SessionStateItemCollection.Deserialize(br);
}
}
// Return the session entry
return(entry);
}
/// <summary>
/// Gets the set.
/// </summary>
/// <returns></returns>
protected HashSet <TValue> GetSet()
{
var get = Bucket.Get <HashSet <TValue> >(Key);
if (!get.Success)
{
if (get.Exception != null)
{
throw get.Exception;
}
throw new InvalidOperationException(get.Status.ToString());
}
return(get.Value);
}
public IActionResult GetCategories(string userId)
{
var u = _bucket.Get <User>(userId);
User user = u.Value;
if (user != null)
{
var q = _bucket.Get <User>(user.UserId);
List <Category> categorylist = new List <Category>();
categorylist = q.Value.Categories;
return(Ok(categorylist));
}
return(BadRequest());
}
public static Dictionary <string, T> GetMultiJson <T>(this IBucket client, IList <string> keys) where T : class
{
Dictionary <string, T> result = new Dictionary <string, T>();
if (keys.Count > 0)
{
// TODO: Use the async overloads that take a list of keys for multi-operations.
var dicObj = client.Get <dynamic>(keys);
foreach (var item in dicObj)
{
if (item.Value.Success && !string.IsNullOrEmpty(item.Value.Value))
{
var json = item.Value.Value.ToString();
if (!string.IsNullOrEmpty(json))
{
var obj = JsonConvert.DeserializeObject <T>(json);
if (!result.ContainsKey(item.Key))
{
result.Add(item.Key, obj);
}
}
}
}
}
return(result);
}
/// <summary>
/// Gets a <c>CacheItem</c> for the specified key.
/// </summary>
/// <param name="key">The key being used to identify the item within the cache.</param>
/// <param name="region">The cache region.</param>
/// <returns>The <c>CacheItem</c>.</returns>
protected override CacheItem <TCacheValue> GetCacheItemInternal(string key, string region)
{
var fullkey = GetKey(key, region);
var result = _bucket.Get <CacheItem <TCacheValue> >(fullkey);
if (result.Success)
{
var cacheItem = result.Value;
if (cacheItem.Value is JToken)
{
var value = cacheItem.Value as JToken;
cacheItem = cacheItem.WithValue((TCacheValue)value.ToObject(cacheItem.ValueType));
}
// TODO: test sliding
// extend sliding expiration
if (cacheItem.ExpirationMode == ExpirationMode.Sliding)
{
_bucket.Touch(fullkey, cacheItem.ExpirationTimeout);
}
return(cacheItem);
}
return(null);
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>
/// An enumerator that can be used to iterate through the collection.
/// </returns>
public IEnumerator <T> GetEnumerator()
{
// ReSharper disable once InconsistentlySynchronizedField
var get = Bucket.Get <List <T> >(Key);
if (!get.Success)
{
if (get.Exception != null)
{
throw get.Exception;
}
throw new InvalidOperationException(get.Status.ToString());
}
return(get.Value.GetEnumerator());
}
public T Get(string id)
{
var key = CreateKey(id);
var result = _bucket.Get <T>(key);
return(!result.Success ? null : result.Value);
}
public Dictionary <string, MagicDoc> GetMagicTen()
{
var dict = new Dictionary <string, MagicDoc>();
for (int i = 0; i < 10; i++)
{
var key = "doc" + i;
var magicDoc = new MagicDoc
{
Active = _bucket.Get <dynamic>(key),
Replica = _bucket.GetFromReplica <dynamic>(key)
};
dict.Add(key, magicDoc);
}
return(dict);
}
public Profile GetProfileByKey(string key)
{
var profile = _bucket.Get <Profile>(key).Value;
profile.Id = key;
return(profile);
}
protected override Task <WorkloadOperationResult> OnExecuteStep(IBucket bucket, int workloadIndex, int docIndex, Func <TimeSpan> getTiming)
{
var key = DocKeyGenerator.Generate(workloadIndex, docIndex);
var randomKey = DocKeyGenerator.Generate(workloadIndex, docIndex);
if (UseSync)
{
var upsertResult = bucket.Upsert(key, SampleDocument);
var getResult = bucket.Get <string>(randomKey);
return(Task.FromResult(
new WorkloadOperationResult(upsertResult.Success && getResult.Success, GetMessage(upsertResult, getResult), getTiming())
));
}
return(Task.WhenAll(
bucket.UpsertAsync(key, SampleDocument), bucket.GetAsync <string>(randomKey)
)
.ContinueWith(tasks => new WorkloadOperationResult(tasks.Result[0].Success && tasks.Result[1].Success,
GetMessage(tasks.Result[0], tasks.Result[1]),
getTiming())
{
DocSize = GetDocSize(tasks.Result[1]) + SampleDocument.Length
}));
}
static void ThreadPoolInsert(IBucket bucket, int n)
{
for (int i = 0; i < n; i++)
{
int i1 = i;
Task.Factory.StartNew(() =>
{
var key = "key" + i1;
var value = "value" + i1;
/*var result = bucket.Upsert(key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);*/
var result2 = bucket.Get<string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result2.Message);
}
/*}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}*/
});
}
}
static void SynchronousInsert(IBucket bucket, int n)
{
for (int i = 0; i < n; i++)
{
var key = "key" + i;
var value = "value" + i;
var result = bucket.Upsert(key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = bucket.Get <string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result2.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
}
}
static void SynchronousInsert(IBucket bucket, int n)
{
for (int i = 0; i < n; i++)
{
var key = "key" + i;
var value = "value" + i;
var result = bucket.Upsert(key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = bucket.Get<string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result2.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
}
}
public void Test_Dispose_On_Many_Threads()
{
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);
}
Thread.Sleep(random.Next(0, 100));
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
Console.WriteLine(e);
return(true);
});
}
});
}
static void ThreadPoolInsert(IBucket bucket, int n)
{
for (int i = 0; i < n; i++)
{
int i1 = i;
Task.Factory.StartNew(() =>
{
var key = "key" + i1;
var value = "value" + i1;
/*var result = bucket.Upsert(key, value);
*
* if (result.Success)
* {
* Console.WriteLine("Write Key: {0} - Value: {1}", key, value);*/
var result2 = bucket.Get <string>(key);
if (result2.Success)
{
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result2.Message);
}
/*}
* else
* {
* Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
* }*/
});
}
}
private static string[] MergeSchema(string[] newHeaders)
{
List <string> headers = new List <string>();
var res = _bucket.Get <string>("schema");
if (res.Success && res.Value != null)
{
var schema = JsonConvert.DeserializeObject <List <string> >(res.Value);
schema.ForEach(s =>
{
if (!headers.Contains(s))
{
headers.Add(s);
}
});
}
newHeaders.ToList().ForEach(h =>
{
if (!headers.Contains(h))
{
headers.Add(h);
}
});
headers.Sort();
return(headers.Where(h => !string.IsNullOrEmpty(h)).ToArray());
}
public User FindById(string id)
{
var result = _bucket.Get <User>(id);
var user = result.Value;
user.Id = id;
return(user);
}
private static void PessimisticLockingExample1(IBucket bucket)
{
// tag::PessimisticLockingExample1[]
// create initial document
bucket.Upsert("myshield", new { defenseLevel = 1, name = "Mirror Shield" });
// document is retrieved and locked by A
var shieldAResult = bucket.GetAndLock <dynamic>("myshield", TimeSpan.FromMilliseconds(30000));
var shieldA = shieldAResult.Value;
// B attempts to get and lock it as well
var shieldBResult = bucket.GetAndLock <dynamic>("myshield", TimeSpan.FromMilliseconds(30000));
if (!shieldBResult.Success)
{
Console.WriteLine("B couldn't establish a lock, trying a plain Get");
shieldBResult = bucket.Get <dynamic>("myshield");
}
// B tries to make a change, despite not having a lock
Console.WriteLine("'B' is updating the document");
var shieldB = shieldBResult.Value;
shieldB.defenseLevel = 3;
IOperationResult bResult = bucket.Replace("myshield", shieldB);
if (!bResult.Success)
{
Console.WriteLine($"B was unable to make a change: {bResult.Message}");
Console.WriteLine();
}
// A can make the change, but MUST use the CAS value
shieldA.defenseLevel = 2;
IOperationResult aResult = bucket.Replace("myshield", shieldA);
if (!aResult.Success)
{
Console.WriteLine($"A tried to make a change, but forgot to use a CAS value: {aResult.Message}");
Console.WriteLine();
Console.WriteLine("Trying again with CAS this time");
aResult = bucket.Replace("myshield", shieldA, shieldAResult.Cas);
if (aResult.Success)
{
Console.WriteLine("Success!");
}
}
// now, the document is unlocked
// so B can try again
bResult = bucket.Replace("myshield", shieldB);
if (bResult.Success)
{
Console.WriteLine($"B was able to make a change.");
}
// end::PessimisticLockingExample1[]
}
static void Main(string[] args)
{
// tag::cluster[]
var clientConfig = new ClientConfiguration
{
Servers = new List <Uri>
{
new Uri("http://172.17.0.2"),
new Uri("http://172.17.0.3"),
new Uri("http://172.17.0.4")
}
};
var cluster = new Cluster(clientConfig);
var credentials = new PasswordAuthenticator("myuser", "password");
cluster.Authenticate(credentials);
_bucket = cluster.OpenBucket("mybucket");
// end::cluster[]
// tag::createdocs[]
var docKeys = new List <string>();
for (var i = 0; i < numDocuments; i++)
{
var key = "documentKey" + i;
docKeys.Add(key);
_bucket.Upsert(key, new { name = "Document" + i });
}
// end::createdocs[]
// tag::mainloop[]
var iteration = 0;
while (true)
{
Console.WriteLine($"Getting {numDocuments} documents [{iteration++}]");
foreach (var docKey in docKeys)
{
var result = _bucket.Get <dynamic>(docKey);
if (terse)
{
ShowResultTerse(result, docKey);
}
else
{
ShowResult(result, docKey);
}
}
Console.WriteLine();
Thread.Sleep(2000);
}
// end::mainloop[]
}
public ActionResult KeyValueExample()
{
var key = Guid.NewGuid().ToString();
_bucket.Insert(key, FooBar.Generate());
var foobar = _bucket.Get <FooBar>(key).Value;
ViewBag.Key = key;
return(View(foobar));
}
// just to show that the bucket is being injected properly
// tag::About[]
public IActionResult About()
{
// get the route document for Columbus to Chicago (United)
var route = _bucket.Get <dynamic>("route_56027").Value;
// display the equipment number of the route
ViewData["Message"] = "CMH to ORD - " + route.equipment;
return(View());
}
public IActionResult Point([FromBody] PointSearch point)
{
var query = new GeoDistanceQuery();
query.Latitude(point.Latitude);
query.Longitude(point.Longitude);
query.Distance(point.DistanceWithUnits);
var searchParams = new SearchParams()
// .Fields("geo", "name") // omitting because of bug NCBC-1651
.Limit(10)
.Timeout(TimeSpan.FromMilliseconds(10000));
var searchQuery = new SearchQuery
{
Query = query,
Index = "mygeoindex",
SearchParams = searchParams
};
var results = _bucket.Query(searchQuery);
var list = new List <GeoSearchResult>();
foreach (var hit in results.Hits)
{
// *** this part shouldn't be necessary
// the geo and name should come with the search results
// but there's an SDK bug NCBC-1651
var doc = _bucket.Get <dynamic>(hit.Id).Value;
// ****************
list.Add(new GeoSearchResult
{
Latitude = doc.geo.lat,
Longitude = doc.geo.lon,
InfoWindow = new InfoWindow
{
Content = doc.name + "<br />" +
doc.city + ", " +
doc.state + " " +
doc.country
}
});
}
return(Ok(list));
}
/// <summary>
/// Gets the dictionary document.
/// </summary>
/// <returns></returns>
protected virtual IDictionary <TKey, TValue> GetDictionary()
{
var get = Bucket.Get <IDictionary <TKey, TValue> >(Key);
if (!get.Success && get.Exception != null)
{
throw get.Exception;
}
return(get.Value);
}
protected T Get(Guid id)
{
var result = _bucket.Get <T>(CreateKey(id));
if (!result.Success)
{
throw result.Exception;
}
return(result.Value);
}
private void LoadSchema()
{
Task.Run(() =>
{
var schema = _bucket.Get <string>("schema");
if (schema != null && schema.Success)
{
Fields = new List <string>(JsonConvert.DeserializeObject <string[]>(schema.Value));
}
});
}
/// <summary>
/// Loads a session state item from the bucket. This function is publicly accessible
/// so that you have direct access to session data from another application if necesssary.
/// We use this so our front end code can determine if an employee is logged into our back
/// end application to give them special permissions, without the session data being actually common
/// between the two applications.
/// </summary>
/// <param name="headerPrefix">Prefix for the header data</param>
/// <param name="dataPrefix">Prefix for the real data</param>
/// <param name="bucket">Couchbase bucket to load from</param>
/// <param name="id">Session ID</param>
/// <param name="metaOnly">True to load only meta data</param>
/// <returns>Session store item read, null on failure</returns>
public static SessionStateItem Load(
string headerPrefix,
string dataPrefix,
IBucket bucket,
string id,
bool metaOnly)
{
// Read the header value from Couchbase
var header = bucket.Get<byte[]>(CouchbaseSessionStateProvider.HeaderPrefix + id);
if (header.Status != ResponseStatus.Success)
{
return null;
}
// Deserialize the header values
SessionStateItem entry;
using (var ms = new MemoryStream(header.Value))
{
entry = LoadHeader(ms);
}
entry.HeadCas = header.Cas;
// Bail early if we are only loading the meta data
if (metaOnly)
{
return entry;
}
// Read the data for the item from Couchbase
var data = bucket.Get<byte[]>(CouchbaseSessionStateProvider.DataPrefix + id);
if (data.Value == null)
{
return null;
}
entry.DataCas = data.Cas;
// Deserialize the data
using (var ms = new MemoryStream(data.Value))
{
using (var br = new BinaryReader(ms))
{
entry.Data = SessionStateItemCollection.Deserialize(br);
}
}
// Return the session entry
return entry;
}
static void ParallerInsert(IBucket bucket, int n)
{
var options = new ParallelOptions {MaxDegreeOfParallelism = 4};
Parallel.For(0, n, options, i =>
{
var key = "key" + i;
int value = i;
var result = bucket.Upsert(key, value);
if (result.Success)
{
Console.WriteLine("Write Key: {0} - Value: {1}", key, value);
var result2 = bucket.Get<int>(key);
if (result2.Success)
{
if (result2.Value != value)
{
throw new Exception();
}
Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value);
}
else
{
Console.WriteLine("Read Error: {0} - {1}", key, result2.Message);
}
}
else
{
Console.WriteLine("Write Error: {0} - {1}", key, result.Message);
}
});
}
