private void PrepSearch()
{
_randomId = _random.Next();
var alyssaKey = _randomId + RiakSearchKey;
_alyssaRiakId = new RiakObjectId(BucketType, Bucket, alyssaKey);
var alyssaDoc = string.Format(RiakSearchDoc, _randomId);
var alanKey = _randomId + RiakSearchKey2;
var alanRiakId = new RiakObjectId(BucketType, Bucket, alanKey);
var alanDoc = string.Format(RiakSearchDoc2, _randomId);
Console.WriteLine("Using {0}, {1} for Yokozuna search keys", alyssaKey, alanKey);
Func<RiakResult<RiakObject>> put1 = () => Client.Put(new RiakObject(_alyssaRiakId, alyssaDoc.ToRiakString(),
RiakConstants.ContentTypes.ApplicationJson, RiakConstants.CharSets.Utf8));
var put1Result = put1.WaitUntil();
Func<RiakResult<RiakObject>> put2 = () => Client.Put(new RiakObject(alanRiakId, alanDoc.ToRiakString(),
RiakConstants.ContentTypes.ApplicationJson, RiakConstants.CharSets.Utf8));
var put2Result = put2.WaitUntil();
put1Result.IsSuccess.ShouldBeTrue(put1Result.ErrorMessage);
put2Result.IsSuccess.ShouldBeTrue(put2Result.ErrorMessage);
}
public void TestFlagOperations()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Maps, Bucket, key);
const string flagName = "Name";
var flagMapUpdate = new MapUpdate
{
flag_op = MapUpdate.FlagOp.DISABLE,
field = new MapField { name = Serializer.Invoke(flagName), type = MapField.MapFieldType.FLAG }
};
var updatedMap1 = Client.DtUpdateMap(id, Serializer, null, null, new List<MapUpdate> { flagMapUpdate });
Assert.True(updatedMap1.Result.IsSuccess, updatedMap1.Result.ErrorMessage);
var mapEntry = updatedMap1.Values.Single(s => s.Field.Name == flagName);
Assert.NotNull(mapEntry.FlagValue);
Assert.IsFalse(mapEntry.FlagValue.Value);
var flagMapUpdate2 = new MapUpdate
{
flag_op = MapUpdate.FlagOp.ENABLE,
field = new MapField { name = Serializer.Invoke(flagName), type = MapField.MapFieldType.FLAG }
};
var updatedMap2 = Client.DtUpdateMap(id, Serializer, updatedMap1.Context, null,
new List<MapUpdate> { flagMapUpdate2 });
Assert.True(updatedMap2.Result.IsSuccess, updatedMap2.Result.ErrorMessage);
mapEntry = updatedMap2.Values.Single(s => s.Field.Name == flagName);
Assert.NotNull(mapEntry.FlagValue);
Assert.IsTrue(mapEntry.FlagValue.Value);
}
public void TestKVOperations()
{
const string key = "bucket_type_test_key";
var id = new RiakObjectId(TestBucketType, TestBucket, key);
var obj = new RiakObject(id, Value);
// put
var putResult = Client.Put(obj, new RiakPutOptions().SetReturnBody(true).SetDw(3));
putResult.IsSuccess.ShouldBeTrue();
putResult.Value.BucketType.ShouldEqual(TestBucketType);
// get
var getResult = Client.Get(id);
getResult.IsSuccess.ShouldBeTrue();
getResult.Value.BucketType.ShouldEqual(TestBucketType);
// delete
var deleteResult = Client.Delete(id, new RiakDeleteOptions().SetDw(3));
deleteResult.IsSuccess.ShouldBeTrue();
// multiget
var ids = new List<RiakObjectId>();
for (int i = 0; i < 3; i++)
{
obj = new RiakObject(new RiakObjectId(TestBucketType, TestBucket, key + i), Value);
Client.Put(obj, new RiakPutOptions().SetReturnBody(true).SetDw(3));
ids.Add(obj.ToRiakObjectId());
}
var multiGetResult = Client.Get(ids).ToList();
multiGetResult.All(r => r.IsSuccess).ShouldBeTrue();
multiGetResult.All(r => r.Value.BucketType == TestBucketType).ShouldBeTrue();
}
private static void StoreData()
{
Console.WriteLine("[ChaosMonkeyApp] store thread starting");
IRiakClient client = cluster.CreateClient();
try
{
while (true)
{
var id = new RiakObjectId("chaos-monkey", key.ToString());
var obj = new RiakObject(id, Guid.NewGuid().ToString());
obj.ContentEncoding = RiakConstants.CharSets.Utf8;
obj.ContentType = RiakConstants.ContentTypes.TextPlain;
var rslt = client.Put(obj);
if (rslt.IsSuccess)
{
Console.WriteLine("[ChaosMonkeyApp] stored key: {0}", key);
}
else
{
Console.WriteLine("[ChaosMonkeyApp] error storing key {0}, {1}", key, rslt.ErrorMessage);
}
++key;
Thread.Sleep(storeDataInterval);
ct.ThrowIfCancellationRequested();
}
}
finally
{
Console.WriteLine("[ChaosMonkeyApp] store thread stopping");
}
}
public void CreatingBucketInSpecificBucketType()
{
id = new RiakObjectId("no_siblings", "sensitive_user_data", "user19735");
var obj = new RiakObject(id, "{\"name\":\"Bob\"}");
var rslt = client.Put(obj);
CheckResult(rslt);
}
public void InvalidFieldNamesAndTypes()
{
id = new RiakObjectId("indexes", "mykey", "test value");
var obj = new RiakObject("indexes", "mykey", "test value");
var intIdx = obj.IntIndex("test-int-idx");
Assert.Throws<FormatException>(() => intIdx.Add("invalid-value"));
}
public void TestCounterOperations()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Counters, Bucket, key);
// Fetch empty
var initialCounter = Client.DtFetchCounter(id);
Assert.IsFalse(initialCounter.Value.HasValue);
// Increment one
var updatedCounter1 = Client.DtUpdateCounter(id, 1);
Assert.AreEqual(1, updatedCounter1.Value);
// Increment many
var updatedCounter2 = Client.DtUpdateCounter(id, 4);
Assert.AreEqual(5, updatedCounter2.Value);
// Fetch non-empty counter
var incrementedCounter = Client.DtFetchCounter(id);
Assert.AreEqual(5, incrementedCounter.Value);
// Decrement one
var updatedCounter3 = Client.DtUpdateCounter(id, -1);
Assert.AreEqual(4, updatedCounter3.Value);
// Decrement many
var updatedCounter4 = Client.DtUpdateCounter(id, -4);
Assert.AreEqual(0, updatedCounter4.Value);
}
public async Task Save(String endpoint, long position)
{
var id = new RiakObjectId($"{Settings.Bucket}.system", endpoint);
var options = new RiakGetOptions { };
options.SetRw(Quorum.WellKnown.All);
var exists = await _riak.Async.Get(id, options);
if (exists.IsSuccess)
{
var checkpoint = exists.Value.GetObject<Checkpoint>();
checkpoint.Position = position;
exists.Value.SetObject(checkpoint);
var putOpt = new RiakPutOptions { IfNotModified = true, IfNoneMatch = false };
putOpt.SetW(Quorum.WellKnown.All);
await _riak.Async.Put(exists.Value, putOpt);
}
else
{
var checkpoint = new Checkpoint
{
Id = endpoint,
Position = position,
};
var putOpt = new RiakPutOptions { IfNotModified = false, IfNoneMatch = true };
putOpt.SetW(Quorum.WellKnown.All);
var o = new RiakObject(id, checkpoint);
await _riak.Async.Put(o, putOpt);
}
}
public void TestFlagOperations()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Maps, Bucket, key);
const string flagName = "Name";
byte[] flagNameBytes = Serializer(flagName);
var options = new RiakDtUpdateOptions();
options.SetIncludeContext(true);
options.SetTimeout(new Timeout(TimeSpan.FromSeconds(60)));
var flagMapUpdate = new MapUpdate
{
flag_op = MapUpdate.FlagOp.ENABLE,
field = new MapField { name = flagNameBytes, type = MapField.MapFieldType.FLAG }
};
var update = new List<MapUpdate> { flagMapUpdate };
var updatedMap1 = Client.DtUpdateMap(id, Serializer, null, null, update, options);
Assert.True(updatedMap1.Result.IsSuccess, updatedMap1.Result.ErrorMessage);
var mapEntry = updatedMap1.Values.Single(s => s.Field.Name == flagName);
Assert.NotNull(mapEntry.FlagValue);
Assert.IsTrue(mapEntry.FlagValue.Value);
flagMapUpdate.flag_op = MapUpdate.FlagOp.DISABLE;
var updatedMap2 = Client.DtUpdateMap(id, Serializer, updatedMap1.Context, null, update, options);
Assert.True(updatedMap2.Result.IsSuccess, updatedMap2.Result.ErrorMessage);
mapEntry = updatedMap2.Values.Single(s => s.Field.Name == flagName);
Assert.NotNull(mapEntry.FlagValue);
Assert.IsFalse(mapEntry.FlagValue.Value);
}
protected virtual void TestFixtureTearDown()
{
foreach (string key in Keys)
{
var id = new RiakObjectId(BucketType, Bucket, key);
client.Delete(id);
}
}
public void CreatingBucketInSpecificBucketTypeExampleTwo()
{
id = new RiakObjectId("no_siblings", "old_memes", "all_your_base");
var obj = new RiakObject(id, "all your base are belong to us",
RiakConstants.ContentTypes.TextPlain);
var rslt = client.Put(obj);
CheckResult(rslt);
}
public void UsingBucketType()
{
var id1 = new RiakObjectId("users", "my_bucket", "my_key");
var id2 = new RiakObjectId("users", "my_bucket", "my_key");
var rslt1 = client.Get(id1);
CheckResult(rslt1, true);
var rslt2 = client.Get(id2);
CheckResult(rslt2, true);
}
private RiakObjectId PutCoach(string team, string coach)
{
var id = new RiakObjectId("siblings", "coaches", team);
var obj = new RiakObject(id, coach,
RiakConstants.ContentTypes.TextPlain);
var rslt = client.Put(obj);
CheckResult(rslt);
return id;
}
public void StoringAndSpecifyingContentType()
{
id = new RiakObjectId("quotes", "oscar_wilde", "genius");
var obj = new RiakObject(
id,
"I have nothing to declare but my genius",
RiakConstants.ContentTypes.TextPlain);
var rslt = client.Put(obj);
CheckResult(rslt);
}
public void ReadingObjects()
{
id = new RiakObjectId("animals", "dogs", "rufus");
Assert.AreEqual("animals", id.BucketType);
Assert.AreEqual("dogs", id.Bucket);
Assert.AreEqual("rufus", id.Key);
var rslt = client.Get(id);
Console.WriteLine("ResultCode: {0}", rslt.ResultCode);
}
public virtual void TestFixtureTearDown()
{
if (EnumerableUtil.NotNullOrEmpty(Keys))
{
foreach (string key in Keys)
{
var id = new RiakObjectId(BucketType, Bucket, key);
client.Delete(id);
}
}
}
private void UpdateCoach(string team, string newCoach)
{
var id = new RiakObjectId("siblings", "coaches", team);
var getResult = client.Get(id);
CheckResult(getResult);
RiakObject obj = getResult.Value;
obj.SetObject<string>(newCoach, RiakConstants.ContentTypes.TextPlain);
var rslt = client.Put(obj);
CheckResult(rslt);
}
public void Putting_A_Value_To_A_Write_Once_Bucket_Works()
{
string key = Guid.NewGuid().ToString();
string value = "test value";
var id = new RiakObjectId(BucketType, Bucket, key);
var obj = new RiakObject(id, value, RiakConstants.ContentTypes.TextPlain);
RiakResult<RiakObject> rslt = client.Put(obj);
Assert.True(rslt.IsSuccess, rslt.ErrorMessage);
}
public void UpdateCoachExample()
{
id = PutCoach("packers", "Old Coach");
UpdateCoach("packers", "Vince Lombardi");
id = new RiakObjectId("siblings", "coaches", "packers");
var getResult = client.Get(id);
RiakObject packers = getResult.Value;
Assert.AreEqual("Vince Lombardi", Encoding.UTF8.GetString(packers.Value));
Assert.AreEqual(0, packers.Siblings.Count);
}
public void DefaultBucketCanBeSpecifiedAsType()
{
id = new RiakObjectId("default", "my_bucket", "my_key");
var obj1 = new RiakObject(id, "value", RiakConstants.ContentTypes.TextPlain);
var putRslt = client.Put(obj1);
CheckResult(putRslt);
var id2 = new RiakObjectId("my_bucket", "my_key");
var getRslt = client.Get(id2);
CheckResult(getRslt);
RiakObject obj2 = getRslt.Value;
Assert.AreEqual(obj1.Value, obj2.Value);
}
public DateTime? LastHeartbeat(string endpoint, Int32 bucket)
{
var id = new RiakObjectId($"{Settings.Bucket}.system", $"{endpoint}:{bucket}");
var options = new RiakGetOptions { };
options.SetRw(Quorum.WellKnown.All);
var exists = _riak.Get(id, options);
if (exists.IsSuccess)
{
var competer = exists.Value.GetObject<Competer>();
return competer.Heartbeat;
}
return null;
}
public async Task<EventStore.ClientAPI.Position> Load(String endpoint)
{
var id = new RiakObjectId($"{Settings.Bucket}.system", endpoint);
var options = new RiakGetOptions { };
options.SetRw(Quorum.WellKnown.All);
var exists = await _riak.Async.Get(id, options);
if (exists.IsSuccess)
{
var position = exists.Value.GetObject<Checkpoint>();
return new EventStore.ClientAPI.Position(position.Position, position.Position);
}
return EventStore.ClientAPI.Position.Start;
}
public void ContentTypes()
{
id = new RiakObjectId("animals", "dogs", "fido");
var fido = new { breed = "dalmatian", size = "large" };
var obj = new RiakObject(id, fido);
var rslt = client.Put(obj);
CheckResult(rslt);
rslt = client.Get(id);
CheckResult(rslt);
Assert.NotNull(rslt.Value);
Assert.AreEqual(RiakConstants.ContentTypes.ApplicationJson, rslt.Value.ContentType);
string json = Encoding.UTF8.GetString(rslt.Value.Value);
Assert.AreEqual(@"{""breed"":""dalmatian"",""size"":""large""}", json);
}
public bool CheckOrSave(string endpoint, Int32 bucket, long position)
{
var id = new RiakObjectId($"{Settings.Bucket}.system", $"{endpoint}:{bucket}");
var options = new RiakGetOptions { };
options.SetRw(Quorum.WellKnown.All);
var exists = _riak.Get(id, options);
if (exists.IsSuccess) return false;
var competer = new Competer
{
Id = $"{endpoint}:{bucket}",
Discriminator = Discriminator,
Endpoint = endpoint,
Bucket = bucket,
Position = position,
Heartbeat = DateTime.UtcNow
};
var putOpt = new RiakPutOptions { IfNotModified = false, IfNoneMatch = true };
putOpt.SetW(Quorum.WellKnown.All);
var o = new RiakObject(id, competer);
var result = _riak.Put(o, putOpt);
if (!result.IsSuccess)
{
Logger.Info("Endpoint {0} failed to claim bucket {1}. Error: {2}", endpoint, bucket, result.ErrorMessage);
return false;
}
Thread.Sleep(new Random().Next(100, 2000));
do
{
exists = _riak.Get(id, options);
} while (!exists.IsSuccess);
competer = exists.Value.GetObject<Competer>();
if (competer.Discriminator != Discriminator)
{
Logger.Info("Endpoint {0} failed to claim bucket {1}. Error: {2}", endpoint, bucket, "Discriminator mismatch");
return false;
}
Logger.Info("Endpoint {0} successfully claimed bucket {1}", endpoint, bucket);
return true;
}
public void Test1()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Maps, Bucket, key);
const string setName = "set";
// New Map with Set
var setMapUpdate = new MapUpdate
{
set_op = new SetOp(),
field = new MapField { name = Serializer.Invoke(setName), type = MapField.MapFieldType.SET }
};
// Add X, Y to set
var addSet = new List<string> { "X", "Y" }.Select(s => Serializer.Invoke(s)).ToList();
setMapUpdate.set_op.adds.AddRange(addSet);
// Store
var updatedMap1 = Client.DtUpdateMap(id, Serializer, NoContext, NoRemovals,
new List<MapUpdate> { setMapUpdate });
// Add Z
var setMapUpdate2 = new MapUpdate
{
set_op = new SetOp(),
field = new MapField { name = Serializer.Invoke(setName), type = MapField.MapFieldType.SET }
};
var addSet2 = new List<string> { "Z" }.Select(s => Serializer.Invoke(s)).ToList();
setMapUpdate2.set_op.adds.AddRange(addSet2);
// Remove Set
var fieldToRemove = new RiakDtMapField(setMapUpdate.field);
// Store again
var updatedMap2 = Client.DtUpdateMap(id, Serializer, updatedMap1.Context,
new List<RiakDtMapField> { fieldToRemove }, new List<MapUpdate> { setMapUpdate2 });
Assert.AreEqual(1, updatedMap2.Values.Count);
var set = updatedMap2.Values.Single(s => s.Field.Name == setName);
var setValues = set.SetValue.Select(v => Deserializer.Invoke(v)).ToList();
Assert.AreEqual(1, setValues.Count);
Assert.Contains("Z", setValues);
}
public void TestSetOperations()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Sets, Bucket, key);
var initialSet = Client.DtFetchSet(id);
Assert.IsNull(initialSet.Context);
Assert.IsEmpty(initialSet.Values);
// Single Add
var add = new List<string> { "foo" };
var updatedSet1 = Client.DtUpdateSet(id, Serializer, initialSet.Context, add, null);
var valuesAsStrings1 = updatedSet1.GetObjects(Deserializer).ToList();
Assert.AreEqual(1, updatedSet1.Values.Count);
Assert.Contains("foo", valuesAsStrings1);
// Many Add
var manyAdds = new List<string> { "foo", "bar", "baz", "qux" };
var updatedSet2 = Client.DtUpdateSet(id, Serializer, updatedSet1.Context, manyAdds, null);
var valuesAsStrings2 = updatedSet2.GetObjects(Deserializer).ToList();
Assert.AreEqual(4, updatedSet2.Values.Count);
Assert.Contains("foo", valuesAsStrings2);
Assert.Contains("bar", valuesAsStrings2);
Assert.Contains("baz", valuesAsStrings2);
Assert.Contains("qux", valuesAsStrings2);
// Single Remove
var remove = new List<string> { "baz" };
var updatedSet3 = Client.DtUpdateSet(id, Serializer, updatedSet2.Context, null, remove);
var valuesAsStrings3 = updatedSet3.GetObjects(Deserializer).ToList();
Assert.AreEqual(3, updatedSet3.Values.Count);
Assert.Contains("foo", valuesAsStrings3);
Assert.Contains("bar", valuesAsStrings3);
Assert.Contains("qux", valuesAsStrings3);
// Many Remove
var manyRemove = new List<string> { "foo", "bar", "qux" };
var updatedSet4 = Client.DtUpdateSet(id, Serializer, updatedSet3.Context, null, manyRemove);
Assert.AreEqual(0, updatedSet4.Values.Count);
}
public void TearDown()
{
#if CLEANUP
if (id != null)
{
DeleteObject(id);
}
if (EnumerableUtil.NotNullOrEmpty(ids))
{
DeleteObjects(ids);
}
if (options != null)
{
id = new RiakObjectId(options.BucketType, options.Bucket, options.Key);
DeleteObject(id);
}
#endif
}
public void Putting_A_Value_To_A_Write_Once_Bucket_Works()
{
string key = Guid.NewGuid().ToString();
string value = "test value";
var r = client.GetBucketProperties(BucketType, Bucket);
// TODO FUTURE - someday Riak will return useful error codes
if (!r.IsSuccess && r.ErrorMessage.ToLowerInvariant().Contains("no bucket-type named"))
{
Assert.Pass("write_once bucket type not available, skipping");
}
else
{
var id = new RiakObjectId(BucketType, Bucket, key);
var obj = new RiakObject(id, value, RiakConstants.ContentTypes.TextPlain);
RiakResult<RiakObject> rslt = client.Put(obj);
Assert.True(rslt.IsSuccess, rslt.ErrorMessage);
}
}
public void TestMapSetOperations()
{
string key = GetRandomKey();
var id = new RiakObjectId(BucketTypeNames.Maps, Bucket, key);
const string setName = "Name";
var setMapUpdate = new MapUpdate
{
set_op = new SetOp(),
field = new MapField { name = Serializer.Invoke(setName), type = MapField.MapFieldType.SET }
};
var addSet = new List<string> { "Alex" }.Select(s => Serializer.Invoke(s)).ToList();
setMapUpdate.set_op.adds.AddRange(addSet);
var updatedMap1 = Client.DtUpdateMap(id, Serializer, null, null, new List<MapUpdate> { setMapUpdate });
var setValues1 =
updatedMap1.Values.Single(s => s.Field.Name == setName)
.SetValue.Select(v => Deserializer.Invoke(v))
.ToList();
Assert.Contains("Alex", setValues1);
Assert.AreEqual(1, setValues1.Count);
setMapUpdate.set_op = new SetOp();
var removeSet = addSet;
var addSet2 = new List<string> { "Luke", "Jeremiah" }.Select(s => Serializer.Invoke(s)).ToList();
setMapUpdate.set_op.adds.AddRange(addSet2);
setMapUpdate.set_op.removes.AddRange(removeSet);
var updatedMap2 = Client.DtUpdateMap(id, Serializer, updatedMap1.Context, null,
new List<MapUpdate> { setMapUpdate });
var setValues2 =
updatedMap2.Values.Single(s => s.Field.Name == setName)
.SetValue.Select(v => Deserializer.Invoke(v))
.ToList();
Assert.Contains("Luke", setValues2);
Assert.Contains("Jeremiah", setValues2);
Assert.AreEqual(2, setValues2.Count);
}
public void TestKVOperations()
{
string key = Guid.NewGuid().ToString();
var id = new RiakObjectId(TestBucketType, TestBucket, key);
var obj = new RiakObject(id, Value);
// put
var putOptions = new RiakPutOptions();
putOptions.SetReturnBody(true);
putOptions.SetDw(3);
putOptions.SetTimeout(new Timeout(TimeSpan.FromSeconds(60)));
var putResult = Client.Put(obj, putOptions);
Assert.True(putResult.IsSuccess, putResult.ErrorMessage);
Assert.AreEqual(TestBucketType, putResult.Value.BucketType);
// get
var getResult = Client.Get(id);
Assert.True(getResult.IsSuccess);
Assert.AreEqual(TestBucketType, getResult.Value.BucketType);
// delete
var deleteOptions = new RiakDeleteOptions();
deleteOptions.Vclock = getResult.Value.VectorClock;
deleteOptions.SetDw(3);
var deleteResult = Client.Delete(id, new RiakDeleteOptions().SetDw(3));
Assert.True(deleteResult.IsSuccess);
// multiget
var ids = new List<RiakObjectId>();
for (int i = 0; i < 3; i++)
{
obj = new RiakObject(new RiakObjectId(TestBucketType, TestBucket, key + i), Value);
Client.Put(obj, new RiakPutOptions().SetReturnBody(false).SetDw(3));
ids.Add(obj.ToRiakObjectId());
}
var multiGetResult = Client.Get(ids).ToList();
Assert.True(multiGetResult.All(r => r.IsSuccess));
Assert.True(multiGetResult.All(r => r.Value.BucketType == TestBucketType));
}
/// <summary>
/// Delete the record identified by the <paramref name="objectId"/>.
/// </summary>
/// <param name='objectId'>
/// A <see cref="CorrugatedIron.Models.RiakObjectId"/> identifying the bucket/key combination for the record to be deleted.
/// </param>
/// <param name='options'>
/// Delete options
/// </param>
public RiakResult Delete(RiakObjectId objectId, RiakDeleteOptions options = null)
{
return(Delete(objectId.Bucket, objectId.Key, options));
}
/// <inheritdoc/>
public Task <RiakResult> Delete(RiakObjectId objectId, RiakDeleteOptions options = null)
{
return(Task.Factory.StartNew(() => client.Delete(objectId.Bucket, objectId.Key, options)));
}
/// <summary>
/// Retrieve the specified object from Riak.
/// </summary>
/// <param name='objectId'>
/// Object identifier made up of a key and bucket. <see cref="CorrugatedIron.Models.RiakObjectId"/>
/// </param>
/// <param name='rVal'>
/// The number of nodes required to successfully respond to the read before the read is considered a success.
/// </param>
/// <remarks>If a node does not respond, that does not necessarily mean that the object referred to by
/// <paramref name="objectId"/> is not available. It simply means
/// that less than <paramref name="rVal" /> nodes successfully responded to the read request. Unfortunately,
/// the Riak API does not allow us to distinguish between a 404 resulting from less than <paramref name="rVal"/>
/// nodes successfully responding and a object identified by <paramref name="objectId"/>
/// not being found in Riak.
/// </remarks>
public RiakResult <RiakObject> Get(RiakObjectId objectId, uint rVal = RiakConstants.Defaults.RVal)
{
return(Get(objectId.Bucket, objectId.Key, rVal));
}
/// <inheritdoc/>
public void Delete(RiakObjectId objectId, Action <RiakResult> callback, RiakDeleteOptions options = null)
{
ExecAsync(() => callback(client.Delete(objectId.Bucket, objectId.Key, options)));
}
/// <inheritdoc/>
public void Get(RiakObjectId objectId, Action <RiakResult <RiakObject> > callback, RiakGetOptions options = null)
{
options = options ?? RiakGetOptions.Default;
ExecAsync(() => callback(client.Get(objectId.Bucket, objectId.Key, options)));
}
