/// <summary>
/// Sets the <see cref="CorrugatedIron.Models.RiakBucketProperties"/> properties of a <paramref name="bucket"/>.
/// </summary>
/// <returns>
/// A <see cref="CorrugatedIron.RiakResult"/> detailing the success or failure of the operation.
/// </returns>
/// <param name='bucket'>
/// The Bucket.
/// </param>
/// <param name='properties'>
/// The Properties.
/// </param>
public RiakResult SetBucketProperties(string bucket, RiakBucketProperties properties)
{
if (properties.CanUsePbc)
{
var request = new RpbSetBucketReq {
Bucket = bucket.ToRiakString(), Props = properties.ToMessage()
};
var result = UseConnection(conn => conn.PbcWriteRead <RpbSetBucketReq, RpbSetBucketResp>(request));
return(result);
}
else
{
var request = new RiakRestRequest(ToBucketUri(bucket), RiakConstants.Rest.HttpMethod.Put)
{
Body = properties.ToJsonString().ToRiakString(),
ContentType = RiakConstants.ContentTypes.ApplicationJson
};
var result = UseConnection(conn => conn.RestRequest(request));
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)));
}
return(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;
}));
}
}
private async Task SetHttpBucketProperties(string bucket, RiakBucketProperties properties)
{
var request = new RiakRestRequest(ToBucketUri(bucket), RiakConstants.Rest.HttpMethod.Put)
{
Body = properties.ToJsonString().ToRiakString(),
ContentType = RiakConstants.ContentTypes.ApplicationJson
};
await _connection.RestRequest(_endPoint, request).ConfigureAwait(false);
}
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 async Task ResetHttpBucketProperties(string bucket)
{
var request = new RiakRestRequest(ToBucketPropsUri(bucket), RiakConstants.Rest.HttpMethod.Delete);
var result = await _connection.RestRequest(_endPoint, request).ConfigureAwait(false);
switch (result.StatusCode)
{
case HttpStatusCode.NoContent:
break;
case HttpStatusCode.NotFound:
throw new RiakException((uint)ResultCode.NotFound, "Bucket {0} not found.".Fmt(bucket), false);
default:
throw new RiakException((uint)ResultCode.InvalidResponse, "Unexpected Status Code: {0} ({1})".Fmt(result.StatusCode, (int)result.StatusCode), false);
}
}
/// <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);
}
/// <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));
}
}
public RiakResult <RiakRestResponse> RestRequest(RiakRestRequest request)
{
var baseUri = new StringBuilder(_restRootUrl).Append(request.Uri);
if (request.QueryParams.Count > 0)
{
baseUri.Append("?");
var first = request.QueryParams.First();
baseUri.Append(first.Key.UrlEncoded()).Append("=").Append(first.Value.UrlEncoded());
request.QueryParams.Skip(1).ForEach(kv => baseUri.Append("&").Append(kv.Key.UrlEncoded()).Append("=").Append(kv.Value.UrlEncoded()));
}
var targetUri = new Uri(baseUri.ToString());
var req = (HttpWebRequest)WebRequest.Create(targetUri);
req.KeepAlive = true;
req.Method = request.Method;
req.Credentials = CredentialCache.DefaultCredentials;
if (!string.IsNullOrWhiteSpace(request.ContentType))
{
req.ContentType = request.ContentType;
}
if (!request.Cache)
{
req.Headers.Set(RiakConstants.Rest.HttpHeaders.DisableCacheKey, RiakConstants.Rest.HttpHeaders.DisableCacheValue);
}
request.Headers.ForEach(h => req.Headers.Set(h.Key, h.Value));
if (request.Body != null && request.Body.Length > 0)
{
req.ContentLength = request.Body.Length;
using (var writer = req.GetRequestStream())
{
writer.Write(request.Body, 0, request.Body.Length);
}
}
else
{
req.ContentLength = 0;
}
try
{
var response = (HttpWebResponse)req.GetResponse();
var result = new RiakRestResponse
{
ContentLength = response.ContentLength,
ContentType = response.ContentType,
StatusCode = response.StatusCode,
Headers = response.Headers.AllKeys.ToDictionary(k => k, k => response.Headers[k]),
ContentEncoding = !string.IsNullOrWhiteSpace(response.ContentEncoding)
? Encoding.GetEncoding(response.ContentEncoding)
: Encoding.Default
};
if (response.ContentLength > 0)
{
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream, result.ContentEncoding))
{
result.Body = reader.ReadToEnd();
}
}
}
}
return(RiakResult <RiakRestResponse> .Success(result));
}
catch (RiakException ex)
{
return(RiakResult <RiakRestResponse> .Error(ResultCode.CommunicationError, ex.Message, ex.NodeOffline));
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError)
{
return(RiakResult <RiakRestResponse> .Error(ResultCode.HttpError, ex.Message, false));
}
return(RiakResult <RiakRestResponse> .Error(ResultCode.HttpError, ex.Message, true));
}
catch (Exception ex)
{
return(RiakResult <RiakRestResponse> .Error(ResultCode.CommunicationError, ex.Message, true));
}
}
public Task <RiakResult <RiakRestResponse> > RestRequest(RiakRestRequest request)
{
var baseUri = new StringBuilder(_restRootUrl).Append(request.Uri);
if (request.QueryParams.Count > 0)
{
baseUri.Append("?");
var first = request.QueryParams.First();
baseUri.Append(first.Key.UrlEncoded()).Append("=").Append(first.Value.UrlEncoded());
request.QueryParams.Skip(1).ForEach(kv => baseUri.Append("&").Append(kv.Key.UrlEncoded()).Append("=").Append(kv.Value.UrlEncoded()));
}
var targetUri = new Uri(baseUri.ToString());
var req = (HttpWebRequest)WebRequest.Create(targetUri);
req.KeepAlive = true;
req.Method = request.Method;
req.Credentials = CredentialCache.DefaultCredentials;
if (!string.IsNullOrWhiteSpace(request.ContentType))
{
req.ContentType = request.ContentType;
}
if (!request.Cache)
{
req.Headers.Set(RiakConstants.Rest.HttpHeaders.DisableCacheKey, RiakConstants.Rest.HttpHeaders.DisableCacheValue);
}
request.Headers.ForEach(h => req.Headers.Set(h.Key, h.Value));
if (request.Body != null && request.Body.Length > 0)
{
req.ContentLength = request.Body.Length;
using (var writer = req.GetRequestStream())
{
writer.Write(request.Body, 0, request.Body.Length);
}
}
else
{
req.ContentLength = 0;
}
// process response
var asyncResult = req.BeginGetResponse(null, null);
return(Task <WebResponse> .Factory.FromAsync(asyncResult, req.EndGetResponse)
.ContinueWith((Task <WebResponse> responseTask) => {
// rethrow exception on fault
if (responseTask.IsFaulted)
{
throw responseTask.Exception;
}
// pull out response
var response = (HttpWebResponse)responseTask.Result;
var result = new RiakRestResponse()
{
ContentLength = response.ContentLength,
ContentType = response.ContentType,
StatusCode = response.StatusCode,
Headers = response.Headers.AllKeys.ToDictionary(k => k, k => response.Headers[k]),
ContentEncoding = !string.IsNullOrWhiteSpace(response.ContentEncoding)
? Encoding.GetEncoding(response.ContentEncoding)
: Encoding.Default
};
if (response.ContentLength > 0)
{
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
return ReadStreamAsync(responseStream, (int)response.ContentLength)
.ContinueWith((Task <byte[]> readTask) => {
result.Body = result.ContentEncoding.GetString(readTask.Result);
return result;
});
}
}
}
// end of the line
throw new RiakException("Couldn't read HTTP response", false);
}).Unwrap()
.ContinueWith((Task <RiakRestResponse> responseTask) => {
if (!responseTask.IsFaulted)
{
return RiakResult <RiakRestResponse> .Success(responseTask.Result);
}
else
{
var exceptions = responseTask.Exception.Flatten().InnerExceptions;
var rEx = exceptions.OfType <RiakException>().FirstOrDefault();
var wEx = exceptions.OfType <WebException>().FirstOrDefault();
// process exceptions
if (rEx != null)
{
return RiakResult <RiakRestResponse> .Error(ResultCode.CommunicationError, rEx.Message, rEx.NodeOffline);
}
else if (wEx != null)
{
if (wEx.Status == WebExceptionStatus.ProtocolError)
{
return RiakResult <RiakRestResponse> .Error(ResultCode.HttpError, wEx.Message, false);
}
return RiakResult <RiakRestResponse> .Error(ResultCode.HttpError, wEx.Message, true);
}
else
{
var ex = exceptions.FirstOrDefault();
return RiakResult <RiakRestResponse> .Error(ResultCode.CommunicationError, ex.Message, true);
}
}
}));
}
public Task <RiakRestResponse> RestRequest(IRiakEndPoint endPoint, RiakRestRequest request)
{
return(endPoint.GetSingleResultViaRest(async serverUrl =>
{
var baseUri = new StringBuilder(serverUrl).Append(request.Uri);
if (request.QueryParams.Count > 0)
{
baseUri.Append("?");
var first = request.QueryParams.First();
baseUri.Append(first.Key.UrlEncoded()).Append("=").Append(first.Value.UrlEncoded());
request.QueryParams.Skip(1)
.ForEach(
kv =>
baseUri.Append("&")
.Append(kv.Key.UrlEncoded())
.Append("=")
.Append(kv.Value.UrlEncoded()));
}
var targetUri = new Uri(baseUri.ToString());
var req = (HttpWebRequest)WebRequest.Create(targetUri);
req.KeepAlive = true;
req.Method = request.Method;
req.Credentials = CredentialCache.DefaultCredentials;
if (!string.IsNullOrWhiteSpace(request.ContentType))
{
req.ContentType = request.ContentType;
}
if (!request.Cache)
{
req.Headers.Set(RiakConstants.Rest.HttpHeaders.DisableCacheKey,
RiakConstants.Rest.HttpHeaders.DisableCacheValue);
}
request.Headers.ForEach(h => req.Headers.Set(h.Key, h.Value));
if (request.Body != null && request.Body.Length > 0)
{
req.ContentLength = request.Body.Length;
var writer = await req.GetRequestStreamAsync().ConfigureAwait(false);
writer.Write(request.Body, 0, request.Body.Length);
}
else
{
req.ContentLength = 0;
}
try
{
var response = (HttpWebResponse)await req.GetResponseAsync().ConfigureAwait(false);
var result = new RiakRestResponse
{
ContentLength = response.ContentLength,
ContentType = response.ContentType,
StatusCode = response.StatusCode,
Headers = response.Headers.AllKeys.ToDictionary(k => k, k => response.Headers[k]),
ContentEncoding = !string.IsNullOrWhiteSpace(response.ContentEncoding)
? Encoding.GetEncoding(response.ContentEncoding)
: Encoding.Default
};
if (response.ContentLength > 0)
{
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream, result.ContentEncoding))
{
result.Body = reader.ReadToEnd();
}
}
}
}
if (result.StatusCode != HttpStatusCode.NoContent)
{
throw new RiakException((uint)ResultCode.InvalidResponse, "Unexpected Status Code: {0} ({1})".Fmt(result.StatusCode, (int)result.StatusCode), false);
}
return result;
}
catch (RiakException ex)
{
throw;
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.ProtocolError)
{
throw new RiakException((uint)ResultCode.HttpError, ex.Message, false);
}
throw new RiakException((uint)ResultCode.HttpError, ex.Message, true);
}
catch (Exception ex)
{
throw new RiakException((uint)ResultCode.CommunicationError, ex.Message, true);
}
}));
}
