private void PushMessage(RESPArray message)
{
var subscribers = Subscriptions.GetSubscribedTo(message);
var notification = RedisNotification.ParseArray(message);
foreach (var channel in subscribers.Cast <RedisChannel>())
{
Task.Run(() => channel.PushMessage(notification));
}
}
internal Boolean IsMessage(RESPObject response, out RESPArray message)
{
message = null;
if (response.Header != RESPHeaders.Array)
{
return(false);
}
message = response.Cast <RESPArray>();
return(IsSubscriptionMessage(message.ElementAt <RESPBulkString>(0).Value.ToUpperInvariant()));
}
internal IEnumerable <IRedisChannel> GetSubscribedTo(RESPArray message)
{
Contract.Assert(message.Any(), "Empty RESPArray");
var operation = message.ElementAt <RESPBulkString>(0).Value.ToUpperInvariant();
if (!IsSubscriptionMessage(operation))
{
return(Enumerable.Empty <IRedisChannel>());
}
var aggregator = operation.Equals("MESSAGE", StringComparison.Ordinal) ? _subscriptions : _psubscriptions;
return(aggregator.GetChannels(message.ElementAt <RESPBulkString>(1).Value));
}
internal static RedisNotification ParseArray(RESPArray array)
{
var header = array.ElementAt <RESPBulkString>(0).Value.ToUpperInvariant();
if (header.Equals("PMESSAGE", StringComparison.Ordinal))
{
return(new RedisNotification(header, array.ElementAt <RESPBulkString>(1).Value, array.ElementAt <RESPBulkString>(2).Value, array.ElementAt <RESPBulkString>(3).Value));
}
else if (header.Equals("MESSAGE", StringComparison.Ordinal))
{
return(new RedisNotification(header, array.ElementAt <RESPBulkString>(1).Value, array.ElementAt <RESPBulkString>(2).Value));
}
else
{
return(new RedisNotification(header));
}
}
internal void Acknowledge(RESPArray response)
{
Contract.Assert(response.Any(), "Empty RESPArray");
var operation = response.ElementAt <RESPBulkString>(0).Value.ToUpperInvariant();
var key = response.ElementAt <RESPBulkString>(1).Value;
switch (operation)
{
case "SUBSCRIBE":
case "PSUBSCRIBE":
AcknowledgeSubscription(key);
break;
case "UNSUBSCRIBE":
case "PUNSUBSCRIBE":
AcknowledgeUnsubscription(key);
break;
}
}
internal static void Bind(RESPArray array, T instance, Boolean ignoreMissingMembers = true, Boolean ignoreTypeMismatchMembers = true)
{
var type = typeof(T);
if (_setters == null)
{
var setter = Create();
Interlocked.CompareExchange(ref _setters, setter, null);
}
for (int i = 0; i < array.Count; i += 2)
{
var member = array[i];
var memberName = GetPropertyName(member, i);
Setter <T> setter;
if (!_setters.TryGetValue(memberName, out setter))
{
if (!ignoreMissingMembers)
{
throw new RedisClientBindingException("The result contains property '" + memberName + "' but the object to bind to does not have such member");
}
}
else
{
if (setter == null)
{
if (!ignoreTypeMismatchMembers)
{
throw new RedisClientBindingException("The target object contains a member named '" + memberName + "' but the type is not compatible with the one in the result (" + member.GetType().ToString() + ")");
}
}
else
{
SetValue(memberName, instance, i < array.Count ? array[i + 1] : null, setter);
}
}
}
}
internal static RESPArray Load(SocketReader reader)
{
Int32 itemCount = reader.ReadInt32();
if (itemCount < 0)
{
return(RESPArray.Empty);
}
var array = new RESPArray(itemCount);
for (int i = 0; i < itemCount; i++)
{
var obj = RESPObject.Read(reader);
if (obj == null)
{
throw new RESPException("Cannot read array elements.");
}
array._items[i] = obj;
}
return(array);
}
static RESPObject ProcessResponse(Char?header, SocketReader reader)
{
if (!header.HasValue)
{
return(null);
}
switch (header)
{
case RESPHeaders.SimpleString: return(RESPSimpleString.Load(reader));
case RESPHeaders.BulkString: return(RESPBulkString.Load(reader));
case RESPHeaders.Array: return(RESPArray.Load(reader));
case RESPHeaders.Error: return(RESPError.Load(reader));
case RESPHeaders.Integer: return(RESPInteger.Load(reader));
default: throw new RESPException("Unrecognized RESP header (byte): " + (byte)header.Value);
}
}
