public RedisNodeInfo(RedisEndPoint endPoint, RedisRole role, string name = null)
: this()
{
Role = role;
Name = name ?? String.Empty;
EndPoint = endPoint ?? RedisEndPoint.Empty;
}
private NodeRoleAndSiblings GetSlavesOfMaster(RedisServerInfo serverInfo)
{
if (serverInfo != null)
{
var replicationSection = serverInfo.Replication;
if (replicationSection != null)
{
var slaves = replicationSection.Slaves;
if (slaves != null)
{
var slaveEndPoints = new List <RedisEndPoint>();
foreach (var slave in slaves)
{
try
{
if (slave.Port.HasValue && !slave.IPAddress.IsEmpty())
{
var endPoint = new RedisEndPoint(slave.IPAddress, slave.Port.Value);
slaveEndPoints.Add(endPoint);
}
}
catch (Exception)
{ }
}
return(new NodeRoleAndSiblings(RedisRole.Master, slaveEndPoints.ToArray()));
}
}
}
return(null);
}
public bool SetMasterIsDown(RedisEndPoint endPoint)
{
if (!Disposed && !endPoint.IsEmpty())
{
lock (m_SyncRoot)
{
var masters = m_Masters;
if (masters.IsAlive())
{
var masterNodes = masters.Nodes;
if (masterNodes != null)
{
var masterNode = masterNodes.FirstOrDefault(n => n.IsAlive() && n.EndPoint == endPoint);
if (masterNode.IsAlive())
{
if (!masterNode.IsClosed)
{
masterNode.IsClosed = true;
}
ChangeGroup(masterNode);
return(true);
}
}
}
}
}
return(false);
}
private NodeRoleAndSiblings GetMastersOfSentinel(string masterName, RedisServerInfo serverInfo)
{
if (serverInfo != null)
{
var sentinelSection = serverInfo.Sentinel;
if (sentinelSection != null)
{
var masters = sentinelSection.Masters;
if (masters != null)
{
var mastersLength = masters.Length;
if (mastersLength > 0)
{
if (masterName.IsEmpty())
{
if (mastersLength == 1)
{
var master = masters[0];
try
{
if (master.Port.HasValue && !master.IPAddress.IsEmpty())
{
var endPoint = new RedisEndPoint(master.IPAddress, master.Port.Value);
return(new NodeRoleAndSiblings(RedisRole.Sentinel, new[] { endPoint }));
}
}
catch (Exception)
{ }
}
return(null);
}
var masterEndPoints = new List <RedisEndPoint>();
foreach (var master in masters)
{
try
{
if (master.Name == masterName &&
master.Port.HasValue && !master.IPAddress.IsEmpty())
{
var endPoint = new RedisEndPoint(master.IPAddress, master.Port.Value);
masterEndPoints.Add(endPoint);
}
}
catch (Exception)
{ }
}
return(new NodeRoleAndSiblings(RedisRole.Sentinel, masterEndPoints.ToArray()));
}
}
}
}
return(null);
}
protected RedisManagedNode(RedisManagerSettings settings, RedisRole role, object seed,
Action <object, RedisCardioPulseStatus> onPulseStateChange, bool ownsSeed = true)
{
m_Seed = seed;
m_Role = role;
m_OwnsSeed = ownsSeed;
m_EndPoint = RedisEndPoint.Empty;
m_Settings = settings;
m_OnPulseStateChange = onPulseStateChange;
}
public RedisManagedNode FindNodeOf(RedisEndPoint endPoint)
{
if (!(Disposed || endPoint.IsEmpty()))
{
var nodes = m_Nodes;
if (nodes != null)
{
return(nodes.FirstOrDefault(n => !ReferenceEquals(n, null) && (n.EndPoint == endPoint)));
}
}
return(null);
}
public void PromoteToMaster(RedisEndPoint newEndPoint, RedisEndPoint oldEndPoint)
{
if (!Disposed && !newEndPoint.IsEmpty())
{
lock (m_SyncRoot)
{
SetMasterIsDown(oldEndPoint);
var masters = m_Masters;
if (masters.IsAlive())
{
var slaves = m_Slaves;
var node = masters.FindNodeOf(newEndPoint);
if (node.IsAlive())
{
node.Ping();
if (node.IsClosed)
{
node.IsClosed = false;
}
if (slaves.IsAlive())
{
slaves.RemoveNode(node);
}
return;
}
if (slaves.IsAlive())
{
var slaveNode = slaves.FindNodeOf(newEndPoint);
if (slaveNode.IsAlive())
{
if (ChangeGroup(slaveNode))
{
if (slaveNode.IsClosed)
{
slaveNode.IsClosed = false;
}
}
}
}
}
}
}
}
private NodeRoleAndSiblings GetMasterOfSlave(RedisServerInfo serverInfo)
{
if (serverInfo != null)
{
var replicationSection = serverInfo.Replication;
if (replicationSection != null)
{
try
{
if (replicationSection.MasterPort.HasValue &&
!replicationSection.MasterHost.IsEmpty())
{
var endPoint = new RedisEndPoint(replicationSection.MasterHost,
(int)replicationSection.MasterPort.Value);
return(new NodeRoleAndSiblings(RedisRole.Slave, new[] { endPoint }));
}
}
catch (Exception)
{ }
}
}
return(null);
}
private RedisSocket CreateSocket(RedisEndPoint endPoint, IPAddress ipAddress)
{
var socket = NewSocketInternal(ipAddress);
try
{
ConfigureInternal(socket);
socket.ConnectAsync(ipAddress, endPoint.Port).Wait();
SetLastError(0L);
SetState((long)RedisConnectionState.Connected);
var oldSocket = Interlocked.Exchange(ref m_Socket, socket);
if (oldSocket != null && oldSocket != socket)
{
oldSocket.DisposeSocket();
}
}
catch (Exception e)
{
SetState((long)RedisConnectionState.Failed);
var errorCode = e.GetSocketErrorCode();
if (errorCode != SocketError.Success)
{
SetLastError((long)errorCode);
}
else
{
SetLastError(RedisErrorCode.GenericError);
}
socket.DisposeSocket();
throw;
}
return(socket);
}
public Tuple <RedisRole, RedisEndPoint[], RedisSocket> DiscoverNode(RedisEndPoint endPoint)
{
if (endPoint.IsEmpty())
{
throw new RedisFatalException(new ArgumentNullException("endPoint"), RedisErrorCode.MissingParameter);
}
ValidateNotDisposed();
var settings = Settings.Clone(endPoint.Host, endPoint.Port);
using (var connection = NewConnection(settings))
{
var nodeInfo = GetNodeInfo(settings.MasterName, connection);
if (!(nodeInfo == null || nodeInfo.Role == RedisRole.Undefined))
{
var role = nodeInfo.Role;
var siblingEndPoints = nodeInfo.Siblings;
return(new Tuple <RedisRole, RedisEndPoint[], RedisSocket>(role, siblingEndPoints, connection.RemoveSocket()));
}
}
return(null);
}
protected GroupedSockets CreateGroupSockets()
{
if (!Disposed)
{
var settings = m_Settings;
var ipEPList = RedisEndPoint.ToIPEndPoints(settings.EndPoints);
if (ipEPList != null && ipEPList.Count > 0)
{
var ipEPSettings = ipEPList
.Select(ep => (RedisPoolSettings)settings.Clone(ep.Address.ToString(), ep.Port))
.ToArray();
if (!ipEPSettings.IsEmpty())
{
var discoveredEndPoints = new HashSet <IPEndPoint>();
var emptyTuple = new Tuple <RedisRole, RedisSocket> [0];
var groupsTuples = ipEPSettings
.SelectMany(setting => CreateNodes(discoveredEndPoints, setting) ?? emptyTuple)
.Where(node => node != null)
.GroupBy(
tuple => tuple.Item1,
tuple => tuple.Item2,
(role, group) => new Tuple <RedisRole, RedisSocket[]>(role, group.ToArray()))
.ToList();
if (!groupsTuples.IsEmpty())
{
// 0: Masters, 1: Slaves, 2: Sentinels
const int MastersPos = 0, SlavesPos = 1, SentinelsPos = 2;
var result = new RedisSocket[3][];
foreach (var tuple in groupsTuples)
{
switch (tuple.Item1)
{
case RedisRole.Master:
result[MastersPos] = tuple.Item2;
break;
case RedisRole.Slave:
result[SlavesPos] = tuple.Item2;
break;
case RedisRole.Sentinel:
result[SentinelsPos] = tuple.Item2;
break;
default:
break;
}
}
return(new GroupedSockets(result[MastersPos], result[SlavesPos], result[SentinelsPos]));
}
}
}
}
return(null);
}