internal RedisPubSubChannel(IRedisNamedObject namedObject, RedisPoolSettings settings,
Action <object> onComplete, Action <object, RedisCardioPulseStatus> onPulseStateChange)
{
if (settings == null)
{
throw new RedisFatalException(new ArgumentNullException("settings"), RedisErrorCode.MissingParameter);
}
m_Settings = settings;
var name = !ReferenceEquals(namedObject, null) ? namedObject.Name : null;
if (name.IsEmpty())
{
name = String.Format("{0}, {1}", GetType().Name, m_Id);
}
m_Name = name;
m_OnComplete = onComplete;
m_OnPulseStateChange = onPulseStateChange;
var providerName = String.Format("{0}, {1}", typeof(RedisContinuousConnectionProvider).Name, m_Id);
m_ConnectionProvider = new RedisContinuousConnectionProvider(providerName, m_Settings, ResponseReceived);
}
public RedisEndPointResolver(string name, RedisPoolSettings settings)
{
if (settings == null)
{
throw new RedisFatalException(new ArgumentNullException("settings"), RedisErrorCode.MissingParameter);
}
m_Name = name;
m_Settings = settings;
}
public RedisConnectionPool(string name, RedisPoolSettings settings)
: base(name, settings)
{
m_AsycRequestQProcessor = RedisCommon.IsWindows ?
new RedisAsyncRequestQParallelProcessor(Settings) :
new RedisAsyncRequestQProcessor(Settings);
if (settings.MaxConnectionCount > 1 || !m_UseAsyncCompleter)
{
Register(this);
}
}
internal RedisContinuousChannel(RedisPoolSettings settings)
{
if (settings == null)
{
throw new RedisFatalException(new ArgumentNullException("settings"), RedisErrorCode.MissingParameter);
}
m_Settings = settings;
Func <IRedisConnectionProvider> factory = NewConnectionProvider;
m_ConnectionProvider = factory();
}
protected Tuple <RedisRole, RedisEndPoint[], RedisSocket> DiscoverNode(RedisPoolSettings settings)
{
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);
}
public RedisAsyncRequestQProcessor(RedisPoolSettings settings,
Action <RedisAsyncRequest, RedisSocketContext> onProcessRequest = null)
{
Settings = settings;
m_OnProcessRequest = onProcessRequest;
m_IdleTimeout = settings.ConnectionIdleTimeout;
var queueTimeout = settings.SendTimeout;
if (queueTimeout < 0)
{
queueTimeout = settings.ReceiveTimeout;
}
else
{
var receiveTimeout = settings.ReceiveTimeout;
if (receiveTimeout > 0)
{
queueTimeout += receiveTimeout;
}
}
m_AsycRequestQ = new RedisAsyncRequestQ(queueTimeout);
}
public RedisContinuousConnectionProvider(string name, RedisPoolSettings settings, Action <IRedisRawResponse> onReceiveResponse)
: base(name, settings)
{
m_OnReceiveResponse = onReceiveResponse;
}
public RedisAsyncRequestQParallelProcessor(RedisPoolSettings settings)
: base(settings, null)
{
}
public RedisManagedPool(RedisRole role, string name, RedisPoolSettings settings)
: base(name, settings)
{
Role = role;
}
public RedisManagedSentinelListener(RedisPoolSettings settings,
Action <object> onComplete, Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(null, settings, onComplete, onPulseStateChange)
{
}
internal RedisMonitorChannel(RedisPoolSettings settings, Action <object> onComplete)
: base(settings)
{
m_OnComplete = onComplete;
RegisterOnComplete(OnComplete);
}
private Tuple <RedisRole, RedisSocket>[] CreateNodes(HashSet <IPEndPoint> discoveredEndPoints, RedisPoolSettings settings)
{
try
{
if (Disposed)
{
return(null);
}
var endPoints = settings.EndPoints;
if (endPoints.IsEmpty())
{
return(null);
}
var ipAddresses = endPoints[0].ResolveHost();
if (ipAddresses.IsEmpty())
{
return(null);
}
var nodeEndPoint = new IPEndPoint(ipAddresses[0], endPoints[0].Port);
if (discoveredEndPoints.Contains(nodeEndPoint))
{
return(null);
}
discoveredEndPoints.Add(nodeEndPoint);
var nodeInfo = DiscoverNode(settings);
if (nodeInfo != null)
{
var role = nodeInfo.Item1;
var siblingEndPoints = nodeInfo.Item2;
var socket = nodeInfo.Item3;
var list = new List <Tuple <RedisRole, RedisSocket> >();
if (socket != null)
{
list.Add(new Tuple <RedisRole, RedisSocket>(role, socket));
}
if (role != RedisRole.Undefined && !siblingEndPoints.IsEmpty())
{
foreach (var siblingEndPoint in siblingEndPoints)
{
try
{
if (!Disposed && siblingEndPoint != null && !siblingEndPoint.Host.IsEmpty())
{
var siblingSettings = (RedisPoolSettings)settings.Clone(siblingEndPoint.Host, siblingEndPoint.Port);
var otherNodes = CreateNodes(discoveredEndPoints, siblingSettings);
if (otherNodes != null)
{
list.AddRange(otherNodes);
}
}
}
catch (Exception)
{ }
}
}
return(list.ToArray());
}
}
catch (Exception)
{ }
return(null);
}
internal RedisContinuousReaderConnection(string name, RedisRole expectedRole, RedisPoolSettings settings,
Action <IRedisRawResponse> onReceiveResponse, Action <RedisConnection, RedisSocket> onCreateSocket,
Action <RedisConnection, RedisSocket> onReleaseSocket, RedisSocket socket = null, bool connectImmediately = true)
: base(name, expectedRole, settings, onCreateSocket, onReleaseSocket, socket, connectImmediately)
{
m_OnReceiveResponse = onReceiveResponse;
}
