public void SubscribeLoadTest()
{
// arrange
var publisher = new ReliablePublisher(_redis.GetConnection());
var messageParser = new MessageParser();
var subscriber = new ReliableSubscriber(_subscriberConnection, messageParser);
var channelName = nameof(SubscribeLoadTest) + RandomSuffix;
var testMessage = JsonConvert.SerializeObject(new { myKey = "test value's" });
int messagesReceivedCount = 0;
var messageHandler = new MessageHandler((channel, message) =>
{
Interlocked.Increment(ref messagesReceivedCount);
});
// act
subscriber.Subscribe(channelName, messageHandler);
const int messagesCount = 5000;
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < messagesCount; i++)
{
publisher.PublishAsync(channelName, testMessage);
}
// assert
_output.WriteLine($"All {messagesCount} messages sent at {stopwatch.Elapsed}. Already received messages={messagesReceivedCount}");
WaitUntil(() => messagesReceivedCount == messagesCount, 1000);
_output.WriteLine($"All {messagesReceivedCount} messages received at {stopwatch.Elapsed}.");
Assert.Equal(messagesCount, messagesReceivedCount);
}
public void TestMissingMessages()
{
// arrange
var connectionMultiplexer = _redis.GetConnection();
var publisher = new ReliablePublisher(connectionMultiplexer);
var subscriber = new TogglingSubscriber(connectionMultiplexer, new MessageParser());
int receivedMessagesCount = 0;
const string channelName = "test-channel-" + nameof(TestMissingMessages);
var messageHandler = new MessageHandler((channel, msg) => Interlocked.Increment(ref receivedMessagesCount));
subscriber.Subscribe(channelName, messageHandler);
// act
publisher.Publish(channelName, "message1");
Wait(10);
subscriber.IsEnabled = false; // simulation of disability to process messages
publisher.Publish(channelName, "message2");
Wait(10);
subscriber.IsEnabled = true;
publisher.Publish(channelName, "message3");
Wait(10);
// assert
Assert.Equal(3, receivedMessagesCount);
}
public ReliablePublisherSubscriber(IConnectionMultiplexer connectionMultiplexer, ILoggerFactory loggerFactory = default)
{
_connectionMultiplexer = connectionMultiplexer;
_publisher = new ReliablePublisher(connectionMultiplexer);
var messageParser = new MessageParser(ToLogger <MessageParser>(loggerFactory));
_subscriber = new ReliableSubscriber(connectionMultiplexer, messageParser, loggerFactory);
}
public async Task PublishAsyncTest()
{
// arrange
var channelName = "test-channel-" + nameof(PublishAsyncTest);
var publisher = new ReliablePublisher(_redis.GetConnection());
var subscriber = _redis.GetConnection().GetSubscriber(); // standard, not-reliable subscriber
var receivedMessage = "";
await subscriber.SubscribeAsync(channelName, (channel, message) => receivedMessage += message);
// act
await publisher.PublishAsync(channelName, "test message");
Thread.Sleep(20);
// assert
Assert.Equal("1:test message", receivedMessage);
}
public void PublishTest()
{
// arrange
var channelName = "test-channel-" + nameof(PublishTest);
var publisher = new ReliablePublisher(_redis.GetConnection());
var receivedMessage = "";
var subscriber = _redis.GetConnection().GetSubscriber(); // standard, not-reliable subscriber
subscriber.Subscribe(channelName, (channel, message) => receivedMessage += message);
// act
publisher.Publish(channelName, "test message:my message");
Thread.Sleep(50);
// assert
Assert.Equal("1:test message:my message", receivedMessage);
}
public void GetSavedMessages()
{
// arrange
var connectionMultiplexer = _redis.GetConnection();
var publisher = new ReliablePublisher(connectionMultiplexer);
var loader = new MessageLoader(connectionMultiplexer);
// act
const string channelName = "test-channel-" + nameof(GetSavedMessages);
publisher.Publish(channelName, "message1");
publisher.Publish(channelName, "message2");
var savedMessages = loader.GetMessages(channelName, 0)
.ToList();
// assert
Assert.Equal(2, savedMessages.Count);
}
public void PublishWillSaveMessageInRedis()
{
// arrange
var channelName = "test-channel-" + nameof(PublishWillSaveMessageInRedis);
var publisher = new ReliablePublisher(_redis.GetConnection());
// act
var messageExpiration = TimeSpan.FromSeconds(30);
publisher.Publish(channelName, "test message:my message", messageExpiration);
// assert
var database = _redis.GetConnection().GetDatabase();
var savedMessage = database.StringGetWithExpiry($"ch:{{{channelName}}}:1");
Assert.Equal("test message:my message", savedMessage.Value);
Assert.NotNull(savedMessage.Expiry);
Assert.True(savedMessage.Expiry > TimeSpan.Zero && savedMessage.Expiry < TimeSpan.FromSeconds(60), $"Timespan {savedMessage.Expiry} is not within given range.");
}
public static void ReliablePublishSubscribeDemo()
{
var publisherName = "ReliablePublishSubscribeDemo";
IPublisher publisher = new ReliablePublisher(publisherName, 1, 1);
var fullExceptionCount = 0;
for (var i = 0; i < 10; i++)
{
try
{
publisher.Notice();
}
catch (SemaphoreFullException)
{
fullExceptionCount++;
}
}
ISubscriber subscribe1 = new Subscriber("Subscribe1", publisherName, TimeSpan.FromSeconds(10));
ISubscriber subscribe2 = new Subscriber("Subscribe2", publisherName, TimeSpan.FromSeconds(10));
int subscribe1NoticeCount = 0;
int subscribe2NoticeCount = 0;
Console.WriteLine($"Subscriber1Status={subscribe1.Status}");
Console.WriteLine($"Subscriber2Status={subscribe2.Status}");
Console.WriteLine("------------------------------------------------");
Console.ReadLine();
subscribe1.StartWaitNotice(() =>
{
var sb1 = new StringBuilder();
sb1.AppendLine($"Subscriber1Status={subscribe1.Status}");
sb1.AppendLine("Subscribe1 recieve notice.");
sb1.AppendLine("------------------------------------------------");
Console.WriteLine(sb1.ToString());
subscribe1NoticeCount++;
Thread.Sleep(1000);
}, info =>
{
var sb11 = new StringBuilder();
sb11.AppendLine($"Subscriber1Status={subscribe1.Status}");
sb11.AppendLine($"Subscribe1 completed. Exception={info.Exception?.Message}");
sb11.AppendLine(($"Subscribe1 notice count={subscribe1NoticeCount}"));
sb11.AppendLine("------------------------------------------------");
Console.WriteLine(sb11.ToString());
});
Console.ReadLine();
subscribe1.UnSubscriber();
var sb = new StringBuilder();
sb.AppendLine($"Subscriber1Status={subscribe1.Status}");
sb.AppendLine("Subscriber1 request unSubscribe");
sb.AppendLine("------------------------------------------------");
Console.WriteLine(sb.ToString());
subscribe2.StartWaitNotice(() =>
{
var sb2 = new StringBuilder();
sb2.AppendLine($"Subscriber2Status = {subscribe2.Status}");
sb2.AppendLine("Subscribe2 recieve notice.");
sb2.AppendLine("------------------------------------------------");
Console.WriteLine(sb2.ToString());
subscribe2NoticeCount++;
Thread.Sleep(1500);
}, info =>
{
var sb22 = new StringBuilder();
sb22.AppendLine($"Subscriber2Status = {subscribe2.Status}");
sb22.AppendLine($"Subscribe2 completed. Exception={info.Exception?.Message}");
sb22.AppendLine(($"Subscribe2 notice count={subscribe2NoticeCount}"));
sb22.AppendLine("------------------------------------------------");
Console.WriteLine(sb22.ToString());
});
Console.ReadLine();
subscribe2.UnSubscriber();
sb = new StringBuilder();
sb.AppendLine($"Subscriber1Status={subscribe2.Status}");
sb.AppendLine("Subscriber2 request unSubscribe");
sb.AppendLine("------------------------------------------------");
sb.AppendLine($"FullExceptionCount={fullExceptionCount}");
sb.AppendLine("------------------------------------------------");
Console.WriteLine(sb.ToString());
}
