public Task SendAsync(byte[] data, RedisRole commandRole)
{
ValidateNotDisposed();
ValidateRole(commandRole);
var socket = Connect();
if (socket == null)
{
SetLastError((long)SocketError.NotConnected);
SetState((long)RedisConnectionState.Failed);
throw new RedisFatalException(new SocketException((int)SocketError.NotConnected), RedisErrorCode.ConnectionError);
}
var task = socket.SendAsync(data, 0, data.Length);
task.ContinueWith((asyncTask) =>
{
if (asyncTask.IsFaulted && asyncTask.Exception.IsSocketError())
{
FreeAndNilSocket();
}
});
return(task);
}
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;
}
public RedisManagedServer(RedisManagerSettings settings, RedisRole role,
Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(settings)
{
Role = role;
m_OnPulseStateChange = onPulseStateChange;
}
public override RedisRawResponse SendReceive(byte[] data, RedisRole commandRole)
{
ValidateNotDisposed();
ValidateRole(commandRole);
var socket = Connect();
if (socket == null)
{
SetLastError((long)SocketError.NotConnected);
SetState((long)RedisConnectionState.Failed);
throw new RedisFatalException(new SocketException((int)SocketError.NotConnected), RedisErrorCode.ConnectionError);
}
var task = socket.SendAsync(data, 0, data.Length)
.ContinueWith <RedisRawResponse>((asyncTask) =>
{
if (asyncTask.IsFaulted && asyncTask.Exception.IsSocketError())
{
FreeAndNilSocket();
return(null);
}
if (asyncTask.IsCompleted && asyncTask.Result > 0)
{
using (var reader = new RedisSingleResponseReader(Settings))
return(reader.Execute(socket));
}
return(null);
});
return(task.Result);
}
protected internal RedisManagedServer(RedisAsyncClient client, RedisConnectionSettings settings, RedisRole role,
Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(client, settings)
{
Role = role;
m_OnPulseStateChange = onPulseStateChange;
}
protected override void OnBeforeConnect(int dbIndex, RedisRole expectedRole)
{
if (IsDown)
{
throw new RedisFatalException("Pool is down");
}
}
public RedisNodeInfo(RedisEndPoint endPoint, RedisRole role, string name = null)
: this()
{
Role = role;
Name = name ?? String.Empty;
EndPoint = endPoint ?? RedisEndPoint.Empty;
}
public RedisManagedServerGroup(RedisManagerSettings settings, RedisRole role,
RedisManagedServerNode[] nodes, Action <object, RedisCardioPulseStatus> onPulseStateChange)
: base(settings, role, nodes, onPulseStateChange)
{
if (!(role == RedisRole.Slave || role == RedisRole.Master))
{
throw new RedisException("Role must be master or slave");
}
}
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 RedisManagedServerNode(RedisManagerSettings settings, RedisRole role, RedisManagedServer server,
Action <object, RedisCardioPulseStatus> onPulseStateChange, bool ownsSeed = true)
: base(settings, role, server, onPulseStateChange, ownsSeed)
{
m_OnPulseStateChange = onPulseStateChange;
m_EndPoint = (server != null) ? server.EndPoint : RedisEndPoint.Empty;
if (server != null)
{
server.SetOnPulseStateChange(onPulseStateChange);
}
}
public RedisManagedPoolNode(RedisManagerSettings settings, RedisRole role, RedisManagedPool pool,
Action <object, RedisCardioPulseStatus> onPulseStateChange, bool ownsSeed = true)
: base(settings, role, pool, onPulseStateChange, ownsSeed)
{
m_EndPoint = (pool != null) ? pool.EndPoint : RedisEndPoint.Empty;
if (pool != null)
{
pool.PoolPulseStateChanged += OnPoolPulseStateChange;
pool.PubSubPulseStateChanged += OnPubSubPulseStateChange;
}
}
protected internal override IRedisConnection Connect(int dbIndex, RedisRole expectedRole)
{
ValidateNotDisposed();
var connection = m_Connection;
if (connection.IsAlive())
{
return(connection);
}
return(base.Connect(dbIndex, expectedRole));
}
protected override RedisSocket DequeueSocket(int dbIndex, RedisRole expectedRole)
{
var socket = m_Socket;
lock (m_SocketLock)
{
if (socket != null && !socket.IsConnected())
{
Interlocked.Exchange(ref m_Socket, null);
socket = null;
}
}
return(socket);
}
protected virtual void ValidateRole(RedisRole commandRole)
{
if (!(commandRole == RedisRole.Undefined || commandRole == RedisRole.Any))
{
var serverRole = ServerRole;
if (serverRole != RedisRole.Any && serverRole != commandRole &&
(serverRole == RedisRole.Sentinel || commandRole == RedisRole.Sentinel ||
(serverRole == RedisRole.Slave && commandRole == RedisRole.Master)))
{
throw new RedisException(String.Format("Connected server's {0} role does not satisfy the command's desired {1} role",
serverRole.ToString("F"), commandRole.ToString("F")), RedisErrorCode.NotSupported);
}
}
}
private RedisManagedNodesGroup ToNodesGroup(RedisRole role, RedisSocket[] sockets)
{
if (!sockets.IsEmpty())
{
var baseSettings = Settings;
var nodeList = new List <RedisManagedNode>();
foreach (var socket in sockets)
{
try
{
if (socket.IsConnected())
{
var endPoint = socket.RemoteEP;
var settings = (RedisManagerSettings)baseSettings.Clone(endPoint.Address.ToString(), endPoint.Port);
if (role == RedisRole.Sentinel)
{
var listener = new RedisManagedSentinelListener(settings, null, null);
listener.ReuseSocket(socket);
nodeList.Add(new RedisManagedSentinelNode(settings, listener, null));
}
else
{
var pool = new RedisManagedPool(role, Name, settings);
pool.ReuseSocket(socket);
nodeList.Add(new RedisManagedPoolNode(settings, role, pool, null));
}
}
}
catch (Exception)
{
socket.DisposeSocket();
}
}
if (nodeList.Count > 0)
{
var settings = (RedisManagerSettings)Settings;
return(role != RedisRole.Sentinel ?
(RedisManagedNodesGroup)(new RedisManagedPoolGroup(settings, role, nodeList.Cast <RedisManagedPoolNode>().ToArray(), null)) :
new RedisManagedSentinelGroup(settings, settings.MasterName, nodeList.Cast <RedisManagedSentinelNode>().ToArray(), null));
}
}
return(null);
}
internal RedisDbConnection(string name, RedisRole expectedRole, RedisConnectionSettings settings,
Action <RedisConnection, RedisSocket> onCreateSocket, Action <RedisConnection, RedisSocket> onReleaseSocket,
int dbIndex, RedisSocket socket = null, bool connectImmediately = false)
: base(name, expectedRole, settings, onCreateSocket, onReleaseSocket, socket, false)
{
m_DbIndex = Math.Min(Math.Max(dbIndex, RedisConstants.UninitializedDbIndex), RedisConstants.MaxDbIndex);
try
{
if (connectImmediately)
{
ConnectInternal();
}
}
catch (Exception)
{ }
SelectDB(m_DbIndex);
}
protected virtual IRedisConnection Connect(RedisRole role, bool beginReveive = false)
{
ValidateNotDisposed();
var connectionProvider = m_ConnectionProvider;
if (connectionProvider != null)
{
var connection = connectionProvider.Connect(-1, role);
if (connection != null && !connection.Connected)
{
connection.Connect();
}
OnConnect(connection, beginReveive);
return(connection);
}
return(null);
}
internal RedisConnection(string name,
RedisRole expectedRole, RedisConnectionSettings settings,
Action <RedisConnection, RedisSocket> onCreateSocket,
Action <RedisConnection, RedisSocket> onReleaseSocket,
RedisSocket socket = null, bool connectImmediately = false)
{
if (settings == null)
{
throw new RedisFatalException(new ArgumentNullException("settings"));
}
if (onReleaseSocket == null)
{
throw new RedisFatalException(new ArgumentNullException("onReleaseSocket"));
}
RedisConnectionStats.IncrInUseConnections();
m_ExpectedRole = expectedRole;
m_Settings = settings ?? RedisConnectionSettings.Default;
m_CreateAction = onCreateSocket;
m_ReleaseAction = onReleaseSocket;
m_Name = !name.IsEmpty() ? name : (GetType().Name + ", " + m_Id.ToString());
if ((socket != null) && socket.Connected)
{
m_Socket = socket;
m_State = (int)RedisConnectionState.Connected;
}
try
{
if (connectImmediately)
{
ConnectInternal();
}
}
catch (Exception)
{ }
}
protected RedisManagedNodesGroup(RedisManagerSettings settings, RedisRole role,
RedisManagedNode[] nodes, Action <object, RedisCardioPulseStatus> onPulseStateChange)
{
Role = role;
m_OnPulseStateChange = onPulseStateChange;
m_Nodes = nodes ?? new RedisManagedNode[0];
m_Settings = settings;
if (nodes.IsEmpty())
{
m_NodeIndex = -1;
}
else
{
foreach (var node in nodes)
{
if (node != null)
{
node.SetOnPulseStateChange(OnPulseStateChange);
}
}
}
}
protected virtual void OnConnect()
{
var settings = m_Settings;
Auth(settings.Password);
SetClientName(settings.ClientName);
if (!NeedsToDiscoverRole())
{
m_ServerRole = ExpectedRole;
}
else
{
var role = (m_ServerRole = DiscoverRole());
ValidateRole(role);
}
var serverMode = (m_ServerMode = NeedsToDiscoverMode() ? DiscoverMode() : RedisServerMode.Standalone);
if (serverMode == RedisServerMode.Cluster)
{
DiscoverClusterSlots();
}
}
protected override RedisSocket DequeueSocket(int dbIndex, RedisRole expectedRole)
{
var storeHasMember = false;
lock (m_MemberStoreLock)
{
var member = m_MemberStoreTail;
if (member != null)
{
try
{
if (member.DbIndex == dbIndex)
{
storeHasMember = true;
if (expectedRole == RedisRole.Any ||
expectedRole == RedisRole.Undefined ||
member.Role == expectedRole)
{
var socket = member.ReleaseSocket();
m_MemberStoreTail = null;
if (socket.IsConnected())
{
return(socket);
}
socket.DisposeSocket();
}
}
}
catch (Exception)
{ }
}
}
var store = m_MemberStore;
if (store != null)
{
lock (m_MemberStoreLock)
{
if (store.Count > 0)
{
RedisSocket socket = null;
RedisConnectionPoolMember member;
var node = store.First;
while (node != null)
{
var nextNode = node.Next;
try
{
member = node.Value;
if (member.DbIndex == dbIndex)
{
storeHasMember = true;
if (expectedRole == RedisRole.Any ||
expectedRole == RedisRole.Undefined ||
member.Role == expectedRole)
{
socket = member.ReleaseSocket();
store.Remove(node);
if (socket.IsConnected())
{
return(socket);
}
socket.DisposeSocket();
}
}
}
catch (Exception)
{ }
finally
{
node = nextNode;
}
}
}
}
}
if (storeHasMember && expectedRole == RedisRole.Slave)
{
return(DequeueSocket(dbIndex, RedisRole.Master));
}
return(null);
}
protected override IRedisConnection NewConnection(RedisSocket socket, int dbIndex, RedisRole expectedRole, bool connectImmediately = true)
{
var settings = (Settings as RedisPoolSettings) ?? RedisPoolSettings.Default;
return(new RedisDbConnection(Name, expectedRole, settings, null, OnReleaseSocket, dbIndex,
socket.IsConnected() ? socket : null, connectImmediately));
}
protected override void ApplyRole(RedisRole role)
{
}
IRedisConnection IRedisConnectionProvider.Connect(int dbIndex, RedisRole expectedRole)
{
return(this.Connect(dbIndex, expectedRole));
}
public NodeRoleAndSiblings(RedisRole role, RedisEndPoint[] siblings)
{
Role = role;
Siblings = siblings;
}
public virtual RedisRawResponse SendReceive(byte[] data, RedisRole commandRole)
{
ValidateNotDisposed();
throw new RedisFatalException("SendAndReceive is not supported by base connection. Use Send method for sending data.", RedisErrorCode.NotSupported);
}
protected override IRedisConnection OnNewConnection(RedisSocket socket, int dbIndex, RedisRole role, bool connectImmediately = true)
{
var settings = (Settings as RedisPoolSettings) ?? RedisPoolSettings.Default;
return(new RedisContinuousReaderConnection(Name, RedisRole.Master, settings,
OnReceiveResponse,
null,
OnReleaseSocket,
socket,
true));
}
public RedisManagedPool(RedisRole role, string name, RedisPoolSettings settings)
: base(name, settings)
{
Role = role;
}
protected override IRedisConnection OnNewConnection(RedisSocket socket, int dbIndex, RedisRole role, bool connectImmediately = true)
{
var settings = Settings as RedisSentinelSettings ?? RedisSentinelSettings.Default;
return(new RedisSentinelConnection(Name, settings,
null,
OnReleaseSocket,
socket,
true));
}
protected internal abstract IRedisConnection Connect(int dbIndex, RedisRole expectedRole);