private static string[] ParseCommandInfo(RedisRawObject response)
{
if (response != null &&
response.Type == RedisRawObjectType.Array)
{
var items = response.Items;
if (items != null)
{
var count = items.Count;
if (count > 0)
{
var result = new List <string>(count);
foreach (var item in items)
{
if (item != null &&
item.Type == RedisRawObjectType.BulkString)
{
result.Add(item.DataText);
}
}
return(result.ToArray());
}
}
}
return(null);
}
public static RedisSlowLogInfo[] ToSlowLogInfo(RedisRawObject response)
{
if (response != null &&
response.Type == RedisRawObjectType.Array)
{
var children = response.Items;
if (children != null && children.Count > 0)
{
var result = new List <RedisSlowLogInfo>(children.Count);
foreach (var child in children)
{
if (child != null &&
child.Type == RedisRawObjectType.Array)
{
var items = child.Items;
if (items != null && items.Count >= 4)
{
long id;
if (TryParseInteger(items[0], out id))
{
long timeL;
if (TryParseInteger(items[1], out timeL))
{
var time = timeL.FromUnixTimeStamp();
long durationL;
if (TryParseInteger(items[2], out durationL))
{
var duration = TimeSpan.FromMilliseconds(durationL);
var commandInfo = ParseCommandInfo(items[3]);
string clientInfo = null;
string clientName = null;
if (items.Count > 4)
{
clientInfo = ParseBulkString(items[4]);
if (items.Count > 5)
{
clientName = ParseBulkString(items[5]);
}
}
result.Add(new RedisSlowLogInfo(id, time, duration, clientInfo, clientName, commandInfo));
}
}
}
}
}
}
return(result.ToArray());
}
}
return(null);
}
public static RedisMasterRoleSlaveInfo Parse(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) && rawObject.Type == RedisRawObjectType.Array)
{
var list = rawObject.Items;
if (list != null)
{
var count = list.Count;
if (count > 0)
{
var result = new RedisMasterRoleSlaveInfo();
var item = list[0];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
result.IPAddress = item.DataText;
}
if (count > 1)
{
item = list[1];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var port = item.DataText;
if (!port.IsEmpty())
{
int i;
if (int.TryParse(port, out i))
{
result.Port = i;
}
}
}
if (count > 2)
{
item = list[2];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var offset = item.DataText;
if (!offset.IsEmpty())
{
long l;
if (long.TryParse(offset, out l))
{
result.ReplicationOffset = l;
}
}
}
}
}
return(result);
}
}
}
return(null);
}
private static string ParseBulkString(RedisRawObject response)
{
if (response != null &&
response.Type == RedisRawObjectType.BulkString)
{
return(response.DataText);
}
return(null);
}
protected virtual bool ProcessResult(IList <RedisRequest> requests, RedisRawObject rawObject)
{
if (requests != null)
{
var requestCount = requests.Count;
if (requestCount > 0)
{
var itemCount = 0;
IList <RedisRawObject> items = null;
if (!ReferenceEquals(rawObject, null))
{
items = rawObject.Items;
if (items != null)
{
itemCount = items.Count;
}
else
{
requests[0].ProcessResult(rawObject);
Cancel(requests, 1);
return(true);
}
}
for (var i = 0; i < requestCount; i++)
{
try
{
var request = requests[i];
if (ReferenceEquals(request, null))
{
continue;
}
var child = (i < itemCount) ? items[i] : null;
if (ReferenceEquals(child, null))
{
request.Cancel();
continue;
}
request.ProcessResult(child);
}
catch (Exception e)
{
SetException(requests, e, i);
throw;
}
}
return(true);
}
}
return(false);
}
private bool Receive(IList <RedisRequest> requests, RedisSocketContext context)
{
if (requests != null)
{
var requestCount = requests.Count;
if (requestCount > 0)
{
var socket = context.Socket;
if (socket.IsConnected())
{
using (var reader = new RedisSingleResponseReader(context.Settings))
{
for (var i = 0; i < requestCount; i++)
{
try
{
var request = requests[i];
if (ReferenceEquals(request, null))
{
continue;
}
var execResult = reader.Execute(socket);
if (ReferenceEquals(execResult, null))
{
throw new RedisFatalException("Corrupted redis response data", RedisErrorCode.CorruptResponse);
}
execResult.HandleError();
var rawObj = RedisRawObject.ToObject(execResult);
if (ReferenceEquals(rawObj, null))
{
throw new RedisFatalException("Corrupted redis response data", RedisErrorCode.CorruptResponse);
}
request.ProcessResult(rawObj);
}
catch (Exception e)
{
SetException(requests, e, i);
throw;
}
}
}
return(true);
}
}
}
return(false);
}
} // 0
#endregion Properties
#region Methods
public static RedisSentinelNodeInfo[] ParseInfoResponse(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) &&
rawObject.Type == RedisRawObjectType.Array)
{
var items = rawObject.Items;
if (items != null)
{
var count = items.Count;
if (count > 0)
{
var isInfoArray = true;
for (var i = 0; i < count; i++)
{
var item = items[i];
if (!ReferenceEquals(item, null) &&
item.Type != RedisRawObjectType.Array)
{
isInfoArray = false;
break;
}
}
if (!isInfoArray)
{
var info = new RedisSentinelNodeInfo(rawObject);
return(new[] { info });
}
var list = new List <RedisSentinelNodeInfo>(count);
for (var i = 0; i < count; i++)
{
var item = items[i];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.Array)
{
var info = new RedisSentinelNodeInfo(item);
list.Add(info);
}
}
if (list.Count > 0)
{
return(list.ToArray());
}
}
}
}
return(null);
}
public RedisRaw ExpectArray(RedisSocketContext context, bool throwException = true)
{
using (var response = ExecuteInternal(context, throwException))
{
if (response == null)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
return(new RedisRaw(RedisRawObject.ToObject(response)));
}
}
private static bool TryParseInteger(RedisRawObject response, out long value)
{
value = RedisConstants.Zero;
if (response != null &&
response.Type == RedisRawObjectType.Integer)
{
var data = response.Data;
if (data != null && data is long)
{
value = (long)data;
return(true);
}
}
return(false);
}
protected override void ParseInfo(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) && rawObject.Type == RedisRawObjectType.Array)
{
var list = rawObject.Items;
if (list != null)
{
var count = list.Count;
if (count > 1)
{
var item = list[1];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var data = item.Data;
if (data is long)
{
ReplicationOffset = (long)data;
}
else if (data is int)
{
ReplicationOffset = (int)data;
}
}
if (count > 2)
{
var slaves = new List <RedisMasterRoleSlaveInfo>(count - 2);
for (var i = 2; i < count; i++)
{
var slaveInfo = RedisMasterRoleSlaveInfo.Parse(list[i]);
if (slaveInfo != null)
{
slaves.Add(slaveInfo);
}
}
if (slaves.Count > 0)
{
Slaves = slaves.ToArray();
}
}
}
}
}
}
protected override void ParseInfo(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) && rawObject.Type == RedisRawObjectType.Array)
{
var list = rawObject.Items;
if (list != null)
{
var count = list.Count;
if (count > 1)
{
var item = list[1];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.Array)
{
var items = item.Items;
if (items != null)
{
var itemCount = items.Count;
if (itemCount > 0)
{
var masterNames = new List <string>(itemCount);
for (var i = 0; i < itemCount; i++)
{
item = items[i];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var masterName = item.DataText;
if (!masterName.IsEmpty())
{
masterNames.Add(masterName);
}
}
}
if (masterNames.Count > 0)
{
MasterNames = masterNames.ToArray();
}
}
}
}
}
}
}
}
public static RedisRoleInfo Parse(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) && rawObject.Type == RedisRawObjectType.Array)
{
var list = rawObject.Items;
if (list != null)
{
var count = list.Count;
if (count > 0)
{
var item = list[0];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var roleStr = item.DataText;
if (!roleStr.IsEmpty())
{
roleStr = roleStr.ToLowerInvariant();
var role = roleStr.ToRedisRole();
switch (role)
{
case RedisRole.Master:
case RedisRole.Slave:
case RedisRole.Sentinel:
{
var result = new RedisSentinelRoleInfo(roleStr);
result.ParseInfo(rawObject);
return(result);
}
default:
break;
}
}
}
}
}
}
return(null);
}
private static RedisGeoPosition ToGeoPosition(RedisRawObject obj)
{
if (obj != null && obj.Type == RedisRawObjectType.Array)
{
var items = obj.Items;
if (items != null && items.Count >= 2)
{
var item = items[0];
if (item != null && item.Type == RedisRawObjectType.BulkString)
{
var data = item.DataText;
if (!data.IsEmpty())
{
double longitude;
if (double.TryParse(data, out longitude))
{
item = items[1];
if (item != null && item.Type == RedisRawObjectType.BulkString)
{
data = item.DataText;
if (!data.IsEmpty())
{
double latitude;
if (double.TryParse(data, out latitude))
{
return(new RedisGeoPosition(longitude, latitude));
}
}
}
}
}
}
}
}
return(RedisGeoPosition.Empty);
}
} // 30000
#endregion Properties
#region Methods
protected virtual void Parse(RedisRawObject rawObject)
{
if (!ReferenceEquals(rawObject, null) && rawObject.Type == RedisRawObjectType.Array)
{
var items = rawObject.Items;
if (items != null)
{
var count = items.Count;
if (count > 0)
{
for (var i = 0; i < count; i += 2)
{
var item = items[i];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
var key = item.DataText;
if (!key.IsEmpty())
{
var value = (string)null;
if (i < count - 1)
{
item = items[i + 1];
if (!ReferenceEquals(item, null) && item.Type == RedisRawObjectType.BulkString)
{
value = item.DataText;
}
}
base[key] = value;
}
}
}
}
}
}
}
public static RedisGeoRadiusResult ToGeoRadiusResult(RedisRawObject obj)
{
if (obj != null)
{
if (obj.Type == RedisRawObjectType.BulkString)
{
var member = obj.DataText;
if (member != null)
{
return(new RedisGeoRadiusResult(member));
}
}
else if (obj.Type == RedisRawObjectType.Array)
{
var items = obj.Items;
if (items == null)
{
return(null);
}
var count = items.Count;
if (count < 1)
{
return(null);
}
object data;
string member = null;
double? distance = null;
long? hash = null;
RedisGeoPosition?coord = null;
var item = items[0];
if (item != null && item.Type == RedisRawObjectType.BulkString)
{
member = item.DataText;
}
for (var i = 1; i < count; i++)
{
var child = items[i];
if (child != null)
{
if (child.Type == RedisRawObjectType.Array)
{
coord = ToGeoPosition(child);
}
else
{
if (child.Type == RedisRawObjectType.Integer)
{
data = child.Data;
if (data is long)
{
hash = (long)data;
}
}
else if (child.Type == RedisRawObjectType.BulkString)
{
var str = child.DataText;
if (str != null)
{
var d = 0d;
if (double.TryParse(str, out d))
{
distance = d;
}
}
}
}
}
}
return(new RedisGeoRadiusResult(member, coord, distance, hash));
}
}
return(null);
}
private void ProcessReceiveQueue()
{
var queue = m_ReceiveQ;
if (queue == null)
{
return;
}
m_ReceiveGate.Reset();
var idleTime = 0;
var idleStart = DateTime.MinValue;
var request = (RedisAsyncRequest)null;
try
{
using (var reader = new RedisSingleResponseReader(Settings))
{
var idleTimeout = IdleTimeout;
while (Processing)
{
if (!queue.TryDequeue(out request))
{
if (m_ReceiveGate.Wait(SpinSleepTime))
{
m_ReceiveGate.Reset();
}
else
{
idleTime += SpinSleepTime;
if (idleTime >= idleTimeout)
{
break;
}
}
continue;
}
using (request)
{
if (idleTime > 0)
{
var command = request.Command;
if (ReferenceEquals(command, null) || !command.IsHeartBeat)
{
idleTime = 0;
}
}
try
{
var context = m_CurrentContext;
if (context == null)
{
continue;
}
if (!request.IsCompleted)
{
var socket = context.Socket;
if (socket.IsConnected())
{
try
{
var execResult = reader.Execute(socket);
if (ReferenceEquals(execResult, null))
{
throw new RedisFatalException("Corrupted redis response data", RedisErrorCode.CorruptResponse);
}
execResult.HandleError();
var rawObj = RedisRawObject.ToObject(execResult);
if (ReferenceEquals(rawObj, null))
{
throw new RedisFatalException("Corrupted redis response data", RedisErrorCode.CorruptResponse);
}
if (!request.ProcessResult(rawObj))
{
request.Cancel();
}
}
catch (Exception e)
{
request.SetException(e);
}
}
}
}
catch (Exception)
{ }
}
}
}
}
finally
{
while (queue.TryDequeue(out request))
{
try { request.Cancel(); }
catch (Exception) { }
}
}
}
public static RedisRawObject ToObject(IRedisRawResponse response)
{
if (response == null)
{
return(null);
}
var type = response.Type;
if (type == RedisRawObjectType.Undefined)
{
throw new RedisException("Undefined redis response", RedisErrorCode.CorruptResponse);
}
object data = null;
var bytes = response.Data;
if (bytes != null)
{
switch (type)
{
case RedisRawObjectType.SimpleString:
case RedisRawObjectType.Error:
data = bytes.ToUTF8String();
break;
case RedisRawObjectType.BulkString:
data = bytes;
break;
case RedisRawObjectType.Integer:
if (bytes.Length == 0)
{
throw new RedisException("Invalid integer value", RedisErrorCode.CorruptResponse);
}
long l;
if (!long.TryParse(bytes.ToUTF8String(), out l))
{
throw new RedisException("Invalid integer value", RedisErrorCode.CorruptResponse);
}
data = l;
break;
default:
break;
}
}
var result = new RedisRawObject(type, data);
result.TypeByte = response.TypeByte;
if (type == RedisRawObjectType.Array && response.Length > -1)
{
var list = new List <RedisRawObject>(response.Length);
result.m_List = new ReadOnlyCollection <RedisRawObject>(list);
if (response.Length > 0)
{
var items = response.Items;
if (items != null)
{
foreach (var item in items)
{
if (item != null)
{
var child = ToObject(item);
if (child != null)
{
list.Add(child);
}
}
}
}
}
}
return(result);
}
private static void Write(RedisRawObject obj, StringBuilder sBuilder, int indent = 0, int number = 0)
{
var indentStr = new string(' ', Math.Max(0, 2 * indent));
sBuilder.Append(indentStr);
if (number > 0)
{
sBuilder.Append(number);
sBuilder.Append(") ");
}
if (ReferenceEquals(obj, null))
{
sBuilder.AppendLine("(nil)");
return;
}
var data = obj.Data;
switch (obj.Type)
{
case RedisRawObjectType.BulkString:
{
var bytes = data as byte[];
if (bytes == null)
{
sBuilder.AppendLine("(nil)");
}
else if (bytes.Length == 0)
{
sBuilder.AppendLine("(empty)");
}
else
{
sBuilder.Append('"');
sBuilder.Append(bytes.ToUTF8String());
sBuilder.Append('"');
sBuilder.AppendLine();
}
}
break;
case RedisRawObjectType.SimpleString:
case RedisRawObjectType.Error:
{
if (obj.Type == RedisRawObjectType.Error)
{
sBuilder.Append("(error) ");
}
var str = data as string;
if (str == null)
{
sBuilder.AppendLine("(nil)");
}
else if (str == String.Empty)
{
sBuilder.AppendLine("(empty)");
}
else
{
sBuilder.Append('"');
sBuilder.Append(str);
sBuilder.Append('"');
sBuilder.AppendLine();
}
}
break;
case RedisRawObjectType.Integer:
{
sBuilder.Append("(integer) ");
object l = null;
if (data is long || data is double)
{
l = data;
}
if (l == null)
{
sBuilder.AppendLine("(nil)");
}
else
{
sBuilder.Append(l);
sBuilder.AppendLine();
}
}
break;
case RedisRawObjectType.Array:
{
if (obj.Count == 0)
{
sBuilder.AppendLine("(empty list or set)");
}
else
{
var items = obj.Items;
if (items == null || items.Count == 0)
{
sBuilder.AppendLine("(empty list or set)");
}
else
{
var length = items.Count;
for (var i = 0; i < length; i++)
{
Write(items[i], sBuilder, indent + 1, i + 1);
}
}
}
}
break;
default:
sBuilder.AppendFormat("(Unknown reply type: {0})", obj.TypeByte);
sBuilder.AppendLine();
break;
}
}
public virtual bool ProcessResult(RedisRawObject rawObj)
{
if (!ReferenceEquals(rawObj, null))
{
var data = rawObj.Data;
switch (Expectation)
{
case RedisCommandExpect.BulkString:
{
var str = ReferenceEquals(data, null) ? null :
(data is byte[] ? ((byte[])data).ToUTF8String() : data.ToString());
RedisString result = str;
SetResult(str);
}
return(true);
case RedisCommandExpect.BulkStringBytes:
{
var bytes = ReferenceEquals(data, null) ? null :
(data is byte[] ? (byte[])data : data.ToBytes());
RedisBytes result = bytes;
SetResult(result);
}
return(true);
case RedisCommandExpect.SimpleString:
{
var str = ReferenceEquals(data, null) ? null :
(data is string?(string)data : data.ToString());
if (m_OKIf.IsEmpty())
{
RedisString result = str;
SetResult(result);
}
else
{
RedisBool result = m_OKIf == str;
SetResult(result);
}
}
return(true);
case RedisCommandExpect.SimpleStringBytes:
{
var str = ReferenceEquals(data, null) ? null :
(data is string?(string)data : data.ToString());
if (m_OKIf.IsEmpty())
{
RedisBytes result = str.ToBytes();
SetResult(result);
}
else
{
RedisBool result = m_OKIf == str;
SetResult(result);
}
}
return(true);
case RedisCommandExpect.OK:
{
RedisBool result = RedisConstants.OK.Equals(data);
SetResult(result);
}
return(true);
case RedisCommandExpect.One:
{
RedisBool result = RedisConstants.One.Equals(data);
SetResult(result);
}
return(true);
case RedisCommandExpect.GreaterThanZero:
{
RedisBool result = RedisConstants.Zero.CompareTo(data) == -1;
SetResult(result);
}
return(true);
case RedisCommandExpect.Nothing:
SetResult(RedisVoidVal.Value);
return(true);
case RedisCommandExpect.Response:
case RedisCommandExpect.Array:
{
var response = data as RedisRawObject;
var result = new RedisRaw(response);
SetResult(result);
}
return(true);
case RedisCommandExpect.Double:
{
RedisDouble result = (double)data;
SetResult(result);
}
return(true);
case RedisCommandExpect.Integer:
{
if (data is long)
{
RedisInteger result = (long)data;
SetResult(result);
}
else
{
RedisInteger result = (int)data;
SetResult(result);
}
}
return(true);
case RedisCommandExpect.MultiDataBytes:
{
var bytes = data as byte[][];
RedisMultiBytes result = bytes;
SetResult(result);
}
return(true);
case RedisCommandExpect.MultiDataStrings:
{
var strings = data as string[];
RedisMultiString result = strings;
SetResult(result);
}
return(true);
case RedisCommandExpect.NullableDouble:
{
if (data is double)
{
RedisNullableDouble result = (double)data;
SetResult(result);
}
else if (data is double?)
{
RedisNullableDouble result = (double?)data;
SetResult(result);
}
else
{
var result = new RedisNullableDouble(null);
SetResult(result);
}
}
return(true);
case RedisCommandExpect.NullableInteger:
{
if (data is long)
{
RedisNullableInteger result = (long)data;
SetResult(result);
}
else if (data is long?)
{
RedisNullableInteger result = (long?)data;
SetResult(result);
}
else if (data is int)
{
RedisNullableInteger result = (int)data;
SetResult(result);
}
else if (data is int?)
{
RedisNullableInteger result = (int?)data;
SetResult(result);
}
else
{
var result = new RedisNullableInteger(null);
SetResult(result);
}
}
return(true);
default:
SetResult(data);
return(true);
}
}
return(false);
}
internal RedisSentinelInfoBase(RedisRawObject rawObject)
{
Parse(rawObject);
}
internal RedisSentinelNodeInfo(RedisRawObject rawObject)
: base(rawObject)
{
}
protected virtual void ParseInfo(RedisRawObject rawObject)
{
}
