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); }