/// <summary>
/// Retrieves a range of elements from the specified stream
/// </summary>
/// <param name="streamName">Name of the stream</param>
/// <param name="start">The identifier or timestamp in ms of the range start</param>
/// <param name="end">The identifier or timestamp in ms of the range end</param>
/// <returns></returns>
public List <RedisStreamEntry> XRange(RedisValue streamName, RedisValue?start, RedisValue?end)
{
if (!start.HasValue && !end.HasValue)
{
//Return all results
start = "-";
end = "+";
}
//If only a single value is provided, assume they are targeting a single record
else if (start.HasValue && !end.HasValue)
{
end = start;
}
else if (!start.HasValue)
{
start = end;
}
List <RedisStreamEntry> entries = new List <RedisStreamEntry>();
var res = _redisDb.Execute("XRANGE", streamName, start, end);
foreach (RedisResult[] item in (RedisResult[])res)
{
var keyValue = (RedisResult[])item[1];
entries.Add(new RedisStreamEntry
{
Id = item[0],
Key = keyValue[0],
Value = keyValue[1]
});
}
return(entries);
}
/// <inheritdoc />
public async Task <object?> GetHashFieldAsync(string hashKey, string fieldKey)
{
RedisValue?value = await ExecuteRedisCommandAsync(() =>
{
IDatabase db = GetRedisDatabase();
return(db.HashGetAsync(hashKey, fieldKey));
});
if ((value == null) || value.Value.IsNullOrEmpty || string.IsNullOrWhiteSpace(value.Value.ToString()))
{
return(null);
}
else
{
if (value.Value.TryParse(out long lngval))
{
return(lngval);
}
else if (value.Value.TryParse(out double dblval))
{
return(dblval);
}
else
{
return(value.Value.ToString());
}
}
}
/// <summary>
/// Appends an element to the specified stream
/// </summary>
/// <param name="streamName">Name of the stream</param>
/// <param name="id">Explicit identifier and instance number for the entry in the stream (ie:1523598632996-0) </param>
/// <param name="key">The key for the entry</param>
/// <param name="value">The value for the entry</param>
/// <returns>The identifier of the element that was appended to the stream</returns>
public RedisResult XAdd(RedisValue streamName, RedisValue?id, RedisValue key, RedisValue value)
{
if (!id.HasValue)
{
id = "*"; //Auto assign id
}
Debug.Assert(id != null, nameof(id) + " != null");
return(_redisDb.Execute("XADD", streamName, id.Value, key, value));
}
public ListCondition(RedisKey key, long index, bool expectedResult, RedisValue?expectedValue)
{
if (key.IsNull)
{
throw new ArgumentException(nameof(key));
}
this.key = key;
this.index = index;
this.expectedResult = expectedResult;
this.expectedValue = expectedValue;
}
private static async Task ReceiveEvents(IDatabase db, CancellationToken cancel)
{
const int STEPS = 40;
const char FILLER = ' ';
var SPACING = new string(' ', 50);
var FULLY_FILLED = new string(FILLER, STEPS) + FILLER;
await Task.Run(async() =>
{
RedisValue?minID = null;
while (!cancel.IsCancellationRequested)
{
// return next N elements, depending on order and minID
var processed = 0;
foreach (var entry in await db.StreamRangeAsync(STREAM_NAME, minID, null, 10))
{
// extract and format the data
var cpu = -1;
var sb = new StringBuilder();
sb.AppendFormat("{0}:", entry.Id);
foreach (var value in entry.Values)
{
sb.AppendFormat(" {0} = {1} ", value.Name, value.Value);
if (value.Name.Equals("CPU"))
{
int.TryParse(value.Value, out cpu);
}
}
// first print the CPU graph, then write the textual data line
if (cpu >= 0)
{
var count = (int)(1.0 * cpu *STEPS / 100.0);
Console.Write("{0}|{1}|{2,3} %\r", SPACING, FULLY_FILLED, cpu);
Console.Write("{0}|{1}*\r", SPACING, new string(FILLER, count));
}
Console.WriteLine(sb.ToString());
// increment to get the next entry
minID = entry.Id + "1";
++processed;
}
// nbo data, so trim the stream and wait for more
if (processed == 0)
{
await db.StreamTrimAsync(STREAM_NAME, 32);
await Task.Delay(200);
}
}
}, cancel);
}
private RedisValue Increment(RedisValue?position)
{
if (position == null || position == StreamPosition.Beginning)
{
return(StreamPosition.Beginning);
}
var key = position.ToString().Split("-");
int count = int.Parse(key[1]);
count++;
return(key[0] + "-" + count.ToString());
}
public static IEnumerable <HashEntry> ToHash <T>(this T obj) where T : struct
{
IEnumerable <FieldInfo> fields = obj.GetType().GetFields();
foreach (FieldInfo field in fields.Where(t => t.IsPublic))
{
RedisValue?value = field.GetValue(obj)?.GetRedisValue();
if (value == null)
{
continue;
}
yield return(new HashEntry(field.Name, value.Value));
}
}
/// <inheritdoc />
public async Task <string> GetListElementAtIndexAsync(string key, long index)
{
RedisValue?val = await ExecuteRedisCommandAsync(() =>
{
IDatabase db = GetRedisDatabase();
return(db.ListGetByIndexAsync(key, index));
});
if ((val == null) || val.Value.IsNullOrEmpty || string.IsNullOrWhiteSpace(val.Value.ToString()))
{
throw new ArgumentException($"No element found at index {index}");
}
else
{
return(val.Value.ToString());
}
}
private async static Task CheckPendingMessages(CancellationToken cancel)
{
Console.WriteLine("Checking pending messages ...");
const int ALLOWED_IDLE_MSEC = 1 * 60 * 1000;
bool bMoreData = true;
RedisValue?nextMsg = null;
while (bMoreData)
{
bMoreData = false;
foreach (var msg in await db.StreamPendingMessagesAsync(STREAM_NAME, Group, 10, RedisValue.Null, nextMsg))
{
LastConsumedMsgID = msg.MessageId;
nextMsg = LastConsumedMsgID + "1"; // continue with next one
bMoreData = true;
Console.Write('.');
// try to claim it, checking against ALLOWED_IDLE_MSEC
var entries = await db.StreamClaimAsync(STREAM_NAME, Group, Consumer, ALLOWED_IDLE_MSEC, new RedisValue[1] {
LastConsumedMsgID.Value
});
foreach (var entry in entries)
{
if (!entry.IsNull) // something to process
{
Console.Write('\r');
await ProcessMessageAsync(entry, cancel);
}
else
{
Console.WriteLine("\r- {0} left pending", LastConsumedMsgID.Value);
}
}
}
}
}
private void AssertConversionEqual <T>(RedisTypeConverter converter, T value,
RedisValue?expectedRedisValue = null)
{
// check from(to(V)) == V (explicit type version)
var rv1 = converter.GetToRedisValueFunc <T>()(value);
var nv1 = converter.GetFromRedisValueFunc <T>()(rv1);
Assert.Equal(value, nv1);
// check from(to(V)) == V (object type version)
var rv2 = converter.GetToRedisValueFunc(typeof(T))(value);
var nv2 = converter.GetFromRedisValueFunc(typeof(T))(rv2);
Assert.Equal(value, nv2);
// check to1(V) == to2(V)
Assert.Equal(rv1, rv2);
if (expectedRedisValue != null)
{
Assert.Equal(expectedRedisValue.Value, rv1);
}
}
StreamPendingMessageInfo[] IDatabase.StreamPendingMessages(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue?minId, RedisValue?maxId, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamPendingMessagesAsync(key, groupName, count, consumerName, minId, maxId, flags));
public RedisStreamEntry[] StreamRange(RedisKey key, RedisValue?minId = null, RedisValue?maxId = null, int?count = null, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamRange(ToInner(key), minId, maxId, count, order, flags));
}
public Task <StreamEntry[]> StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue?position, int?count, CommandFlags flags)
{
return(Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, flags));
}
public Task <StreamPendingMessageInfo[]> StreamPendingMessagesAsync(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue?minId = null, RedisValue?maxId = null, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamPendingMessagesAsync(ToInner(key), groupName, count, consumerName, minId, maxId, flags));
}
public Task <bool> StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue?position, CommandFlags flags)
{
return(Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, flags));
}
public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue?position = null, int?count = null, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamReadGroup(ToInner(key), groupName, consumerName, position, count, flags));
}
public RedisValue StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue?messageId = null, int?maxLength = null, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamAdd(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags));
}
bool IDatabase.StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue?position, bool createStream, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamCreateConsumerGroupAsync(key, groupName, position, createStream, flags));
RedisValue IDatabase.StreamAdd(RedisKey key, NameValueEntry[] streamPairs, RedisValue?messageId, int?maxLength, bool useApproximateMaxLength, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamAddAsync(key, streamPairs, messageId, maxLength, useApproximateMaxLength, flags));
RedisValue IDatabase.StreamAdd(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue?messageId, int?maxLength, bool useApproximateMaxLength, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamAddAsync(key, streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags));
public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue?position = null, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamCreateConsumerGroup(ToInner(key), groupName, position, flags));
}
StreamEntry[] IDatabase.StreamRange(RedisKey key, RedisValue?minId, RedisValue?maxId, int?count, Order messageOrder, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamRangeAsync(key, minId, maxId, count, messageOrder, flags));
public Task <RedisValue> StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, RedisValue?messageId = null, int?maxLength = null, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamAddAsync(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, flags));
}
StreamEntry[] IDatabase.StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue?position, int?count, bool noAck, CommandFlags flags) => Multiplexer.Wait(((IDatabaseAsync)this).StreamReadGroupAsync(key, groupName, consumerName, position, count, noAck, flags));
public Task <bool> StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue?position = null, bool createStream = true, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, createStream, flags));
}
public Task <RedisValue> StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue?messageId = null, int?maxLength = null, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
{
return(this.db.StreamAddAsync(key, streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags));
}
public Task <StreamEntry[]> StreamRangeAsync(RedisKey key, RedisValue?minId = null, RedisValue?maxId = null, int?count = null, Order messageOrder = Order.Ascending, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamRangeAsync(ToInner(key), minId, maxId, count, messageOrder, flags));
}
public Task <bool> StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue?position = null, CommandFlags flags = CommandFlags.None)
{
return(this.db.StreamCreateConsumerGroupAsync(key, groupName, position, flags));
}
public Task <StreamEntry[]> StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue?position = null, int?count = null, bool noAck = false, CommandFlags flags = CommandFlags.None)
{
return(Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, noAck, flags));
}
public Task <StreamEntry[]> StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue?position = null, int?count = null, CommandFlags flags = CommandFlags.None)
{
return(this.db.StreamReadGroupAsync(key, groupName, consumerName, position, count, flags));
}