protected internal RedisManagedServer(RedisAsyncClient client, RedisConnectionSettings settings, RedisRole role,
Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(client, settings)
{
Role = role;
m_OnPulseStateChange = onPulseStateChange;
}
public RedisManagedSentinelListener(RedisConnectionSettings settings,
Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(settings)
{
m_OnPulseStateChange = onPulseStateChange;
m_Client = new RedisAsyncClient(settings);
Init(settings, m_Client);
}
protected NodeRoleAndSiblings GetNodeInfo(string masterName, RedisAsyncClient client)
{
if (client != null)
{
try
{
var serverInfo = client.GetServerInfo();
if (serverInfo != null)
{
var role = DiscoverRoleOfNode(serverInfo);
switch (role)
{
case RedisRole.Slave:
return(GetMasterOfSlave(serverInfo) ?? new NodeRoleAndSiblings(role, null));
case RedisRole.Master:
return(GetSlavesOfMaster(serverInfo) ?? new NodeRoleAndSiblings(role, null));
case RedisRole.Sentinel:
{
var masters = GetMastersOfSentinel(masterName, serverInfo);
if (!Disposed)
{
var otherSentinels = GetSiblingSentinelsOfSentinel(masterName, client);
if (!Disposed)
{
if (otherSentinels == null || otherSentinels.Siblings == null)
{
return(masters ?? new NodeRoleAndSiblings(role, null));
}
if (masters == null || masters.Siblings == null)
{
return(otherSentinels ?? new NodeRoleAndSiblings(role, null));
}
var siblings = new HashSet <RedisEndPoint>(masters.Siblings);
siblings.UnionWith(otherSentinels.Siblings);
return(new NodeRoleAndSiblings(role, siblings.ToArray()));
}
}
break;
}
default:
break;
}
}
}
catch (Exception)
{ }
}
return(null);
}
protected internal RedisSentinelClient(RedisAsyncClient client)
{
if (client == null)
{
throw new RedisFatalException(new ArgumentNullException("client"), RedisErrorCode.MissingParameter);
}
m_Client = client.Disposed ? new RedisAsyncClient(client.Settings) : client;
m_Executer = new RedisAsyncCommandExecuter(m_Client, RedisConstants.UninitializedDbIndex);
}
private void Init(RedisConnectionSettings settings, RedisAsyncClient client)
{
m_Executer = new RedisAsyncCommandExecuter(client, RedisConstants.UninitializedDbIndex);
if (IsHeartBeatEnabled(settings))
{
m_HeartBeatProbe = new RedisHeartBeatProbe(settings, this, null);
m_HeartBeatProbe.SetOnPulseStateChange(OnPulseStateChange);
m_HeartBeatProbe.AttachToCardio();
}
}
public RedisSentinelClient(RedisSentinelSettings settings)
: base()
{
if (settings == null)
{
throw new RedisFatalException(new ArgumentNullException("settings"), RedisErrorCode.MissingParameter);
}
m_Client = new RedisAsyncClient(settings);
m_Executer = new RedisAsyncCommandExecuter(m_Client, RedisConstants.UninitializedDbIndex);
}
protected internal RedisAsyncServer(RedisAsyncClient client, RedisConnectionSettings settings)
{
if (client == null)
{
throw new RedisFatalException(new ArgumentNullException("client"), RedisErrorCode.MissingParameter);
}
settings = settings ?? client.Settings;
Init(settings);
if (client.IsAlive())
{
m_Clients[0] = client;
}
}
protected internal RedisManagedSentinelListener(RedisAsyncClient client,
RedisConnectionSettings settings, Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(settings ?? client.Settings)
{
if (client == null)
{
throw new RedisFatalException(new ArgumentNullException("client"), RedisErrorCode.MissingParameter);
}
m_OnPulseStateChange = onPulseStateChange;
settings = settings ?? client.Settings;
m_Client = client.Disposed ? new RedisAsyncClient(settings) : client;
Init(settings, m_Client);
}
private NodeRoleAndSiblings GetSiblingSentinelsOfSentinel(string masterName, RedisAsyncClient client)
{
if (masterName.IsEmpty())
{
throw new ArgumentNullException("masterName");
}
try
{
var response = client.Expect(new RedisCommand(-1, RedisCommandList.Sentinel, RedisCommandType.SendAndReceive,
RedisCommandList.Sentinels, masterName.ToBytes()));
if (!ReferenceEquals(response, null) && response.Type == RedisResultType.Array)
{
var result = response as RedisArray;
if (!ReferenceEquals(result, null))
{
var sentinelInfos = RedisSentinelNodeInfo.ParseInfoResponse(result);
if (sentinelInfos != null)
{
var length = sentinelInfos.Length;
if (length > 0)
{
var siblingEndPoints = new List <RedisEndPoint>(length);
for (var i = 0; i < length; i++)
{
var sentinelInfo = sentinelInfos[i];
if (!Disposed && sentinelInfo != null && sentinelInfo.Port.HasValue && !sentinelInfo.IPAddress.IsEmpty())
{
siblingEndPoints.Add(new RedisEndPoint(sentinelInfo.IPAddress, (int)sentinelInfo.Port.Value));
}
}
if (!Disposed)
{
return(new NodeRoleAndSiblings(RedisRole.Sentinel, siblingEndPoints.ToArray()));
}
}
}
}
}
}
catch (Exception)
{ }
return(null);
}
private RedisAsyncClient GetTransactionalClient()
{
var client = m_TransactionalClient;
if (client == null)
{
lock (m_TransClientLock)
{
client = m_TransactionalClient;
if (client == null)
{
client = (m_TransactionalClient = new RedisAsyncClient(m_Settings));
}
}
}
return(client);
}
private RedisAsyncClient GetClient()
{
lock (m_ClientLock)
{
var index = Interlocked.Add(ref m_ClientIndex, 1);
if (index >= m_ClientCount)
{
index = 0;
Interlocked.Exchange(ref m_ClientIndex, 0);
}
var client = m_Clients[index];
if (client == null)
{
client = (m_Clients[index] = new RedisAsyncClient(m_Settings));
}
return(client);
}
}
public RedisPipeline(RedisAsyncClient asyncClient, int dbIndex)
: base(asyncClient, dbIndex)
{
}
public RedisAsyncCommandExecuter(RedisAsyncClient asyncClient, int dbIndex)
{
m_AsyncClient = asyncClient;
m_DbIndex = Math.Min(Math.Max(dbIndex, RedisConstants.UninitializedDbIndex), RedisConstants.MaxDbIndex);
}
public RedisTransaction(RedisAsyncClient asyncClient, int dbIndex)
: base(asyncClient, dbIndex)
{
}
public RedisDb(RedisAsyncClient asyncClient, int dbIndex)
: base(asyncClient, dbIndex)
{
}
protected GroupedClients CreateGroupSockets()
{
if (!Disposed)
{
var settings = m_Settings;
var ipEPList = RedisEndPoint.ToIPEndPoints(settings.EndPoints);
if (ipEPList != null && ipEPList.Count > 0)
{
var ipEPSettings = ipEPList
.Select(ep => (RedisConnectionSettings)settings.Clone(ep.Address.ToString(), ep.Port))
.ToArray();
if (!ipEPSettings.IsEmpty())
{
var discoveredEndPoints = new HashSet <IPEndPoint>();
var emptyTuple = new Tuple <RedisRole, RedisAsyncClient> [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, RedisAsyncClient[]>(role, group.ToArray()))
.ToList();
if (!groupsTuples.IsEmpty())
{
// 0: Masters, 1: Slaves, 2: Sentinels
const int MastersPos = 0, SlavesPos = 1, SentinelsPos = 2;
var result = new RedisAsyncClient[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 GroupedClients(result[MastersPos], result[SlavesPos], result[SentinelsPos]));
}
}
}
}
return(null);
}
