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 virtual void OnConnect(RedisSocket socket)
{
if (socket.IsConnected())
{
var settings = (Settings ?? RedisPoolSettings.Default);
if (!settings.Password.IsEmpty() &&
Auth(socket, settings.Password))
{
socket.SetAuthenticated(true);
}
if (!settings.ClientName.IsEmpty())
{
SetClientName(socket, settings.ClientName);
}
if (!NeedsToDiscoverRole())
{
socket.Role = ExpectedRole;
}
else
{
var role = DiscoverRole(socket);
ValidateRole(role);
}
}
}
protected virtual RedisRawResponse ReadResponse(RedisSocket socket)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
ValidateNotDisposed();
if (socket.IsConnected())
{
Error = null;
try
{
var result = ProcessResponse(socket);
OnResponse(result);
return(result);
}
catch (Exception e)
{
Error = e;
}
}
return(RedisVoidResponse.Void);
}
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);
}
private int BeginReceive(RedisSocket socket, int length)
{
if ((length != 0) && socket.IsConnected() && (Interlocked.Read(ref m_ReadState) != RedisConstants.Zero) &&
(Interlocked.CompareExchange(ref m_ReceiveStarted, RedisConstants.One, RedisConstants.Zero) == RedisConstants.Zero))
{
try
{
var availableLength = m_BufferSize - m_WritePosition;
if (availableLength < 1)
{
Interlocked.Exchange(ref m_WritePosition, Beginning);
Interlocked.Exchange(ref m_ReadPosition, Beginning);
availableLength = m_BufferSize;
}
if (length > 0)
{
length = Math.Max(length, socket.Available);
}
var receiveSize = (length < 0) ? availableLength : Math.Min(length, availableLength);
var timeout = false;
var received = false;
double receiveTimeout = m_ReceiveTimeout;
var infiniteTimeout = (long)receiveTimeout == Timeout.Infinite;
var stream = socket.GetRealStream();
var readStatus = SocketError.Success;
do
{
try
{
var now = DateTime.UtcNow;
var receivedLength = 0;
if (!socket.UseSsl)
{
receivedLength = socket.Receive(m_Buffer, m_WritePosition, receiveSize, SocketFlags.None, out readStatus);
}
else
{
try
{
readStatus = SocketError.Success;
receivedLength = stream.Read(m_Buffer, m_WritePosition, receiveSize);
}
catch (Exception e)
{
while (e != null)
{
e = e.InnerException;
if (e is SocketException)
{
readStatus = ((SocketException)e).SocketErrorCode;
break;
}
}
if (readStatus != SocketError.Success)
{
throw;
}
}
}
if (readStatus == SocketError.TimedOut ||
readStatus == SocketError.WouldBlock)
{
if (!infiniteTimeout)
{
receiveTimeout -= (DateTime.UtcNow - now).TotalMilliseconds;
if (receiveTimeout <= 0)
{
timeout = true;
throw new SocketException((int)SocketError.TimedOut);
}
}
continue;
}
received = true;
if (receivedLength > 0)
{
IncrementWritePosition(receivedLength);
}
else if (receivedLength == 0)
{
Interlocked.Exchange(ref m_ReadState, RedisConstants.Zero);
}
return(receivedLength);
}
catch (SocketException e)
{
if (!infiniteTimeout ||
!(e.SocketErrorCode == SocketError.TimedOut ||
e.SocketErrorCode == SocketError.WouldBlock))
{
throw;
}
}
catch (Exception e)
{
if (!(e is SocketException))
{
Interlocked.Exchange(ref m_ReceiveStarted, RedisConstants.Zero);
}
}
}while (!(received || timeout) && (Interlocked.Read(ref m_ReadState) != RedisConstants.Zero));
}
finally
{
Interlocked.Exchange(ref m_ReceiveStarted, RedisConstants.Zero);
}
}
return(int.MinValue);
}
