private void NodeMonitor()
{
while (true)
{
ct.ThrowIfCancellationRequested();
var deadNodes = new List <IRiakNode>();
IRiakNode node = null;
while (offlineNodes.TryDequeue(out node))
{
ct.ThrowIfCancellationRequested();
var result = node.UseConnection(c => c.PbcWriteRead(MessageCode.RpbPingReq, MessageCode.RpbPingResp));
ct.ThrowIfCancellationRequested();
if (result.IsSuccess)
{
loadBalancer.AddNode(node);
}
else
{
deadNodes.Add(node);
}
}
foreach (var deadNode in deadNodes)
{
ct.ThrowIfCancellationRequested();
offlineNodes.Enqueue(deadNode);
}
ct.WaitHandle.WaitOne(nodePollTime);
}
}
private void NodeMonitor()
{
while (!_disposing)
{
var deadNodes = new List <IRiakNode>();
IRiakNode node = null;
while (_offlineNodes.TryDequeue(out node) && !_disposing)
{
var result = node.UseConnection(c => c.PbcWriteRead(MessageCode.PingReq, MessageCode.PingResp));
if (result.IsSuccess)
{
_loadBalancer.AddNode(node);
}
else
{
deadNodes.Add(node);
}
}
if (!_disposing)
{
foreach (var deadNode in deadNodes)
{
_offlineNodes.Enqueue(deadNode);
}
Thread.Sleep(_nodePollTime);
}
}
}
/// <inheritdoc/>
public void AddNode(IRiakNode node)
{
lock (nodesLock)
{
if (!nodes.Contains(node))
{
nodes.Add(node);
}
}
}
/// <inheritdoc/>
public void AddNode(IRiakNode node)
{
lock (nodesLock)
{
if (!nodes.Contains(node))
{
nodes.Add(node);
}
}
}
public IRiakNode SelectNode()
{
IRiakNode node = null;
if (_roundRobin.TryMoveNext(out node))
{
return(node);
}
return(null);
}
/// <inheritdoc/>
public void RemoveNode(IRiakNode node)
{
lock (nodesLock)
{
if (nodes.Contains(node))
{
nodes.Remove(node);
}
}
}
/// <inheritdoc/>
public void RemoveNode(IRiakNode node)
{
lock (nodesLock)
{
if (nodes.Contains(node))
{
nodes.Remove(node);
}
}
}
private void DeactivateNode(IRiakNode node)
{
lock (node)
{
if (!_offlineNodes.Contains(node))
{
_loadBalancer.RemoveNode(node);
_offlineNodes.Enqueue(node);
}
}
}
public void RemoveNode(IRiakNode node)
{
lock(_nodesLock)
{
if(_nodes.Contains(node))
{
_nodes.Remove(node);
var list = _nodes.ToList();
_generator = () => list;
}
}
}
public void AddNode(IRiakNode node)
{
lock(_nodesLock)
{
if(!_nodes.Contains(node))
{
_nodes.Add(node);
var list = _nodes.ToList();
_generator = () => list;
}
}
}
public void AddNode(IRiakNode node)
{
lock (_nodesLock)
{
if (!_nodes.Contains(node))
{
_nodes.Add(node);
var list = _nodes.ToList();
_generator = () => list;
}
}
}
public void RemoveNode(IRiakNode node)
{
lock (_nodesLock)
{
if (_nodes.Contains(node))
{
_nodes.Remove(node);
var list = _nodes.ToList();
_generator = () => list;
}
}
}
private void DeactivateNode(IRiakNode node)
{
lock (node)
{
if (!_offlineNodes.Contains(node))
{
_loadBalancer.RemoveNode(node);
node.ReleaseAll().ConfigureAwait(false).GetAwaiter().GetResult();
_offlineNodes.Enqueue(node);
}
}
}
private void MaybeDeactivateNode(bool nodeOffline, IRiakNode node)
{
if (nodeOffline && node.CanMarkOffline)
{
lock (node)
{
if (!offlineNodes.Contains(node))
{
loadBalancer.RemoveNode(node);
offlineNodes.Enqueue(node);
}
}
}
}
// try to re-add dead nodes, started by timer
private void NodeMonitorCycle()
{
if (!_disposing)
{
_nodePollTimer.Change(_nodePollTime, Timeout.Infinite);
// dequeue all offline nodes
var offlineList = new List <IRiakNode>();
IRiakNode queueNode = null;
while (_offlineNodes.TryDequeue(out queueNode) && !_disposing)
{
offlineList.Add(queueNode);
}
// try to ping all offline nodes
foreach (var node in offlineList)
{
if (!_disposing)
{
node.UseConnection(c => c.PbcWriteRead(MessageCode.PingReq, MessageCode.PingResp))
.ContinueWith((Task <RiakResult> finishedTask) => {
if (!_disposing)
{
lock (node)
{
if (finishedTask.Result.IsSuccess)
{
_loadBalancer.AddNode(node);
}
else
{
if (!_offlineNodes.Contains(node))
{
_offlineNodes.Enqueue(node);
}
}
}
}
});
}
}
}
}
private async void NodeMonitor()
{
while (!_disposing)
{
var deadNodes = new List <IRiakNode>();
IRiakNode node = null;
while (_offlineNodes.TryDequeue(out node) && !_disposing)
{
try
{
var nodeToMonitor = node;
await
_riakConnection.PbcWriteRead(new RiakNodeEndpoint(nodeToMonitor), MessageCode.PingReq,
MessageCode.PingResp).ConfigureAwait(false);
_loadBalancer.AddNode(node);
}
catch (Exception)
{
try
{
node.ReleaseAll().ConfigureAwait(false).GetAwaiter().GetResult();
}
finally
{
deadNodes.Add(node);
}
}
}
if (!_disposing)
{
foreach (var deadNode in deadNodes)
{
_offlineNodes.Enqueue(deadNode);
}
Thread.Sleep(_nodePollTime);
}
}
}
public RiakNodeEndpoint(IRiakNode node)
{
_node = node;
}
