internal void Add(IRedisRawResponse item)
{
ValidateNotDisposed();
if (m_Type != RedisRawObjectType.Array)
{
throw new ArgumentException("Can not add item to " + Type.ToString("F") + " type", "item");
}
if (item == null)
{
throw new ArgumentNullException("item");
}
if (item == this)
{
throw new ArgumentException("Circular reference", "item");
}
var response = item as RedisRawResponse;
if (response != null)
{
response.SetParent(this);
}
var list = GetArrayList();
list.Add(item);
SetReady(list.Count >= Length);
}
public RedisRawResponse(IRedisRawResponse parent = null, RedisRawObjectType type = RedisRawObjectType.Undefined)
{
m_Parent = parent;
if (type != RedisRawObjectType.Undefined)
{
SetType(type);
}
}
public static RedisSlowLogInfo[] ToSlowLogInfo(IRedisRawResponse 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);
}
protected static double?ForNullableDouble(IRedisRawResponse response, bool throwException)
{
if (response == null)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
if (response.Type == RedisRawObjectType.Array ||
response.Type == RedisRawObjectType.Undefined)
{
if (throwException)
{
throw new RedisException("Invalid data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
var data = response.Data;
if (data == null)
{
return(null);
}
if (data.Length == 0)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
if (data.EqualTo(RedisConstants.Nil))
{
return(null);
}
double result;
if (double.TryParse(data.ToUTF8String(), out result))
{
return(result);
}
if (throwException)
{
throw new RedisException("Not a double result", RedisErrorCode.CorruptResponse);
}
return(null);
}
protected virtual void OnReceiveResponse(IRedisRawResponse response)
{
if (!Disposed)
{
var onReceiveResponse = m_OnReceiveResponse;
if (onReceiveResponse != null)
{
onReceiveResponse(response);
}
}
}
public static RedisMonitorMessage ToMonitorMessage(IRedisRawResponse response)
{
if (!ReferenceEquals(response, null) &&
response.Type == RedisRawObjectType.SimpleString)
{
var data = response.Data;
if (data != null)
{
var timeEndPos = data.IndexOf((byte)' ', 0, 100);
if (timeEndPos > 0)
{
var timeStr = data.ToUTF8String(0, timeEndPos);
if (!timeStr.IsEmpty())
{
var clientStartPos = data.IndexOf((byte)'[', timeEndPos + 1, 10);
if (clientStartPos > -1)
{
var clientEndPos = data.IndexOf((byte)']', clientStartPos + 1, 100);
if (clientEndPos > -1)
{
var time = DateTime.MinValue;
var dotPos = timeStr.IndexOf('.');
if (dotPos < 0)
{
time = timeStr.ToInt().FromUnixTimeStamp();
}
else
{
time = ((dotPos == 0) ? "0" : timeStr.Substring(0, dotPos)).ToInt()
.FromUnixTimeStamp(timeStr.Substring(dotPos + 1, timeStr.Length - dotPos - 1).ToInt(0));
}
byte[] msgData = null;
var clientInfo = data.ToUTF8String(clientStartPos, clientEndPos - clientStartPos + 1);
clientEndPos += 2;
if (clientEndPos < data.Length)
{
msgData = new byte[data.Length - clientEndPos];
Buffer.BlockCopy(data, clientEndPos, msgData, 0, msgData.Length);
}
return(new RedisMonitorMessage(time, clientInfo, msgData));
}
}
}
}
}
}
return(RedisMonitorMessage.Empty);
}
internal void SetParent(IRedisRawResponse value)
{
var parent = Interlocked.Exchange(ref m_Parent, value);
if (parent != null && value != parent)
{
var response = parent as RedisRawResponse;
if (response != null)
{
response.Remove(this);
}
}
}
protected static long?ForNullableInteger(IRedisRawResponse response, bool throwException)
{
if (response == null)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
if (response.Type != RedisRawObjectType.Integer)
{
if (throwException)
{
throw new RedisException("Invalid data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
var data = response.Data;
if (data.IsEmpty())
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
if (data.EqualTo(RedisConstants.Nil))
{
return(null);
}
long result;
if (long.TryParse(data.ToUTF8String(), out result))
{
return(result);
}
if (throwException)
{
throw new RedisException("Not an integer result", RedisErrorCode.CorruptResponse);
}
return(null);
}
protected virtual void ResponseReceived(IRedisRawResponse response)
{
m_LastMessageSeenTime = DateTime.UtcNow;
if (CanSendResponse(response))
{
var subscriptions = m_Subscriptions;
if (subscriptions != null)
{
T message;
if (TryConvertResponse(response, out message))
{
subscriptions.Invoke(message);
}
}
}
}
protected static double ForDouble(IRedisRawResponse response, bool throwException)
{
if (response == null)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(double.MinValue);
}
if (response.Type == RedisRawObjectType.Array ||
response.Type == RedisRawObjectType.Undefined)
{
if (throwException)
{
throw new RedisException("Invalid data returned", RedisErrorCode.CorruptResponse);
}
return(double.MinValue);
}
var data = response.Data;
if (data.IsEmpty())
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(double.MinValue);
}
double result;
if (double.TryParse(data.ToUTF8String(), out result))
{
return(result);
}
if (throwException)
{
throw new RedisException("Not a double result", RedisErrorCode.CorruptResponse);
}
return(double.MinValue);
}
private static bool TryParseInteger(IRedisRawResponse response, out long value)
{
value = RedisConstants.Zero;
if (response != null &&
response.Type == RedisRawObjectType.Integer)
{
var data = response.Data;
if (!data.IsEmpty())
{
value = RedisConstants.MinusOne;
if (long.TryParse(data.ToUTF8String(), out value))
{
return(true);
}
}
}
return(false);
}
private static string ParseBulkString(IRedisRawResponse response)
{
if (response != null &&
response.Type == RedisRawObjectType.BulkString)
{
var data = response.Data;
if (data == null)
{
return(null);
}
if (data.Length == 0)
{
return(String.Empty);
}
return(data.ToUTF8String());
}
return(null);
}
private static string[] ParseCommandInfo(IRedisRawResponse 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)
{
var data = item.Data;
if (data == null)
{
result.Add(null);
}
else if (data.Length == 0)
{
result.Add(String.Empty);
}
else
{
result.Add(data.ToUTF8String());
}
}
}
return(result.ToArray());
}
}
}
return(null);
}
protected override void OnResponse(IRedisRawResponse response)
{
if (response != null && Receiving)
{
m_ReceivedResponseQ.Enqueue(response);
if (Interlocked.CompareExchange(ref m_ProcessingReceivedQ, RedisConstants.One, RedisConstants.Zero) ==
RedisConstants.Zero)
{
Action qProcess = () =>
{
try
{
IRedisRawResponse qItem;
while (m_ReceivedResponseQ.TryDequeue(out qItem))
{
try
{
var onReceive = m_OnReceive;
if (onReceive != null)
{
onReceive.InvokeAsync(qItem);
}
}
catch (Exception)
{ }
}
}
finally
{
Interlocked.Exchange(ref m_ProcessingReceivedQ, RedisConstants.Zero);
}
};
qProcess.InvokeAsync();
}
}
}
internal void Remove(IRedisRawResponse item)
{
ValidateNotDisposed();
if (m_Type != RedisRawObjectType.Array)
{
throw new ArgumentException("Can not add/remove item to/from " + Type.ToString("F") + " type", "item");
}
if (item == null)
{
throw new ArgumentNullException("item");
}
if (item == this)
{
throw new ArgumentException("Circular reference", "item");
}
if (item.Parent != this)
{
throw new ArgumentException("Item does not belong to this response", "item");
}
var response = item as RedisRawResponse;
if (response != null)
{
response.SetParent(null);
}
var list = GetArrayList();
list.Remove(item);
SetReady(list.Count >= Length);
}
public static RedisPubSubResponse ToPubSubResponse(IRedisRawResponse response)
{
if (response != null &&
response.Type == RedisRawObjectType.Array)
{
var items = response.Items;
if (items != null && items.Count >= 3)
{
var index = 0;
var typeItem = items[index++];
if (typeItem != null && typeItem.Type == RedisRawObjectType.BulkString)
{
var data = typeItem.Data;
if (data != null)
{
var typeStr = data.ToUTF8String().ToLowerInvariant();
if (!typeStr.IsEmpty())
{
var type = RedisPubSubResponseType.Undefined;
switch (typeStr)
{
case "message":
type = RedisPubSubResponseType.Message;
break;
case "pmessage":
type = RedisPubSubResponseType.PMessage;
break;
case "subscribe":
type = RedisPubSubResponseType.Subscribe;
break;
case "psubscribe":
type = RedisPubSubResponseType.PSubscribe;
break;
case "unsubscribe":
type = RedisPubSubResponseType.Unsubscribe;
break;
case "punsubscribe":
type = RedisPubSubResponseType.PUnsubscribe;
break;
default:
break;
}
if (type != RedisPubSubResponseType.Undefined)
{
if (type == RedisPubSubResponseType.PMessage && items.Count < 4)
{
return(RedisPubSubResponse.Empty);
}
var channelItem = items[index++];
if (channelItem != null && channelItem.Type == RedisRawObjectType.BulkString)
{
data = channelItem.Data;
if (data != null)
{
var channel = data.ToUTF8String();
if (!channel.IsEmpty())
{
var pattern = String.Empty;
switch (type)
{
case RedisPubSubResponseType.PMessage:
{
var patternItem = items[index++];
if (patternItem != null)
{
data = patternItem.Data;
if (data != null)
{
pattern = data.ToUTF8String();
}
}
var tmp = channel;
channel = pattern;
pattern = tmp;
}
break;
case RedisPubSubResponseType.PSubscribe:
case RedisPubSubResponseType.PUnsubscribe:
{
pattern = channel;
channel = String.Empty;
}
break;
default:
break;
}
var dataItem = items[index++];
if (dataItem != null)
{
data = dataItem.Data;
switch (dataItem.Type)
{
case RedisRawObjectType.Integer:
{
var value = -1L;
if (data != null)
{
long.TryParse(data.ToUTF8String(), out value);
}
return(new RedisPubSubResponse(type, typeStr, channel, pattern, value));
}
case RedisRawObjectType.BulkString:
return(new RedisPubSubResponse(type, typeStr, channel, pattern, dataItem.Data));
default:
break;
}
}
}
}
}
}
}
}
}
}
}
return(RedisPubSubResponse.Empty);
}
protected static byte[][] ForMultiDataBytes(IRedisRawResponse response, bool throwException)
{
if (response == null)
{
if (throwException)
{
throw new RedisException("No data returned", RedisErrorCode.CorruptResponse);
}
return(null);
}
var data = response.Data;
switch (response.Type)
{
case RedisRawObjectType.SimpleString:
case RedisRawObjectType.BulkString:
case RedisRawObjectType.Integer:
return(data != null ? new byte[][] { data } : null);
case RedisRawObjectType.Error:
{
if (!throwException)
{
return data != null ? new byte[][] { data }
}
: null;
throw new RedisException(!data.IsEmpty() ? data.ToUTF8String() : "No data returned", RedisErrorCode.CorruptResponse);
}
case RedisRawObjectType.Undefined:
if (throwException)
{
throw new RedisException("Undefined respone data", RedisErrorCode.CorruptResponse);
}
return(null);
case RedisRawObjectType.Array:
{
var len = response.Length;
if (len < 0)
{
return(null);
}
if (len == 0)
{
return new byte[0][] { }
}
;
var items = response.Items;
if (items != null)
{
var list = new List <byte[]>();
len = items.Count;
for (var i = 0; i < len; i++)
{
var item = items[i];
if (item == null)
{
list.Add(null);
}
else
{
if (item.Type == RedisRawObjectType.Undefined)
{
if (throwException)
{
throw new RedisException("Undefined respone data", RedisErrorCode.CorruptResponse);
}
return(null);
}
if (item.Type == RedisRawObjectType.Array)
{
if (throwException)
{
throw new RedisException("Multi-array is not allowed for multi-data respone", RedisErrorCode.CorruptResponse);
}
return(null);
}
list.Add(item.Data);
}
}
return(list.ToArray());
}
return(null);
}
default:
break;
}
return(null);
}
private void ResponseReceived(IRedisRawResponse response)
{
m_LastMessageSeenTime = DateTime.UtcNow;
var pubSubResp = RedisPubSubResponse.ToPubSubResponse(response);
if (!pubSubResp.IsEmpty)
{
switch (pubSubResp.Type)
{
case RedisPubSubResponseType.Message:
{
var subscriptions = m_Subscriptions;
if (subscriptions != null &&
subscriptions.HasCallbacks(pubSubResp.Channel))
{
subscriptions.Invoke(ToPubSubMessage(pubSubResp));
}
}
break;
case RedisPubSubResponseType.PMessage:
{
var subscriptions = m_PSubscriptions;
if (subscriptions != null &&
subscriptions.HasCallbacks(pubSubResp.Pattern))
{
subscriptions.Invoke(ToPubSubMessage(pubSubResp));
}
}
break;
case RedisPubSubResponseType.Subscribe:
{
lock (m_SubscriptionLock)
{
var bag = m_PendingSubscriptions.Drop(pubSubResp.Channel);
m_Subscriptions.Register(pubSubResp.Channel, bag);
}
}
break;
case RedisPubSubResponseType.PSubscribe:
{
lock (m_PSubscriptionLock)
{
var bag = m_PendingPSubscriptions.Drop(pubSubResp.Pattern);
m_PSubscriptions.Register(pubSubResp.Pattern, bag);
}
}
break;
case RedisPubSubResponseType.Unsubscribe:
{
lock (m_SubscriptionLock)
{
if (pubSubResp.Channel.IsEmpty())
{
m_PendingSubscriptions.UnregisterAll();
m_Subscriptions.UnregisterAll();
}
else
{
if (!m_Subscriptions.Unregister(pubSubResp.Channel))
{
m_PendingSubscriptions.Unregister(pubSubResp.Channel);
}
}
}
}
break;
case RedisPubSubResponseType.PUnsubscribe:
{
lock (m_PSubscriptionLock)
{
if (pubSubResp.Pattern.IsEmpty())
{
m_PendingPSubscriptions.UnregisterAll();
m_PSubscriptions.UnregisterAll();
}
else
{
if (!m_PSubscriptions.Unregister(pubSubResp.Pattern))
{
m_PendingPSubscriptions.Unregister(pubSubResp.Pattern);
}
}
}
}
break;
default:
break;
}
}
}
protected virtual bool TryConvertResponse(IRedisRawResponse response, out T value)
{
value = default(T);
return(true);
}
protected virtual bool CanSendResponse(IRedisRawResponse response)
{
return(!ReferenceEquals(response, null));
}
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);
}
protected override bool TryConvertResponse(IRedisRawResponse response, out RedisMonitorMessage value)
{
value = RedisMonitorMessage.ToMonitorMessage(response);
return(!value.IsEmpty);
}
protected virtual void OnResponse(IRedisRawResponse response)
{
}
