internal static IReadOnlyCollection <EnqueueItem> ToEnqueueItemList(EnqueueMessagesDto messages)
{
var enqueueItems = new List <EnqueueItem>();
foreach (var msg in messages.Messages)
{
enqueueItems.Add(new EnqueueItem
{
DeviceId = msg.DeviceId,
Payload = msg.Payload,
Timestamp = msg.TimeStamp,
SenderDeviceId = msg.SenderDeviceId
});
}
return(enqueueItems);
}
public DeviceListDto Enqueue(EnqueueMessagesDto messages)
{
EnsureSingleDevice(messages.Messages.Select(m => m.DeviceId));
var enqueueItems = ItemConverters.ToEnqueueItemList(messages);
var deviceEntries = _persistentStorage.Enqueue(enqueueItems);
var cacheItems = ItemConverters.ToCacheItems(deviceEntries, enqueueItems);
_messageCache.Put(cacheItems);
DeviceEntryRegistry.Instance.Merge(deviceEntries);
return(ItemConverters.ToDeviceListDto(deviceEntries));
}
public void EnqueuePeekCommitManyDevicesTest()
{
var dequeueDictionary = new Dictionary <long, List <string> >();
var enqueueDictionary = new Dictionary <long, List <string> >();
const int deviceCount = 100;
const int dequeueRandomDeviceCount = 30;
const int enqueueRandomDeviceCount = 5;
for (int i = 0; i < deviceCount; i++)
{
var deviceId = MessagingService.Initialize(Identity.Next());
dequeueDictionary.Add(deviceId, new List <string>());
enqueueDictionary.Add(deviceId, new List <string>());
}
var deviceIds = dequeueDictionary.Keys.ToList();
int enqueueCounter = 0;
int dequeueCounter = 0;
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
var dequeueThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
DequeueMessagesDto result = MessagingService.Peek(new DeviceListDto()
{
DeviceIds = GetRandomDevices(deviceIds, dequeueRandomDeviceCount)
});
MessagingService.Commit(new DeviceListDto
{
DeviceIds = result.Messages.Select(m => m.DeviceId).ToList()
});
Interlocked.Add(ref dequeueCounter, result.Messages.Count);
foreach (var msg in result.Messages)
{
dequeueDictionary[msg.DeviceId].Add(Encoding.UTF8.GetString(msg.Payload));
}
}
});
var enqueueThread = new Thread(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var randomDeviceIds = GetRandomDevices(deviceIds, enqueueRandomDeviceCount);
var messagesToEnqueue = new EnqueueMessagesDto {
Messages = new List <EnqueueMessageDto>()
};
foreach (var deviceId in randomDeviceIds)
{
var nextMsgId = enqueueDictionary[deviceId].Count + 1;
var nextMsg = "Stress test message no. " + nextMsgId;
enqueueDictionary[deviceId].Add(nextMsg);
var msgToEnqueue = new EnqueueMessageDto
{
DeviceId = deviceId,
Payload = Encoding.UTF8.GetBytes(nextMsg),
TimeStamp = DateTime.UtcNow,
SenderDeviceId = Identity.Next()
};
messagesToEnqueue.Messages.Add(msgToEnqueue);
}
var result = MessagingService.Enqueue(messagesToEnqueue);
Interlocked.Add(ref enqueueCounter, result.DeviceIds.Count);
}
});
dequeueThread.Start();
enqueueThread.Start();
WaitUntil(500, 10000, () => enqueueCounter);
cancellationTokenSource.Cancel();
enqueueThread.Join();
dequeueThread.Join();
Assert.IsTrue(dequeueCounter > 0);
Assert.IsTrue(enqueueCounter > 0);
Assert.IsTrue(enqueueCounter >= dequeueCounter);
foreach (var deviceId in deviceIds)
{
var enqueuedItems = enqueueDictionary[deviceId];
var dequeuedItems = dequeueDictionary[deviceId];
Assert.IsTrue(dequeuedItems.Count <= enqueuedItems.Count);
Assert.IsTrue(dequeuedItems.All(enqueuedItems.Contains));
var messageNumbers = dequeuedItems.Select(d => int.Parse(d.Substring(d.LastIndexOf(' ')))).ToList();
Assert.IsTrue(messageNumbers.SequenceEqual(messageNumbers.OrderBy(d => d)));
Assert.AreEqual(messageNumbers.Count, messageNumbers.Distinct().Count());
}
}
public DeviceListDto Enqueue([FromBody] EnqueueMessagesDto enqueueMessages)
{
return(_messagingService.Enqueue(enqueueMessages));
}
