public Tuple <bool, TResult> DelayedConsume <TResult>(Func <IRiakConnection, Action, TResult> consumer)
{
if (_disposing)
{
return(Tuple.Create(false, default(TResult)));
}
IRiakConnection instance = null;
try
{
if (_resources.TryPop(out instance))
{
Action cleanup = () =>
{
var i = instance;
instance = null;
_resources.Push(i);
};
var result = consumer(instance, cleanup);
return(Tuple.Create(true, result));
}
}
catch (Exception)
{
if (instance != null)
{
_resources.Push(instance);
}
return(Tuple.Create(false, default(TResult)));
}
return(Tuple.Create(false, default(TResult)));
}
public Tuple <bool, TResult> DelayedConsume <TResult>(Func <IRiakConnection, Action, TResult> consumer)
{
if (disposing)
{
return(Tuple.Create(false, default(TResult)));
}
IRiakConnection conn = null;
try
{
conn = connFactory.CreateConnection(nodeConfig, authConfig);
var result = consumer(conn, conn.Dispose);
return(Tuple.Create(true, result));
}
catch (Exception)
{
if (conn != null)
{
conn.Dispose();
}
return(Tuple.Create(false, default(TResult)));
}
}
public Tuple <bool, TResult> Consume <TResult>(Func <IRiakConnection, TResult> consumer)
{
if (_disposing)
{
return(Tuple.Create(false, default(TResult)));
}
IRiakConnection instance = null;
try
{
if (_resources.TryPop(out instance))
{
var result = consumer(instance);
return(Tuple.Create(true, result));
}
}
catch (Exception)
{
return(Tuple.Create(false, default(TResult)));
}
finally
{
if (instance != null)
{
_resources.Push(instance);
}
}
return(Tuple.Create(false, default(TResult)));
}
public Task <Tuple <bool, TResult> > DelayedConsume <TResult>(Func <IRiakConnection, Action, Task <TResult> > consumer)
{
if (_disposing)
{
return(TaskResult(Tuple.Create(false, default(TResult))));
}
IRiakConnection instance = null;
if (_resources.TryPop(out instance))
{
Action cleanup = (() => {
if (instance != null)
{
_resources.Push(instance);
}
});
return(consumer(instance, cleanup).ContinueWith((Task <TResult> finishedTask) => {
// finshed task
if (!finishedTask.IsFaulted)
{
return Tuple.Create(true, finishedTask.Result);
}
else
{
return Tuple.Create(false, default(TResult));
}
}));
}
else
{
return(TaskResult(Tuple.Create(false, default(TResult))));
}
}
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);
}));
}
private static RiakResult <IEnumerable <RiakResult> > Delete(IRiakConnection conn,
IEnumerable <RiakObjectId> objectIds, RiakDeleteOptions options = null)
{
options = options ?? new RiakDeleteOptions();
var responses = objectIds.Select(id =>
{
if (!IsValidBucketOrKey(id.Bucket))
{
return(RiakResult.Error(ResultCode.InvalidRequest, InvalidBucketErrorMessage, false));
}
if (!IsValidBucketOrKey(id.Key))
{
return(RiakResult.Error(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));
}).ToList();
return(RiakResult <IEnumerable <RiakResult> > .Success(responses));
}
private static RiakResult <IEnumerable <RiakResult> > Delete(IRiakConnection conn,
IEnumerable <RiakObjectId> objectIds, RiakDeleteOptions options = null)
{
options = options ?? new RiakDeleteOptions();
var requests = objectIds.Select(id => new RpbDelReq {
Bucket = id.Bucket.ToRiakString(), Key = id.Key.ToRiakString()
}).ToList();
requests.ForEach(r => options.Populate(r));
var responses = requests.Select(conn.PbcWriteRead <RpbDelReq, RpbDelResp>).ToList();
return(RiakResult <IEnumerable <RiakResult> > .Success(responses));
}
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 RiakCluster(IRiakClusterConfiguration clusterConfiguration)
{
_riakConnection = new RiakConnection();
_nodePollTime = clusterConfiguration.NodePollTime;
_nodes =
clusterConfiguration.RiakNodes.Select(riakNodeConfiguration => new RiakNode(riakNodeConfiguration))
.Cast <IRiakNode>()
.ToList();
_loadBalancer = new RoundRobinStrategy();
_loadBalancer.Initialise(_nodes);
_offlineNodes = new ConcurrentQueue <IRiakNode>();
Task.Factory.StartNew(NodeMonitor);
}
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));
}
internal RiakAsyncClient(IRiakConnection batchConnection)
{
_batchConnection = batchConnection;
}
private RiakClient(IRiakConnection batchConnection, byte[] clientId)
{
_batchConnection = batchConnection;
ClientId = clientId;
Async = new RiakAsyncClient(this);
}
private RiakClient(IRiakConnection batchConnection, byte[] clientId) : this(batchConnection) { }
private RiakClient(IRiakConnection batchConnection)
{
_batchConnection = batchConnection;
Async = new RiakAsyncClient(this);
}
