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) { }