internal void ReuseSocket(RedisSocket socket)
{
var provider = m_ConnectionProvider;
if (provider.IsAlive())
{
provider.ReuseSocket(socket);
}
else if (socket.IsAlive())
{
socket.DisposeSocket();
}
}
public void BeginReceive(Action <RedisContinuousReader> onComplete, Action <IRedisRawResponse> onReceive)
{
ValidateNotDisposed();
if (Interlocked.CompareExchange(ref m_ReceiveState, RedisConstants.One, RedisConstants.Zero) ==
RedisConstants.Zero)
{
m_Connection.ConnectAsync().
ContinueWith((asyncTask) =>
{
RedisSocket socket = null;
if (asyncTask.IsCompleted)
{
socket = asyncTask.Result;
}
Interlocked.Exchange(ref m_Socket, socket);
try
{
if (socket != null)
{
try
{
using (var ctx = new RedisContinuousReaderCtx(this, m_Connection, socket, onReceive))
{
Interlocked.Exchange(ref m_Context, ctx);
ctx.Read();
}
}
finally
{
Interlocked.Exchange(ref m_Context, null);
}
}
}
finally
{
Interlocked.Exchange(ref m_ReceiveState, RedisConstants.Zero);
Interlocked.Exchange(ref m_Socket, null);
socket.DisposeSocket();
}
}).ContinueWith(t =>
{
if (onComplete != null)
{
onComplete(this);
}
});
}
}
protected override void CompleteSocketRelease(IRedisConnection connection, RedisSocket socket)
{
if (socket != null)
{
lock (m_SocketLock)
{
RedisSocket currentSocket;
if (Disposed)
{
currentSocket = Interlocked.CompareExchange(ref m_Socket, null, socket);
if (currentSocket != null)
{
currentSocket.DisposeSocket();
}
else if (socket != null)
{
socket.DisposeSocket();
}
return;
}
currentSocket = m_Socket;
if (!currentSocket.IsAlive())
{
Interlocked.Exchange(ref m_Socket, null);
currentSocket = null;
}
if (ReferenceEquals(currentSocket, socket))
{
return;
}
if (socket.IsAlive())
{
currentSocket = Interlocked.Exchange(ref m_Socket, socket);
if (currentSocket != null)
{
currentSocket.DisposeSocket();
}
}
}
}
}
private static void OnReleaseSocket(IRedisConnection conn, RedisSocket socket)
{
socket.DisposeSocket();
}
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);
}
