public void StreamAddMultipleValuePairsWithManualId()
{
var id = "42-0";
var key = GetUniqueKey("manual_id_multiple_values");
using (var conn = Create())
{
Skip.IfMissingFeature(conn, nameof(RedisFeatures.Streams), r => r.Streams);
var db = conn.GetDatabase();
var fields = new NameValueEntry[]
{
new NameValueEntry("field1", "value1"),
new NameValueEntry("field2", "value2")
};
var messageId = db.StreamAdd(key, fields, id);
var entries = db.StreamRange(key);
Assert.Equal(id, messageId);
Assert.NotNull(entries);
Assert.True(entries.Length == 1);
Assert.Equal(id, entries[0].Id);
}
}
public async Task when_create_event_then_its_in_item_detail_view(Guid id, string itemName)
{
string json = $"{{\"Id\": \"{id}\",\"Name\": \"{itemName}\", \"Version\": 0}}";
var streamName = $"inventory-InventoryItemLogic{id}";
var jsonBytes = Encoding.UTF8.GetBytes(json);
var eventData = new NameValueEntry[]
{
new NameValueEntry("id", Guid.NewGuid().ToString()),
new NameValueEntry("type", "SimpleCQRS.InventoryItemCreated"),
new NameValueEntry("msg", jsonBytes),
new NameValueEntry("partition", string.Empty),
new NameValueEntry("metadata", string.Empty)
};
var result = await connection.StreamAddAsync(streamName, eventData);
await connection.StreamAddAsync("$ce-inventory", new NameValueEntry[]
{
new NameValueEntry("stream", streamName),
new NameValueEntry("key", result),
});
await Task.Delay(sleepMillisecondsDelay);
using var response = await client.GetAsync($"items/{id}");
var jsonResponse = await client.GetStringAsync($"items/{id}");
dynamic itemDetail = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(jsonResponse);
Assert.Equal(id.ToString(), itemDetail.id);
Assert.Equal(itemName, itemDetail.name);
}
protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
var counter = 0L;
await foreach (var price in _priceGeneratorSvc.GetPricesAsync(cancellationToken))
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
if (false)
{
var message = $"{price.symbol} is {price.bid}/{price.offer} at {price.date}";
_logger.LogInformation("latest {symol} price sent at {utcNow}, {message}", price.symbol, DateTime.UtcNow, message);
_redisCacheSvc.subscriber.Publish("messages", message);
await Task.Delay(1000, cancellationToken);
}
else
{
//var message = $"hello at {DateTime.UtcNow}";
//_logger.LogInformation("Message sent at {utcNow}, {message}", DateTime.UtcNow, message);
//var messageId = _redisCacheSvc.db.StreamAdd(streamKey, "foo_name", "bar_value");
//var values = new[]
//{
// new NameValueEntry("sensor_id", "1234"),
// new NameValueEntry("temp", "19.8")
//};
//var messageId2 = _redisCacheSvc.db.StreamAdd("sensor_stream", values);
//_logger.LogInformation("Streams updated at {utcNow}", DateTime.UtcNow);
//await Task.Delay(10, stoppingToken);
//which is fastest?
_ = _redisCacheSvc.db.StreamAdd(Globals.streamKey, nameof(price.symbol), price.symbol);
_ = _redisCacheSvc.db.StreamAdd(Globals.streamKey, nameof(price.symbol), price.symbol, flags: CommandFlags.FireAndForget);
_ = await _redisCacheSvc.db.StreamAddAsync(Globals.streamKey, nameof(price.symbol), price.symbol);
var streamPairs = new NameValueEntry[3]
{
new NameValueEntry("s", price.symbol),
new NameValueEntry("b", price.bid),
new NameValueEntry("a", price.offer)
};
_ = await _redisCacheSvc.db.StreamAddAsync(Globals.streamKey, streamPairs, flags : CommandFlags.FireAndForget);
}
counter++;
if (counter % 1000 == 0)
{
_logger.LogInformation("{counter} records at {utcNow}", counter, DateTime.UtcNow);
}
if (counter % 1_000_000 == 0)
{
break;
}
}
}
public void StreamAdd_2()
{
var fields = new NameValueEntry[0];
wrapper.StreamAdd("key", fields, "*", 1000, true, CommandFlags.HighPriority);
mock.Verify(_ => _.StreamAdd("prefix:key", fields, "*", 1000, true, CommandFlags.HighPriority));
}
public async Task SendMessage(MessageDTO message)
{
var values = new NameValueEntry[]
{
new NameValueEntry("clientuniqueid", message.clientuniqueid),
new NameValueEntry("sender_username", message.senderUsername),
new NameValueEntry("receiver_id", message.receiverId),
new NameValueEntry("receiver_username", message.receiverUsername),
new NameValueEntry("type", message.type),
new NameValueEntry("message", message.message),
new NameValueEntry("date", message.date.ToString()),
};
IDatabase redisDB = _redisConnection.GetDatabase();
string fromUsername;
string toUsername;
int proba = string.Compare(message.senderUsername, message.receiverUsername);
if (proba > 0)
{
fromUsername = message.receiverUsername;
toUsername = message.senderUsername;
}
else
{
fromUsername = message.senderUsername;
toUsername = message.receiverUsername;
}
await redisDB.StreamAddAsync($"messages:{fromUsername}:{toUsername}:chat", values);
}
public void StreamAddMultipleValuePairsWithAutoId()
{
using (var conn = Create())
{
Skip.IfMissingFeature(conn, nameof(RedisFeatures.Streams), r => r.Streams);
var key = GetUniqueKey("multiple_value_pairs");
var fields = new NameValueEntry[]
{
new NameValueEntry("field1", "value1"),
new NameValueEntry("field2", "value2")
};
var db = conn.GetDatabase();
var messageId = db.StreamAdd(key, fields);
var entries = db.StreamRange(key);
Assert.True(entries.Length == 1);
Assert.Equal(messageId, entries[0].Id);
Assert.True(entries[0].Values.Length == 2);
Assert.True(entries[0].Values[0].Name == "field1" &&
entries[0].Values[0].Value == "value1");
Assert.True(entries[0].Values[1].Name == "field2" &&
entries[0].Values[1].Value == "value2");
}
}
public async Task SendFriendRequest(int senderId, int receiverId, Request sender)
{
string channelName = $"messages:{receiverId}:friend_request";
var values = new NameValueEntry[]
{
new NameValueEntry("sender_id", senderId),
new NameValueEntry("sender_first_name", sender.FirstName),
new NameValueEntry("sender_last_name", sender.LastName),
new NameValueEntry("sender_email", sender.Email),
new NameValueEntry("sender_profile_picture_path", sender.ProfilePicturePath),
};
IDatabase redisDB = _redisConnection.GetDatabase();
var messageId = await redisDB.StreamAddAsync(channelName, values);
//Dodatna funkcija
await redisDB.SetAddAsync("friend:" + senderId + ":request", receiverId);
// objekat za notifikaciju
FriendRequestNotificationDTO message = new FriendRequestNotificationDTO
{
ReceiverId = receiverId,
RequestDTO = new RequestDTO {
Id = messageId, Request = sender
}
};
//Push notifikacija
var jsonMessage = JsonSerializer.Serialize(message);
ISubscriber chatPubSub = _redisConnection.GetSubscriber();
await chatPubSub.PublishAsync("friendship.requests", jsonMessage);
}
public void StreamAddAsync_2()
{
var fields = new NameValueEntry[0];
wrapper.StreamAddAsync("key", fields, "*", 1000, true, CommandFlags.None);
mock.Verify(_ => _.StreamAddAsync("prefix:key", fields, "*", 1000, true, CommandFlags.None));
}
public async Task when_create_event_then_its_in_list_view(Guid id, string itemName)
{
string json = $"{{\"Id\": \"{id}\",\"Name\": \"{itemName}\", \"Version\": 0}}";
var jsonBytes = Encoding.UTF8.GetBytes(json);
var streamName = $"inventory-InventoryItemLogic{id}";
var eventData = new NameValueEntry[]
{
new NameValueEntry("id", Guid.NewGuid().ToString()),
new NameValueEntry("type", "SimpleCQRS.InventoryItemCreated"),
new NameValueEntry("msg", jsonBytes),
new NameValueEntry("partition", string.Empty),
new NameValueEntry("metadata", string.Empty)
};
var result = await connection.StreamAddAsync(streamName, eventData);
await connection.StreamAddAsync("$ce-inventory", new NameValueEntry[]
{
new NameValueEntry("stream", streamName),
new NameValueEntry("key", result),
});
await Task.Delay(sleepMillisecondsDelay *2);
var response = await client.GetStringAsync("items/");
//We dont test json convert and .net core mvc conversion, end to end tests will cover that as well.
// just that the test doest break as schema is changed
Assert.Contains(id.ToString(), response);
Assert.Contains(itemName.ToString(), response);
}
public async Task SendFriendRequest(int senderId, int receiverId, Request sender)
{
string channelName = $"messages:{receiverId}:friend_request";
var values = new NameValueEntry[]
{
new NameValueEntry("sender_id", senderId),
new NameValueEntry("sender_first_name", sender.FirstName),
new NameValueEntry("sender_last_name", sender.LastName),
new NameValueEntry("sender_username", sender.Username)
};
IDatabase redisDB = _redisConnection.GetDatabase();
var messageId = await redisDB.StreamAddAsync(channelName, values);
await redisDB.SetAddAsync("friend:" + senderId + ":request", receiverId);
FriendRequestNotificationDTO message = new FriendRequestNotificationDTO
{
ReceiverId = receiverId,
IdNotification = messageId,
Request = sender
};
var jsonMessage = JsonSerializer.Serialize(message);
ISubscriber pubNotification = _redisConnection.GetSubscriber();
await pubNotification.PublishAsync("friendship.requests", jsonMessage);
}
public async Task SendNotification(NotificationDTO notiffication)
{
var values = new NameValueEntry[]
{
new NameValueEntry("sender_username", notiffication.SenderUsername),
new NameValueEntry("receiver_username", notiffication.ReceiverUsername),
new NameValueEntry("message", notiffication.Message),
};
IDatabase redisDB = _redisConnection.GetDatabase();
await redisDB.StreamAddAsync($"notification:{notiffication.SenderUsername}:{notiffication.ReceiverUsername}:reservation", values);
}
public async Task PublishMessageToStreamAsync(string messageKey)
{
var messages = new NameValueEntry[1];
for (int i = 0; i < 1; i++)
{
messages[i] = new NameValueEntry(messageKey, i);
}
var messageId = await _db.StreamAddAsync(ZikeyStream, messages);
System.Console.WriteLine("messageId:{0}", messageId);
}
public async Task <IActionResult> Withdraw()
{
// db.StreamCreateConsumerGroup("bank-consumer", "bank-consumer", StreamPosition.NewMessages);
var values = new NameValueEntry[]
{
new NameValueEntry("date", DateTime.Now.ToString())
};
var messageId = await _database.StreamAddAsync("bank-consumer", values, flags : CommandFlags.FireAndForget);
return(Ok());
}
/// <summary>
/// Sends raw announcement.
/// </summary>
/// <param name="payload">The raw announcement data.</param>
/// <returns>
/// Return the message id
/// </returns>
public async ValueTask <string> SendAsync(Announcement payload)
{
IDatabaseAsync db = await _dbTask;
Metadata meta = payload.Metadata;
string id = meta.MessageId;
#region var entries = new NameValueEntry[]{...}
// local method
NameValueEntry KV(RedisValue key, RedisValue value) => new NameValueEntry(key, value);
var entries = new NameValueEntry[]
{
KV(nameof(meta.MessageId), id),
KV(nameof(meta.Operation), meta.Operation),
KV(nameof(meta.ProducedAt), meta.ProducedAt.ToUnixTimeSeconds())
};
#endregion // var entries = new NameValueEntry[]{...}
// TODO: [bnaya 2021-01] enable to replace the segments storage without replacing the strweam
#region await db.HashSetAsync($"Segments~{id}", segmentsEntities)
var segmentsEntities = payload.Segments
.Select(sgm =>
new HashEntry(sgm.Key, sgm.Value))
.ToArray();
await db.HashSetAsync($"Segments~{id}", segmentsEntities);
#endregion // await db.HashSetAsync($"Segments~{id}", segmentsEntities)
#region await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities)
var interceptionsEntities = payload.InterceptorsData
.Select(spt =>
new HashEntry(spt.Key, spt.Value))
.ToArray();
await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities);
#endregion // await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities)
RedisValue messageId = await _resiliencePolicy.ExecuteAsync(() =>
db.StreamAddAsync(meta.Key(), entries,
flags: CommandFlags.DemandMaster));
return(messageId);
}
static async Task Main(string[] args)
{
var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync("127.0.0.1");
var redisDb = connectionMultiplexer.GetDatabase(1);
if (redisDb == null)
{
throw new ApplicationException("Could not establish connection with the Redis database");
}
while (true)
{
var newPrivateKeyBytes = new Bitcoin().GenerateBitcoinKeyByte();
var value = Convert.ToBase64String(newPrivateKeyBytes);
var key = $"Phase0:Worker1:{value}";
var streamValue = new NameValueEntry[1];
streamValue[0] = new NameValueEntry(key, value);
await redisDb
.StreamAddAsync("Phase0", streamValue)
.ConfigureAwait(false);
// var verifiedKey = Convert.FromBase64String(key);
}
// var random = PrivateKey.CreatePrivateKey(Globals.ProdDumpKeyVersion);
// var seedBytes = random.PrivateKeyBytes;
// //create a private key using seedBytes and not supplying compressedPublicKey which by default forces the public key to be compressed
// var pkCompressed = new PrivateKey(Globals.ProdDumpKeyVersion, seedBytes);
// //get the wif encoded string that represents the pkCompressed private key
// var wifCompressed = pkCompressed.WIFEncodedPrivateKeyString;
// //here we can create a bitcoin address string using the public key ascociated with our private key
// var bitcoinAddressCompressed = BitcoinAddress.GetBitcoinAdressEncodedStringFromPublicKey(pkCompressed.PublicKey);
// //create a private key using seedBytes which forces the public key to be compressed and supplying compressedPublicKey as false so the public key will not be compressed
// var pkNotCompressed = new PrivateKey(Globals.ProdDumpKeyVersion, seedBytes, false);
// var wif = pkNotCompressed.WIFEncodedPrivateKeyString;
// var bitcoinAddress = BitcoinAddress.GetBitcoinAdressEncodedStringFromPublicKey(pkNotCompressed.PublicKey);
// Console.WriteLine($"{bitcoinAddressCompressed} | {random.ToString()}");
// Console.WriteLine($"{bitcoinAddress} | {wif}");
}
private async Task HandleRequest(string metricName, long value)
{
var redisDb = conn.GetDatabase(DBNbr);
var currentTimeStampInMicroseconds = TimeStampProvider.GetCurrentTimeStamp(TimePrecisionUnit.Microseconds);
// Decide in which consumer we should put this metric
var metricConsumerName = await GetMetricConsumer(conn, metricName, currentTimeStampInMicroseconds);
// Put the metric value into the consumer's stream
var nameValueEntry = new NameValueEntry[] {
new NameValueEntry("metricName", metricName),
new NameValueEntry("value", value),
new NameValueEntry("time", currentTimeStampInMicroseconds),
};
await redisDb.StreamAddAsync("stream:" + metricConsumerName, nameValueEntry);
}
/// <summary>
/// Converts a Redis Event Stream Entry event into our abstraction
/// </summary>
internal EventMessage(string id, NameValueEntry value)
{
string[] idParts = ((string)id).Split('-');
long enqueuedUnixMs = long.Parse(idParts[0]);
long sequenceNumber = long.Parse(idParts[1]);
DateTimeOffset enqueuedTimeUtc = DateTimeOffset.FromUnixTimeMilliseconds(enqueuedUnixMs);
Content = value.Value.ToString();
EnqueuedTimeUtc = enqueuedTimeUtc;
Offset = id;
PartitionKey = id;
SequenceNumber = sequenceNumber;
Properties = new Dictionary <string, object>()
{
["Name"] = value.Name,
};
}
public async Task SendMessage(Message message)
{
var values = new NameValueEntry[]
{
new NameValueEntry("sender_username", message.SenderUsername),
new NameValueEntry("senderId", message.SenderId),
new NameValueEntry("receiver_username", message.ReceiverUsername),
new NameValueEntry("receiverId", message.ReceiverId),
new NameValueEntry("text", message.Text)
};
IDatabase redisDB = _redisConnection.GetDatabase();
//int fromId = message.SenderId > message.ReceiverId ? message.SenderId : message.ReceiverId;
//int toId = message.SenderId < message.ReceiverId ? message.SenderId : message.ReceiverId;
await redisDB.StreamAddAsync($"forum:{message.ReceiverId}:chat", values);
var jsonMessage = JsonSerializer.Serialize(message);
ISubscriber chatPubSub = _redisConnection.GetSubscriber();
await chatPubSub.PublishAsync("forum.messages", jsonMessage);
}
private static async Task CreateEvents(IDatabase db, CancellationToken cancel)
{
await Task.Run(async() =>
{
var messung = 0;
while (!cancel.IsCancellationRequested)
{
cpuCounter.NextValue();
await Task.Delay(1000);
var cpu = (int)cpuCounter.NextValue();
var data = new NameValueEntry[2] {
new NameValueEntry("CPU", cpu.ToString()),
new NameValueEntry("messung", ++messung)
};
var id = await db.StreamAddAsync(STREAM_NAME, data, null, 16, true);
}
}, cancel);
}
/// <inheritdoc />
public Task SendEventDataAsync(IList <object> msgs, string partition)
{
if (msgs.Any() == false)
{
throw new InvalidOperationException("Cannot send empty message");
}
NameValueEntry[] entries = new NameValueEntry[msgs.Count()];
for (int i = 0; i < msgs.Count(); i++)
{
entries[i] = new NameValueEntry($"{DATA_FIELD}_{i}", SerializeObject(msgs[i]));
}
return(ExecuteRedisCommandAsync(() =>
{
IDatabase db = GetRedisDatabase();
return db.StreamAddAsync(_streamName, entries);
}));
}
public async Task SendMessage(Message message)
{
var values = new NameValueEntry[]
{
new NameValueEntry("sender", message.Sender),
new NameValueEntry("senderId", message.SenderId),
new NameValueEntry("receiver", message.Receiver),
new NameValueEntry("receiverId", message.ReceiverId),
new NameValueEntry("content", message.Content)
};
IDatabase redisDB = _redisConnection.GetDatabase();
int biggerId = message.SenderId > message.ReceiverId ? message.SenderId : message.ReceiverId;
int smallerId = message.SenderId < message.ReceiverId ? message.SenderId : message.ReceiverId;
await redisDB.StreamAddAsync($"messages:{biggerId}:{smallerId}:chat", values);
var jsonMessage = JsonSerializer.Serialize(message);
ISubscriber chatPubSub = _redisConnection.GetSubscriber();
await chatPubSub.PublishAsync("chat.messages", jsonMessage);
}
private static async Task <TaskResult> CreateEvents(CancellationToken cancel)
{
var events = 0;
try
{
await Task.Run(async() =>
{
var rnd = new Random();
while (!cancel.IsCancellationRequested)
{
var data = new NameValueEntry[1] {
new NameValueEntry("eventID", events + 1)
};
var id = await db.StreamAddAsync(STREAM_NAME, data, null, 16, true);
++events;
Console.Write("\r{0} events generated", events);
await Task.Delay(300, cancel);
}
});
}
catch (TaskCanceledException)
{
// may happen
}
return(new TaskResult()
{
sender = true,
events = events,
group = "generator",
consumer = Process.GetCurrentProcess().Id.ToString()
});
}
public NameValueCollectionEntry(NameValueEntry entry)
{
Name = entry.Name;
Value = entry.Value;
}
