private Task <RiakResult <IEnumerable <RiakResult> > > Delete(IRiakConnection conn,
IEnumerable <RiakObjectId> objectIds,
RiakDeleteOptions options = null)
{
options = options ?? new RiakDeleteOptions();
return(AfterAll(objectIds.Select(id => {
if (!IsValidBucketOrKey(id.Bucket))
{
return RiakResult.ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false);
}
if (!IsValidBucketOrKey(id.Key))
{
return RiakResult.ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false);
}
var req = new RpbDelReq {
bucket = id.Bucket.ToRiakString(), key = id.Key.ToRiakString()
};
options.Populate(req);
return conn.PbcWriteRead(req, MessageCode.DelResp);
})).ContinueWith((Task <IEnumerable <RiakResult> > finishedTask) => {
return RiakResult <IEnumerable <RiakResult> > .Success(finishedTask.Result);
}));
}
public Task <RiakResult> SetBucketProperties(string bucket, RiakBucketProperties properties)
{
if (!IsValidBucketOrKey(bucket))
{
return(RiakResult.ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (properties.CanUsePbc)
{
var request = new RpbSetBucketReq {
bucket = bucket.ToRiakString(), props = properties.ToMessage()
};
return(UseConnection(conn => conn.PbcWriteRead(request, MessageCode.SetBucketResp)));
}
else
{
var request = new RiakRestRequest(ToBucketUri(bucket), RiakConstants.Rest.HttpMethod.Put)
{
Body = properties.ToJsonString().ToRiakString(),
ContentType = RiakConstants.ContentTypes.ApplicationJson
};
return(UseConnection(conn => conn.RestRequest(request))
.ContinueWith((Task <RiakResult <RiakRestResponse> > finishedTask) => {
var result = finishedTask.Result;
if (result.IsSuccess && result.Value.StatusCode != HttpStatusCode.NoContent)
{
return RiakResult.Error(ResultCode.InvalidResponse, "Unexpected Status Code: {0} ({1})".Fmt(result.Value.StatusCode, (int)result.Value.StatusCode), result.NodeOffline);
}
return result;
}));
}
}
public override Task <RiakResult <IEnumerable <TResult> > > UseDelayedConnection <TResult>(Func <IRiakConnection, Action, Task <RiakResult <IEnumerable <TResult> > > > useFun, int retryAttempts)
{
if (retryAttempts < 0)
{
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.NoRetries, "Unable to access a connection on the cluster.", true));
}
if (_disposing)
{
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.ShuttingDown, "System currently shutting down", true));
}
var node = _node;
if (node != null)
{
return(node.UseDelayedConnection(useFun)
.ContinueWith((Task <RiakResult <IEnumerable <TResult> > > finishedTask) => {
var result = finishedTask.Result;
if (!result.IsSuccess)
{
return TaskDelay(RetryWaitTime).ContinueWith(finishedDelayTask => {
return UseDelayedConnection(useFun, retryAttempts - 1);
}).Unwrap();
}
return TaskResult(result);
}).Unwrap());
}
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.ClusterOffline, "Unable to access functioning Riak node", true));
}
public override Task <RiakResult <IEnumerable <TResult> > > UseDelayedConnection <TResult>(Func <IRiakConnection, Action, Task <RiakResult <IEnumerable <TResult> > > > useFun, int retryAttempts)
{
if (retryAttempts < 0)
{
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.NoRetries, "Unable to access a connection on the cluster.", false));
}
if (_disposing)
{
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.ShuttingDown, "System currently shutting down", true));
}
// select a node
var node = _loadBalancer.SelectNode();
if (node != null)
{
return(node.UseDelayedConnection(useFun)
.ContinueWith((Task <RiakResult <IEnumerable <TResult> > > finishedTask) => {
var result = finishedTask.Result;
if (result.IsSuccess)
{
return TaskResult(result);
}
else
{
if (result.ResultCode == ResultCode.NoConnections)
{
return DelayTask(RetryWaitTime)
.ContinueWith(delayTask => {
return UseDelayedConnection(useFun, retryAttempts - 1);
}).Unwrap();
}
if (result.ResultCode == ResultCode.CommunicationError)
{
if (result.NodeOffline)
{
DeactivateNode(node);
}
return DelayTask(RetryWaitTime)
.ContinueWith(delayTask => {
return UseDelayedConnection(useFun, retryAttempts - 1);
}).Unwrap();
}
}
// out of options
return RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.ClusterOffline, "Unable to access functioning Riak node", true);
}).Unwrap());
}
// no functioning node
return(RiakResult <IEnumerable <TResult> > .ErrorTask(ResultCode.ClusterOffline, "Unable to access functioning Riak node", true));
}
public Task <IEnumerable <RiakResult <RiakObject> > > Get(IEnumerable <RiakObjectId> bucketKeyPairs, RiakGetOptions options = null)
{
bucketKeyPairs = bucketKeyPairs.ToList();
options = options ?? new RiakGetOptions();
return(UseConnection(conn => {
return AfterAll(bucketKeyPairs.Select(bkp => {
// modified closure FTW
var bk = bkp;
if (!IsValidBucketOrKey(bk.Bucket))
{
return RiakResult <RpbGetResp> .ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false);
}
if (!IsValidBucketOrKey(bk.Key))
{
return RiakResult <RpbGetResp> .ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false);
}
var req = new RpbGetReq {
bucket = bk.Bucket.ToRiakString(), key = bk.Key.ToRiakString()
};
options.Populate(req);
return conn.PbcWriteRead <RpbGetReq, RpbGetResp>(req);
})).ContinueWith((Task <IEnumerable <RiakResult <RpbGetResp> > > finishedTask) => {
return RiakResult <IEnumerable <RiakResult <RpbGetResp> > > .Success(finishedTask.Result);
});
}).ContinueWith((Task <RiakResult <IEnumerable <RiakResult <RpbGetResp> > > > finishedTask) => {
// zip up results
var results = RiakResult <IEnumerable <RiakResult <RpbGetResp> > > .Success(finishedTask.Result.Value);
return results.Value.Zip(bucketKeyPairs, Tuple.Create).Select(result => {
if (!result.Item1.IsSuccess)
{
return RiakResult <RiakObject> .Error(result.Item1.ResultCode, result.Item1.ErrorMessage, result.Item1.NodeOffline);
}
if (result.Item1.Value.vclock == null)
{
return RiakResult <RiakObject> .Error(ResultCode.NotFound, "Unable to find value in Riak", false);
}
var o = new RiakObject(result.Item2.Bucket, result.Item2.Key, result.Item1.Value.content.First(), result.Item1.Value.vclock);
if (result.Item1.Value.content.Count > 1)
{
o.Siblings = result.Item1.Value.content.Select(
c => new RiakObject(result.Item2.Bucket, result.Item2.Key, c, result.Item1.Value.vclock)).ToList();
}
return RiakResult <RiakObject> .Success(o);
});
}));
}
public Task <RiakResult <RiakBucketProperties> > GetBucketProperties(string bucket, bool extended = false)
{
// bucket names cannot have slashes in the names, the REST interface doesn't like it at all
if (!IsValidBucketOrKey(bucket))
{
return(RiakResult <RiakBucketProperties> .ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (extended)
{
var request = new RiakRestRequest(ToBucketUri(bucket), RiakConstants.Rest.HttpMethod.Get)
.AddQueryParam(RiakConstants.Rest.QueryParameters.Bucket.GetPropertiesKey,
RiakConstants.Rest.QueryParameters.Bucket.GetPropertiesValue);
return(UseConnection(conn => conn.RestRequest(request))
.ContinueWith((Task <RiakResult <RiakRestResponse> > finishedTask) => {
var result = finishedTask.Result;
if (result.IsSuccess)
{
if (result.Value.StatusCode == HttpStatusCode.OK)
{
var response = new RiakBucketProperties(result.Value);
return RiakResult <RiakBucketProperties> .Success(response);
}
return RiakResult <RiakBucketProperties> .Error(ResultCode.InvalidResponse,
"Unexpected Status Code: {0} ({1})".Fmt(result.Value.StatusCode, (int)result.Value.StatusCode), false);
}
return RiakResult <RiakBucketProperties> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline);
}));
}
else
{
var bpReq = new RpbGetBucketReq {
bucket = bucket.ToRiakString()
};
return(UseConnection(conn => conn.PbcWriteRead <RpbGetBucketReq, RpbGetBucketResp>(bpReq))
.ContinueWith((Task <RiakResult <RpbGetBucketResp> > finishedTask) => {
var result = finishedTask.Result;
if (result.IsSuccess)
{
var props = new RiakBucketProperties(result.Value.props);
return RiakResult <RiakBucketProperties> .Success(props);
}
return RiakResult <RiakBucketProperties> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline);
}));
}
}
public Task <RiakResult <IList <RiakObject> > > WalkLinks(RiakObject riakObject, IList <RiakLink> riakLinks)
{
System.Diagnostics.Debug.Assert(riakLinks.Count > 0, "Link walking requires at least one link");
var input = new RiakBucketKeyInput();
input.AddBucketKey(riakObject.Bucket, riakObject.Key);
var query = new RiakMapReduceQuery()
.Inputs(input);
var lastLink = riakLinks.Last();
foreach (var riakLink in riakLinks)
{
var link = riakLink;
var keep = ReferenceEquals(link, lastLink);
query.Link(l => l.FromRiakLink(link).Keep(keep));
}
return(MapReduce(query)
.ContinueWith((Task <RiakResult <RiakMapReduceResult> > finishedTask) => {
var result = finishedTask.Result;
if (result.IsSuccess)
{
var linkResults = result.Value.PhaseResults.GroupBy(r => r.Phase).Where(g => g.Key == riakLinks.Count - 1);
var linkResultStrings = linkResults.SelectMany(lr => lr.ToList(), (lr, r) => new { lr, r })
.SelectMany(@t => @t.r.Values, (@t, s) => s.FromRiakString());
//var linkResultStrings = linkResults.SelectMany(g => g.Select(r => r.Values.Value.FromRiakString()));
var rawLinks = linkResultStrings.SelectMany(RiakLink.ParseArrayFromJsonString).Distinct();
var oids = rawLinks.Select(l => new RiakObjectId(l.Bucket, l.Key)).ToList();
return Get(oids, new RiakGetOptions())
.ContinueWith((Task <IEnumerable <RiakResult <RiakObject> > > getTask) => {
var objects = getTask.Result;
// FIXME
// we could be discarding results here. Not good?
// This really should be a multi-phase map/reduce
return RiakResult <IList <RiakObject> > .Success(objects.Where(r => r.IsSuccess).Select(r => r.Value).ToList());
});
}
return RiakResult <IList <RiakObject> > .ErrorTask(result.ResultCode, result.ErrorMessage, result.NodeOffline);
}).Unwrap());
}
public Task <IEnumerable <RiakResult> > DeleteBucket(string bucket, RiakDeleteOptions deleteOptions)
{
return(UseConnection(conn => {
return ListKeys(conn, bucket)
.ContinueWith((Task <RiakResult <IEnumerable <string> > > finishedListingKeys) => {
var keyResults = finishedListingKeys.Result;
if (keyResults.IsSuccess)
{
var objectIds = keyResults.Value.Select(key => new RiakObjectId(bucket, key)).ToList();
return Delete(conn, objectIds, deleteOptions);
}
return RiakResult <IEnumerable <RiakResult> > .ErrorTask(keyResults.ResultCode, keyResults.ErrorMessage, keyResults.NodeOffline);
}).Unwrap();
}).ContinueWith((Task <RiakResult <IEnumerable <RiakResult> > > finishedTask) => {
return finishedTask.Result.Value;
}));
}
public Task <IEnumerable <RiakResult <RiakObject> > > Put(IEnumerable <RiakObject> values, RiakPutOptions options = null)
{
options = options ?? new RiakPutOptions();
return(UseConnection(conn => {
return AfterAll(values.Select(v => {
if (!IsValidBucketOrKey(v.Bucket))
{
return RiakResult <RpbPutResp> .ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false);
}
if (!IsValidBucketOrKey(v.Key))
{
return RiakResult <RpbPutResp> .ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false);
}
var msg = v.ToMessage();
options.Populate(msg);
return conn.PbcWriteRead <RpbPutReq, RpbPutResp>(msg);
})).ContinueWith((Task <IEnumerable <RiakResult <RpbPutResp> > > finishedTask) => {
return RiakResult <IEnumerable <RiakResult <RpbPutResp> > > .Success(finishedTask.Result);
});
}).ContinueWith((Task <RiakResult <IEnumerable <RiakResult <RpbPutResp> > > > finishedTask) => {
var results = finishedTask.Result;
return results.Value.Zip(values, Tuple.Create).Select(t => {
if (t.Item1.IsSuccess)
{
var finalResult = options.ReturnBody
? new RiakObject(t.Item2.Bucket, t.Item2.Key, t.Item1.Value.content.First(), t.Item1.Value.vclock)
: t.Item2;
if (options.ReturnBody && t.Item1.Value.content.Count > 1)
{
finalResult.Siblings = t.Item1.Value.content.Select(
c => new RiakObject(t.Item2.Bucket, t.Item2.Key, c, t.Item1.Value.vclock)).ToList();
}
return RiakResult <RiakObject> .Success(finalResult);
}
return RiakResult <RiakObject> .Error(t.Item1.ResultCode, t.Item1.ErrorMessage, t.Item1.NodeOffline);
});
}));
}
public Task <RiakResult> Delete(string bucket, string key, RiakDeleteOptions options = null)
{
if (!IsValidBucketOrKey(bucket))
{
return(RiakResult.ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (!IsValidBucketOrKey(key))
{
return(RiakResult.ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false));
}
var request = new RpbDelReq {
bucket = bucket.ToRiakString(), key = key.ToRiakString()
};
options = options ?? new RiakDeleteOptions();
options.Populate(request);
return(UseConnection(conn => conn.PbcWriteRead(request, MessageCode.DelResp)));
}
public Task <RiakResult <RiakObject> > Put(RiakObject value, RiakPutOptions options = null)
{
if (!IsValidBucketOrKey(value.Bucket))
{
return(RiakResult <RiakObject> .ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (!IsValidBucketOrKey(value.Key))
{
return(RiakResult <RiakObject> .ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false));
}
var request = value.ToMessage();
options = options ?? new RiakPutOptions();
options.Populate(request);
return(UseConnection(conn => conn.PbcWriteRead <RpbPutReq, RpbPutResp>(request))
.ContinueWith((Task <RiakResult <RpbPutResp> > finishedTask) => {
var result = finishedTask.Result;
if (!result.IsSuccess)
{
return RiakResult <RiakObject> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline);
}
var finalResult = options.ReturnBody
? new RiakObject(value.Bucket, value.Key, result.Value.content.First(), result.Value.vclock)
: value;
if (options.ReturnBody && result.Value.content.Count > 1)
{
finalResult.Siblings = result.Value.content.Select(
c => new RiakObject(value.Bucket, value.Key, c, result.Value.vclock)).ToList();
}
return RiakResult <RiakObject> .Success(finalResult);
}));
}
public Task <RiakResult <RiakObject> > Get(string bucket, string key, RiakGetOptions options = null)
{
if (!IsValidBucketOrKey(bucket))
{
return(RiakResult <RiakObject> .ErrorTask(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (!IsValidBucketOrKey(key))
{
return(RiakResult <RiakObject> .ErrorTask(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false));
}
var request = new RpbGetReq {
bucket = bucket.ToRiakString(), key = key.ToRiakString()
};
options = options ?? new RiakGetOptions();
options.Populate(request);
return(UseConnection(conn => conn.PbcWriteRead <RpbGetReq, RpbGetResp>(request))
.ContinueWith((Task <RiakResult <RpbGetResp> > finishedTask) => {
var result = finishedTask.Result;
if (!result.IsSuccess)
{
return RiakResult <RiakObject> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline);
}
if (result.Value.vclock == null)
{
return RiakResult <RiakObject> .Error(ResultCode.NotFound, "Unable to find value in Riak", false);
}
var o = new RiakObject(bucket, key, result.Value.content, result.Value.vclock);
return RiakResult <RiakObject> .Success(o);
}));
}
