/// <summary> /// Lists all buckets available on the Riak cluster. /// </summary> /// <returns> /// An <see cref="System.Collections.Generic.IEnumerable<T>"/> of <see cref="string"/> bucket names. /// </returns> /// <remarks>Buckets provide a logical namespace for keys. Listing buckets requires folding over all keys in a cluster and /// reading a list of buckets from disk. This operation, while non-blocking in Riak 1.0 and newer, still produces considerable /// physical I/O and can take a long time.</remarks> public RiakResult <IEnumerable <string> > ListBuckets() { var result = UseConnection(conn => conn.PbcWriteRead <RpbListBucketsResp>(MessageCode.ListBucketsReq)); if (result.IsSuccess) { var buckets = result.Value.buckets.Select(b => b.FromRiakString()); return(RiakResult <IEnumerable <string> > .Success(buckets.ToList())); } return(RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline)); }
public Task <RiakResult <RiakServerInfo> > GetServerInfo() { return(UseConnection(conn => conn.PbcWriteRead <RpbGetServerInfoResp>(MessageCode.GetServerInfoReq)) .ContinueWith((Task <RiakResult <RpbGetServerInfoResp> > finishedTask) => { var result = finishedTask.Result; if (result.IsSuccess) { return RiakResult <RiakServerInfo> .Success(new RiakServerInfo(result.Value)); } return RiakResult <RiakServerInfo> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline); })); }
public RiakResult <RiakSearchResult> Search(RiakSearchRequest search) { var request = search.ToMessage(); var response = UseConnection(conn => conn.PbcWriteRead <RpbSearchQueryReq, RpbSearchQueryResp>(request)); if (response.IsSuccess) { return(RiakResult <RiakSearchResult> .Success(new RiakSearchResult(response.Value))); } return(RiakResult <RiakSearchResult> .Error(response.ResultCode, response.ErrorMessage, response.NodeOffline)); }
public RiakResult <RiakMapReduceResult> MapReduce(RiakMapReduceQuery query) { var request = query.ToMessage(); var response = UseConnection(conn => conn.PbcWriteRead <RpbMapRedReq, RpbMapRedResp>(request, r => r.IsSuccess && !r.Value.done)); if (response.IsSuccess) { return(RiakResult <RiakMapReduceResult> .Success(new RiakMapReduceResult(response.Value))); } return(RiakResult <RiakMapReduceResult> .Error(response.ResultCode, response.ErrorMessage, response.NodeOffline)); }
public RiakResult <RiakStreamedMapReduceResult> StreamMapReduce(RiakMapReduceQuery query) { var request = query.ToMessage(); var response = UseDelayedConnection((conn, onFinish) => conn.PbcWriteStreamRead <RpbMapRedReq, RpbMapRedResp>(request, r => r.IsSuccess && !r.Value.Done, onFinish)); if (response.IsSuccess) { return(RiakResult <RiakStreamedMapReduceResult> .Success(new RiakStreamedMapReduceResult(response.Value))); } return(RiakResult <RiakStreamedMapReduceResult> .Error(response.ResultCode, response.ErrorMessage)); }
public Task <RiakResult <IEnumerable <string> > > ListBuckets() { return(UseConnection(conn => conn.PbcWriteRead <RpbListBucketsResp>(MessageCode.ListBucketsReq)) .ContinueWith((Task <RiakResult <RpbListBucketsResp> > finishedTask) => { var result = finishedTask.Result; if (result.IsSuccess) { var buckets = result.Value.buckets.Select(b => b.FromRiakString()); return RiakResult <IEnumerable <string> > .Success(buckets.ToList()); } return RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline); })); }
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 <RiakMapReduceResult> > MapReduce(RiakMapReduceQuery query) { var request = query.ToMessage(); return(UseConnection(conn => conn.PbcWriteRead <RpbMapRedReq, RpbMapRedResp>(request, r => r.IsSuccess && !r.Value.done)) .ContinueWith((Task <RiakResult <IEnumerable <RiakResult <RpbMapRedResp> > > > finishedTask) => { var result = finishedTask.Result; if (result.IsSuccess) { return RiakResult <RiakMapReduceResult> .Success(new RiakMapReduceResult(result.Value)); } return RiakResult <RiakMapReduceResult> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline); })); }
private static RiakResult <IEnumerable <string> > ListKeys(IRiakConnection conn, string bucket) { var lkReq = new RpbListKeysReq { Bucket = bucket.ToRiakString() }; var result = conn.PbcWriteRead <RpbListKeysReq, RpbListKeysResp>(lkReq, lkr => lkr.IsSuccess && !lkr.Value.Done); if (result.IsSuccess) { var keys = result.Value.Where(r => r.IsSuccess).SelectMany(r => r.Value.KeyNames).Distinct().ToList(); return(RiakResult <IEnumerable <string> > .Success(keys)); } return(RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage)); }
public RiakResult <IEnumerable <string> > StreamListKeys(string bucket) { var lkReq = new RpbListKeysReq { Bucket = bucket.ToRiakString() }; var result = UseDelayedConnection((conn, onFinish) => conn.PbcWriteStreamRead <RpbListKeysReq, RpbListKeysResp>(lkReq, lkr => lkr.IsSuccess && !lkr.Value.Done, onFinish)); if (result.IsSuccess) { var keys = result.Value.Where(r => r.IsSuccess).SelectMany(r => r.Value.KeyNames); return(RiakResult <IEnumerable <string> > .Success(keys)); } return(RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage)); }
public Task <RiakResult <RiakSearchResult> > Search(RiakSearchRequest search) { var request = search.ToMessage(); return(UseConnection(conn => conn.PbcWriteRead <RpbSearchQueryReq, RpbSearchQueryResp>(request)) .ContinueWith((Task <RiakResult <RpbSearchQueryResp> > finishedTask) => { var result = finishedTask.Result; if (result.IsSuccess) { return RiakResult <RiakSearchResult> .Success(new RiakSearchResult(result.Value)); } return RiakResult <RiakSearchResult> .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline); })); }
/// <summary> /// Deletes the contents of the specified <paramref name="bucket"/>. /// </summary> /// <returns> /// A <see cref="System.Collections.Generic.IEnumerable<T>"/> of <see cref="CorrugatedIron.RiakResult"/> listing the success of all deletes /// </returns> /// <param name='bucket'> /// The bucket to be deleted. /// </param> /// <param name='deleteOptions'> /// Options for Riak delete operation <see cref="CorrugatedIron.Models.RiakDeleteOptions"/> /// </param> /// <remarks> /// <para> /// A delete bucket operation actually deletes all keys in the bucket individually. /// A <see cref="CorrugatedIron.RiakClient.ListKeys"/> operation is performed to retrieve a list of keys /// The keys retrieved from the <see cref="CorrugatedIron.RiakClient.ListKeys"/> are then deleted through /// <see cref="CorrugatedIron.RiakClient.Delete"/>. /// </para> /// <para> /// Because of the <see cref="CorrugatedIron.RiakClient.ListKeys"/> operation, this may be a time consuming operation on /// production systems and may cause memory problems for the client. This should be used either in testing or on small buckets with /// known amounts of data. /// </para> /// </remarks> public IEnumerable <RiakResult> DeleteBucket(string bucket, RiakDeleteOptions deleteOptions) { var results = UseConnection(conn => { var keyResults = ListKeys(conn, bucket); if (keyResults.IsSuccess) { var objectIds = keyResults.Value.Select(key => new RiakObjectId(bucket, key)).ToList(); return(Delete(conn, objectIds, deleteOptions)); } return(RiakResult <IEnumerable <RiakResult> > .Error(keyResults.ResultCode, keyResults.ErrorMessage, keyResults.NodeOffline)); }); return(results.Value); }
/// <summary> /// Persist an <see href="System.Collections.Generic.IEnumerable<T>"/> of <see cref="CorrugatedIron.Models.RiakObjectId"/> to Riak. /// </summary> /// <param name='values'> /// The <see href="System.Collections.Generic.IEnumerable<T>"/> of <see cref="CorrugatedIron.Models.RiakObjectId"/> to save. /// </param> /// <param name='options'> /// Put options. /// </param> public IEnumerable <RiakResult <RiakObject> > Put(IEnumerable <RiakObject> values, RiakPutOptions options = null) { options = options ?? new RiakPutOptions(); values = values.ToList(); var messages = values.Select(v => { var m = v.ToMessage(); options.Populate(m); return(m); }).ToList(); var results = UseConnection(conn => { var responses = messages.Select(conn.PbcWriteRead <RpbPutReq, RpbPutResp>).ToList(); return(RiakResult <IEnumerable <RiakResult <RpbPutResp> > > .Success(responses)); }); var resultsArray = results.Value.ToArray(); for (var i = 0; i < resultsArray.Length; i++) { if (resultsArray[i].IsSuccess) { values.ElementAt(i).MarkClean(); } } 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.VectorClock) : 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.VectorClock)).ToList(); } return RiakResult <RiakObject> .Success(finalResult); } return RiakResult <RiakObject> .Error(t.Item1.ResultCode, t.Item1.ErrorMessage); })); }
/// <summary> /// Persist an <see href="System.Collections.Generic.IEnumerable{T}"/> of <see cref="CorrugatedIron.Models.RiakObjectId"/> to Riak. /// </summary> /// <param name='values'> /// The <see href="System.Collections.Generic.IEnumerable{T}"/> of <see cref="CorrugatedIron.Models.RiakObjectId"/> to save. /// </param> /// <param name='options'> /// Put options. /// </param> /// <returns>An <see cref="System.Collections.Generic.IEnumerable{T}"/> of <see cref="RiakResult{T}"/> /// is returned. You should verify the success or failure of each result separately.</returns> /// <remarks>Riak does not support multi put behavior. CorrugatedIron's multi put functionality wraps multiple /// put requests and returns results as an IEnumerable{RiakResult{RiakObject}}. Callers should be aware that /// this may result in partial success - all results should be evaluated individually in the calling application. /// In addition, applications should plan for multiple failures or multiple cases of siblings being present.</remarks> public IEnumerable <RiakResult <RiakObject> > Put(IEnumerable <RiakObject> values, RiakPutOptions options = null) { options = options ?? new RiakPutOptions(); var results = UseConnection(conn => { var responses = values.Select(v => { if (!IsValidBucketOrKey(v.Bucket)) { return(RiakResult <RpbPutResp> .Error(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false)); } if (!IsValidBucketOrKey(v.Key)) { return(RiakResult <RpbPutResp> .Error(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false)); } var msg = v.ToMessage(); options.Populate(msg); return(conn.PbcWriteRead <RpbPutReq, RpbPutResp>(msg)); }).ToList(); return(RiakResult <IEnumerable <RiakResult <RpbPutResp> > > .Success(responses)); }); 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 <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); })); } }
private static RiakResult <IEnumerable <string> > ListKeys(IRiakConnection conn, string bucket) { System.Diagnostics.Debug.Write(ListKeysWarning); System.Diagnostics.Trace.TraceWarning(ListKeysWarning); Console.WriteLine(ListKeysWarning); var lkReq = new RpbListKeysReq { bucket = bucket.ToRiakString() }; var result = conn.PbcWriteRead <RpbListKeysReq, RpbListKeysResp>(lkReq, lkr => lkr.IsSuccess && !lkr.Value.done); if (result.IsSuccess) { var keys = result.Value.Where(r => r.IsSuccess).SelectMany(r => r.Value.keys).Select(k => k.FromRiakString()).Distinct().ToList(); return(RiakResult <IEnumerable <string> > .Success(keys)); } return(RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline)); }
public RiakResult <IEnumerable <string> > StreamListKeys(string bucket) { System.Diagnostics.Debug.Write(ListKeysWarning); System.Diagnostics.Trace.TraceWarning(ListKeysWarning); Console.WriteLine(ListKeysWarning); var lkReq = new RpbListKeysReq { bucket = bucket.ToRiakString() }; var result = UseDelayedConnection((conn, onFinish) => conn.PbcWriteStreamRead <RpbListKeysReq, RpbListKeysResp>(lkReq, lkr => lkr.IsSuccess && !lkr.Value.done, onFinish)); if (result.IsSuccess) { var keys = result.Value.Where(r => r.IsSuccess).SelectMany(r => r.Value.keys).Select(k => k.FromRiakString()); return(RiakResult <IEnumerable <string> > .Success(keys)); } return(RiakResult <IEnumerable <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline)); }
private RiakResult <IList <string> > IndexGetEquals(string bucket, string indexName, string value) { var message = new RpbIndexReq { bucket = bucket.ToRiakString(), index = indexName.ToRiakString(), key = value.ToRiakString(), qtype = RpbIndexReq.IndexQueryType.eq }; var result = UseConnection(conn => conn.PbcWriteRead <RpbIndexReq, RpbIndexResp>(message)); if (result.IsSuccess) { return(RiakResult <IList <string> > .Success(result.Value.keys.Select(k => k.FromRiakString()).ToList())); } return(RiakResult <IList <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline)); }
/// <summary> /// Retrieve arbitrarily deep list of links for a <see cref="RiakObject"/> /// </summary> /// <returns> /// A list of <see cref="RiakObject"/> identified by the list of links. /// </returns> /// <param name='riakObject'> /// The initial object to use for the beginning of the link walking. /// </param> /// <param name='riakLinks'> /// A list of link definitions /// </param> /// <remarks>Refer to http://wiki.basho.com/Links-and-Link-Walking.html for more information.</remarks> public 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)); } var result = MapReduce(query); 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(); var objects = Get(oids, new RiakGetOptions()); // 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> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline)); }
private Task <RiakResult <IList <string> > > IndexGetRange(string bucket, string indexName, string minValue, string maxValue) { var message = new RpbIndexReq { bucket = bucket.ToRiakString(), index = indexName.ToRiakString(), qtype = RpbIndexReq.IndexQueryType.range, range_min = minValue.ToRiakString(), range_max = maxValue.ToRiakString() }; return(UseConnection(conn => conn.PbcWriteRead <RpbIndexReq, RpbIndexResp>(message)) .ContinueWith((Task <RiakResult <RpbIndexResp> > finishedTask) => { var result = finishedTask.Result; if (result.IsSuccess) { return RiakResult <IList <string> > .Success(result.Value.keys.Select(k => k.FromRiakString()).ToList()); } return RiakResult <IList <string> > .Error(result.ResultCode, result.ErrorMessage, result.NodeOffline); })); }
/// <summary> /// Get the specified <paramref name="key"/> from the <paramref name="bucket"/>. /// Optionally can be read from <paramref name="rVal"/> instances. By default, the server's /// r-value will be used, but can be overridden by <paramref name="rVal"/>. /// </summary> /// <param name='bucket'> /// The name of the bucket containing the <paramref name="key"/> /// </param> /// <param name='key'> /// The key. /// </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 /// <paramref name="bucket"/>/<paramref name="key"/> combination is not available. It simply means /// that less than <paramref name="rVal" /> nodes successfully responded to the read request. Unfortunatley, /// the Riak API does not allow us to distinguish between a 404 resulting from less than <paramref name="rVal"/> /// nodes successfully responding and a <paramref name="bucket"/>/<paramref name="key"/> combination /// not being found in Riak. /// </remarks> public RiakResult <RiakObject> Get(string bucket, string key, uint rVal = RiakConstants.Defaults.RVal) { var request = new RpbGetReq { Bucket = bucket.ToRiakString(), Key = key.ToRiakString(), R = rVal }; var result = UseConnection(conn => conn.PbcWriteRead <RpbGetReq, RpbGetResp>(request)); if (!result.IsSuccess) { return(RiakResult <RiakObject> .Error(result.ResultCode, result.ErrorMessage)); } if (result.Value.VectorClock == null) { return(RiakResult <RiakObject> .Error(ResultCode.NotFound)); } var o = new RiakObject(bucket, key, result.Value.Content, result.Value.VectorClock); return(RiakResult <RiakObject> .Success(o)); }
public override RiakResult <IEnumerable <TResult> > UseDelayedConnection <TResult>(Func <IRiakConnection, Action, RiakResult <IEnumerable <TResult> > > useFun, int retryAttempts) { if (retryAttempts < 0) { return(RiakResult <IEnumerable <TResult> > .Error(ResultCode.NoRetries, "Unable to access a connection on the cluster.", false)); } if (_disposing) { return(RiakResult <IEnumerable <TResult> > .Error(ResultCode.ShuttingDown, "System currently shutting down", true)); } var node = _loadBalancer.SelectNode(); if (node != null) { var result = node.UseDelayedConnection(useFun); if (!result.IsSuccess) { if (result.ResultCode == ResultCode.NoConnections) { Thread.Sleep(RetryWaitTime); return(UseDelayedConnection(useFun, retryAttempts - 1)); } if (result.ResultCode == ResultCode.CommunicationError) { if (result.NodeOffline) { DeactivateNode(node); } Thread.Sleep(RetryWaitTime); return(UseDelayedConnection(useFun, retryAttempts - 1)); } } return(result); } return(RiakResult <IEnumerable <TResult> > .Error(ResultCode.ClusterOffline, "Unable to access functioning Riak node", true)); }
/// <summary> /// Reset the properties on a bucket back to their defaults. /// </summary> /// <param name="bucket">The name of the bucket to reset the properties on.</param> /// <returns>An indication of success or failure.</returns> /// <remarks>This function requires Riak v1.3+.</remarks> public RiakResult ResetBucketProperties(string bucket) { var request = new RiakRestRequest(ToBucketPropsUri(bucket), RiakConstants.Rest.HttpMethod.Delete); var result = UseConnection(conn => conn.RestRequest(request)); if (result.IsSuccess) { switch (result.Value.StatusCode) { case HttpStatusCode.NoContent: return(result); case HttpStatusCode.NotFound: return(RiakResult.Error(ResultCode.NotFound, "Bucket {0} not found.".Fmt(bucket), false)); default: return(RiakResult.Error(ResultCode.InvalidResponse, "Unexpected Status Code: {0} ({1})".Fmt(result.Value.StatusCode, (int)result.Value.StatusCode), result.NodeOffline)); } } return(result); }
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); })); }
/// <summary> /// Delete the record identified by <paramref name="key"/> from a <paramref name="bucket"/>. /// </summary> /// <param name='bucket'> /// The name of the bucket that contains the record to be deleted. /// </param> /// <param name='key'> /// The key identifying the record to be deleted. /// </param> /// <param name='options'> /// Delete options /// </param> public RiakResult Delete(string bucket, string key, RiakDeleteOptions options = null) { if (!IsValidBucketOrKey(bucket)) { return(RiakResult <RiakObject> .Error(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false)); } if (!IsValidBucketOrKey(key)) { return(RiakResult <RiakObject> .Error(ResultCode.InvalidRequest, InvalidKeyErrorMessage, false)); } options = options ?? new RiakDeleteOptions(); var request = new RpbDelReq { bucket = bucket.ToRiakString(), key = key.ToRiakString() }; options.Populate(request); var result = UseConnection(conn => conn.PbcWriteRead(request, MessageCode.DelResp)); return(result); }
public Task <T> Batch <T>(Func <IRiakBatchAsyncClient, Task <T> > batchFun) { var taskResult = default(T); // no idea what this is Func <IRiakConnection, Action, Task <RiakResult <IEnumerable <RiakResult <object> > > > > helperBatchFun = ((conn, onFinish) => { return(Task.Factory.StartNew(() => batchFun(new RiakAsyncClient(conn))).Unwrap() .ContinueWith((Task <T> finishedTask) => { onFinish(); // exception or success if (!finishedTask.IsFaulted) { taskResult = finishedTask.Result; return RiakResult <IEnumerable <RiakResult <object> > > .Success(null); } else { var ex = finishedTask.Exception.Flatten().InnerExceptions.First(); return RiakResult <IEnumerable <RiakResult <object> > > .Error( ResultCode.BatchException, "{0}\n{1}".Fmt(ex.Message, ex.StackTrace), true); } })); }); // apply task to connection return(_endPoint.UseDelayedConnection(helperBatchFun, RetryCount) .ContinueWith((Task <RiakResult <IEnumerable <RiakResult <object> > > > finishedTask) => { var result = finishedTask.Result; if (!result.IsSuccess && result.ResultCode == ResultCode.BatchException) { throw new Exception(result.ErrorMessage); } return taskResult; })); }
/// <summary> /// Returns all properties for a <paramref name="bucket"/>. /// </summary> /// <returns> /// The bucket properties. /// </returns> /// <param name='bucket'> /// The Riak bucket. /// </param> /// <param name='extended'> /// Extended parameters are retrieved by HTTP requests. /// </param> public RiakResult <RiakBucketProperties> GetBucketProperties(string bucket, bool extended = false) { if (extended) { var request = new RiakRestRequest(ToBucketUri(bucket), RiakConstants.Rest.HttpMethod.Get) .AddQueryParam(RiakConstants.Rest.QueryParameters.Bucket.GetPropertiesKey, RiakConstants.Rest.QueryParameters.Bucket.GetPropertiesValue); var result = UseConnection(conn => conn.RestRequest(request)); 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))); } return(RiakResult <RiakBucketProperties> .Error(result.ResultCode, result.ErrorMessage)); } else { var bpReq = new RpbGetBucketReq { Bucket = bucket.ToRiakString() }; var result = UseConnection(conn => conn.PbcWriteRead <RpbGetBucketReq, RpbGetBucketResp>(bpReq)); if (result.IsSuccess) { var props = new RiakBucketProperties(result.Value.Props); return(RiakResult <RiakBucketProperties> .Success(props)); } return(RiakResult <RiakBucketProperties> .Error(result.ResultCode, result.ErrorMessage)); } }
/// <summary> /// Retrieve multiple objects from Riak. /// </summary> /// <param name='bucketKeyPairs'> /// An <see href="System.Collections.Generic.IEnumerable<T>"/> of <see cref="CorrugatedIron.Models.RiakObjectId"/> to be retrieved /// </param> /// <param name='rVal'> /// The number of nodes required to successfully respond to the read before the read is considered a success. /// </param> public IEnumerable <RiakResult <RiakObject> > Get(IEnumerable <RiakObjectId> bucketKeyPairs, uint rVal = RiakConstants.Defaults.RVal) { bucketKeyPairs = bucketKeyPairs.ToList(); var requests = bucketKeyPairs.Select(bk => new RpbGetReq { Bucket = bk.Bucket.ToRiakString(), Key = bk.Key.ToRiakString(), R = rVal }).ToList(); var results = UseConnection(conn => { var responses = requests.Select(conn.PbcWriteRead <RpbGetReq, RpbGetResp>).ToList(); return(RiakResult <IEnumerable <RiakResult <RpbGetResp> > > .Success(responses)); }); return(results.Value.Zip(bucketKeyPairs, Tuple.Create).Select(result => { if (!result.Item1.IsSuccess) { return RiakResult <RiakObject> .Error(result.Item1.ResultCode, result.Item1.ErrorMessage); } if (result.Item1.Value.VectorClock == null) { return RiakResult <RiakObject> .Error(ResultCode.NotFound); } var o = new RiakObject(result.Item2.Bucket, result.Item2.Key, result.Item1.Value.Content.First(), result.Item1.Value.VectorClock); 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.VectorClock)).ToList(); } return RiakResult <RiakObject> .Success(o); })); }
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); })); }