static void Main(string[] args)
{
MessageStore <object> ms = new MessageStore <object>(capacity: 80000);
ThreadPool.SetMinThreads(32, 32);
Console.WriteLine("{0}-bit process", IntPtr.Size * 8);
Console.WriteLine("{0} writer(s), {1} reader(s)", NumWriters, NumReaders);
Console.WriteLine("Running for {0}..", RunTime);
// queue writers
for (int writerNum = 0; writerNum < NumWriters; writerNum++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
for (int i = 0; ; i++)
{
ms.Add("This is my awesome object!");
}
}, null);
}
// queue readers
long totalMessagesRecvd = 0;
for (int readerNum = 0; readerNum < NumReaders; readerNum++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
ulong firstMessageIdToReceive = 0;
while (true)
{
var x = ms.GetMessages(firstMessageIdToReceive);
ulong firstMessageIdReceived = x.FirstMessageId;
firstMessageIdToReceive = firstMessageIdReceived + (ulong)x.Messages.Length;
if (x.Messages.Length > 0)
{
Interlocked.Add(ref totalMessagesRecvd, x.Messages.Length);
}
else
{
// back off if there is no more data
Thread.Sleep(10);
}
}
}, null);
}
// let the program run for 10 seconds
Thread.Sleep(RunTime);
ulong totalMessagesWritten = ms.GetMessageCount();
Console.WriteLine();
Console.WriteLine("Throughput:");
Console.WriteLine("{0:N0} total messages written", totalMessagesWritten);
Console.WriteLine(" ({0:N0} messages per writer per second)", totalMessagesWritten / RunTime.TotalSeconds / NumWriters);
Console.WriteLine("{0:N0} total messages received", totalMessagesRecvd);
Console.WriteLine(" ({0:N0} messages per reader per second)", totalMessagesRecvd / RunTime.TotalSeconds / NumReaders);
}
public void AddItemWithoutRemovingItFiresTimeoutEvent()
{
MqttProtocolInformation.Settings.NetworkTimeout = 4; // 4 seconds
var store = new MessageStore();
var are = new AutoResetEvent(false);
var eventData = "Test data";
string connectionKey = "123";
var msgBldr = new MqttPublishMessageBuilder
{
MessageId = 42,
QualityOfService = QualityOfService.AtLeastOnce,
TopicName = "a/b/c"
};
var msg = msgBldr.GetMessage();
store.MessageTimeout += (sender, args) =>
{
Assert.AreEqual(msg, args.FailedMessage);
Assert.AreEqual(eventData, args.EventData);
are.Set();
};
store.Add(msg, eventData, connectionKey);
if (!are.WaitOne(MqttProtocolInformation.Settings.NetworkTimeout * 2 * 1000))
{
Assert.Fail("Timeout event did not fire.");
}
}
private void ValidateModel()
{
var model = CurrentEditContext.Model;
var vc = new ValidationContext(model);
var vrs = new List <ValidationResult>();
MessageStore.Clear();
Validator.TryValidateObject(model, vc, vrs, true);
foreach (var vr in vrs)
{
if (!vr.MemberNames.Any())
{
MessageStore.Add(new FieldIdentifier(model, string.Empty), vr.ErrorMessage);
}
else
{
foreach (var mn in vr.MemberNames)
{
MessageStore.Add(new FieldIdentifier(model, mn), vr.ErrorMessage);
}
}
}
CurrentEditContext.NotifyValidationStateChanged();
}
public void AddRemoveItemDoesNotFireTimeoutEvent()
{
MqttProtocolInformation.Settings.NetworkTimeout = 4; // 4 seconds
var store = new MessageStore();
var are = new AutoResetEvent(false);
var eventData = "Test data";
string connectionKey = "123";
var msg = new MqttPublishMessageBuilder
{
MessageId = 42,
QualityOfService = QualityOfService.AtLeastOnce,
TopicName = "a/b/c"
};
store.MessageTimeout += (sender, args) =>
{
Assert.Fail("MessageTimeout event fired but should not have.");
are.Set();
};
store.Add(msg.GetMessage(), eventData, connectionKey);
Thread.Sleep(1000);
store.Remove(MessageType.PubAck, 42, connectionKey);
if (!are.WaitOne(MqttProtocolInformation.Settings.NetworkTimeout * 2))
{
Assert.AreEqual(0, store.Count);
}
}
static void Main(string[] args)
{
MessageStore<object> ms = new MessageStore<object>(capacity: 80000);
ThreadPool.SetMinThreads(32, 32);
Console.WriteLine("{0}-bit process", IntPtr.Size * 8);
Console.WriteLine("{0} writer(s), {1} reader(s)", NumWriters, NumReaders);
Console.WriteLine("Running for {0}..", RunTime);
// queue writers
for (int writerNum = 0; writerNum < NumWriters; writerNum++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
for (int i = 0; ; i++)
{
ms.Add("This is my awesome object!");
}
}, null);
}
// queue readers
long totalMessagesRecvd = 0;
for (int readerNum = 0; readerNum < NumReaders; readerNum++)
{
ThreadPool.QueueUserWorkItem(_ =>
{
ulong firstMessageIdToReceive = 0;
while (true)
{
var x = ms.GetMessages(firstMessageIdToReceive);
ulong firstMessageIdReceived = x.FirstMessageId;
firstMessageIdToReceive = firstMessageIdReceived + (ulong)x.Messages.Length;
if (x.Messages.Length > 0)
{
Interlocked.Add(ref totalMessagesRecvd, x.Messages.Length);
}
else
{
// back off if there is no more data
Thread.Sleep(10);
}
}
}, null);
}
// let the program run for 10 seconds
Thread.Sleep(RunTime);
ulong totalMessagesWritten = ms.GetMessageCount();
Console.WriteLine();
Console.WriteLine("Throughput:");
Console.WriteLine("{0:N0} total messages written", totalMessagesWritten);
Console.WriteLine(" ({0:N0} messages per writer per second)", totalMessagesWritten / RunTime.TotalSeconds / NumWriters);
Console.WriteLine("{0:N0} total messages received", totalMessagesRecvd);
Console.WriteLine(" ({0:N0} messages per reader per second)", totalMessagesRecvd / RunTime.TotalSeconds / NumReaders);
}
private void AddValidationResult(object model, ValidationResult validationResult)
{
foreach (ValidationFailure error in validationResult.Errors)
{
var fieldIdentifier = new FieldIdentifier(model, error.PropertyName);
MessageStore.Add(fieldIdentifier, error.ErrorMessage);
}
EditContext.NotifyValidationStateChanged();
}
public void MaxCapacityIsGuarantied()
{
var store = new MessageStore <int, int>(10);
for (int i = 1; i <= 11; i++)
{
store.Add(i, i);
}
Assert.False(store.TryGetValue(1, out _));
Assert.True(store.TryGetValue(11, out _));
}
private void ValidateField(FieldIdentifier fieldIdentifier)
{
var model = fieldIdentifier.Model;
var allProperties = model.GetType().GetProperties();
var previousValidationMessages = allProperties.ToDictionary(
p => p.Name, p => CurrentEditContext.GetValidationMessages(new FieldIdentifier(model, p.Name)).ToArray());
MessageStore.Clear();
foreach (var prop in allProperties)
{
var vrs = new List <ValidationResult>();
var vc = new ValidationContext(model)
{
MemberName = prop.Name
};
var fi = new FieldIdentifier(model, prop.Name);
var compareAttr = GetCompareAttrOrNull(prop);
if (prop.Name == fieldIdentifier.FieldName)
{
if (!Validator.TryValidateProperty(prop.GetValue(model), vc, vrs))
{
MessageStore.Add(fi, vrs.Select(r => r.ErrorMessage));
}
}
else if (compareAttr != null && compareAttr.OtherPropertyName == fieldIdentifier.FieldName)
{
var compareAttrMessage = compareAttr.GetErrorMessage(model, vc);
var prevMessagesForField = previousValidationMessages[prop.Name].Where(vm => !vm.EqualsInvariant(compareAttrMessage)).ToArray();
MessageStore.Add(fi, prevMessagesForField);
if (!Validator.TryValidateValue(prop.GetValue(model), vc, vrs, new[] { compareAttr }))
{
MessageStore.Add(fi, vrs.Select(r => r.ErrorMessage));
}
}
else
{
MessageStore.Add(fi, previousValidationMessages[prop.Name]);
}
}
CurrentEditContext.NotifyValidationStateChanged();
}
public void RemoveItemReturnsEventData()
{
MqttProtocolInformation.Settings.NetworkTimeout = 4; // 4 seconds
var store = new MessageStore();
var eventData = "Test data";
string connectionKey = "123";
var msg = new MqttPublishMessageBuilder
{
MessageId = 42,
QualityOfService = QualityOfService.AtLeastOnce,
TopicName = "a/b/c"
};
store.Add(msg.GetMessage(), eventData, connectionKey);
Thread.Sleep(1000);
object testData = store.Remove(MessageType.PubAck, 42, connectionKey);
Assert.AreSame(eventData, testData);
}
public async Task MessageStoreAddRemoveEndpointTest(bool checkEntireQueueOnCleanup)
{
// Arrange
var dbStoreProvider = new InMemoryDbStoreProvider();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
ICheckpointStore checkpointStore = CheckpointStore.Create(storeProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.FromHours(1), checkEntireQueueOnCleanup, 1800);
// Act
await messageStore.AddEndpoint("module1");
for (int i = 0; i < 10; i++)
{
await messageStore.Add("module1", this.GetMessage(i), 0);
}
// Assert
IMessageIterator module1Iterator = messageStore.GetMessageIterator("module1");
Assert.NotNull(module1Iterator);
IEnumerable <IMessage> batch = await module1Iterator.GetNext(1000);
List <IMessage> batchItemsAsList = batch.ToList();
Assert.Equal(10, batchItemsAsList.Count);
for (int i = 0; i < 10; i++)
{
Assert.Equal($"{i}", batchItemsAsList.ElementAt(i).SystemProperties[SystemProperties.MessageId]);
}
// Remove
await messageStore.RemoveEndpoint("module1");
// Assert
await Assert.ThrowsAsync <InvalidOperationException>(() => messageStore.Add("module1", this.GetMessage(0), 0));
Assert.Throws <InvalidOperationException>(() => messageStore.GetMessageIterator("module1"));
// Act
await messageStore.AddEndpoint("module1");
for (int i = 20; i < 30; i++)
{
await messageStore.Add("module1", this.GetMessage(i), 0);
}
// Assert
module1Iterator = messageStore.GetMessageIterator("module1");
Assert.NotNull(module1Iterator);
batch = await module1Iterator.GetNext(1000);
batchItemsAsList = batch.ToList();
Assert.Equal(10, batchItemsAsList.Count);
for (int i = 20; i < 30; i++)
{
Assert.Equal($"{i}", batchItemsAsList.ElementAt(i - 20).SystemProperties[SystemProperties.MessageId]);
}
}
public void SendMessageAsync(IMqttMessage msg, object eventData, string clientUid)
{
Logger.LogMessage("Protocol", LogLevel.Verbose, "SendMessageAsync(" + msg.MessageType + ")");
var args = new SocketEventArgs
{
MessageToSend = msg,
ClientUid = clientUid
};
// If we expect a response, push the event data on our stack and retrieve it with the response
if (args.MessageToSend.ExpectedResponse != MessageType.None)
{
_messageStore.Add(args.MessageToSend, eventData, clientUid);
}
args.OnOperationComplete((eventArgs) =>
{
MessageType messageType = eventArgs.MessageToSend.MessageType;
string exceptionText = eventArgs.SocketException == null
? "Success."
: "Error: " + eventArgs.SocketException.ToString();
Logger.LogMessage("Protocol", LogLevel.Verbose, "SendMessageAsync(" + messageType + ") completed callback. " + exceptionText);
if (eventArgs.SocketException != null)
{
// Clean up pending message queue
_messageStore.Remove(args.MessageToSend.ExpectedResponse, MqttMessageBase.GetMessageIdOrDefault(args.MessageToSend), clientUid);
}
OnSendMessageAsyncCompleted(clientUid, eventArgs.MessageToSend, eventArgs.SocketException);
if (messageType == MessageType.Connect && eventArgs.SocketException != null)
{
FireConnectComplete(new MqttNetEventArgs
{
Message = args.MessageToSend,
Exception = eventArgs.SocketException,
AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
EventData = eventData,
ClientUid = clientUid
});
}
else if (messageType == MessageType.Disconnect)
{
CloseConnection(clientUid);
FireSendMessageComplete(new MqttNetEventArgs
{
Message = args.MessageToSend,
Exception = eventArgs.SocketException,
AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
EventData = eventData,
ClientUid = clientUid
});
}
else if (messageType == MessageType.Subscribe && eventArgs.SocketException != null)
{
FireSubscribeMessageComplete(new MqttNetEventArgs
{
Message = args.MessageToSend,
Exception = eventArgs.SocketException,
AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
EventData = eventData,
ClientUid = clientUid
});
}
else if (args.MessageToSend.ExpectedResponse == MessageType.None || eventArgs.SocketException != null)
{
FireSendMessageComplete(new MqttNetEventArgs
{
Message = args.MessageToSend,
Exception = eventArgs.SocketException,
AdditionalErrorInfo = eventArgs.AdditionalErrorInfo,
EventData = eventData,
ClientUid = clientUid
});
}
});
Socket.WriteAsync(args);
}
