public void CanCreateConfig()
{
var cut = new PublishSubscribeConfig
{
Persistent = true,
Topic = "MyTopic"
};
cut.Persistent.Should().BeTrue();
cut.Topic.Should().Be("MyTopic");
}
private static PublishMessage CreatePublishMessage <T>(PublishSubscribeConfig publishSubscribeConfig, T message)
{
return(new PublishMessage
{
MessageBody = SerializeToJson(message),
MessageType = typeof(T).FullName,
MessageId = UniqueKeyUtility.Generate(),
Persistent = publishSubscribeConfig.Persistent,
ReplyQueue = null,
Topic = publishSubscribeConfig.Topic
});
}
private static void ValidatePublishSubscribeConfig(PublishSubscribeConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (config.Topic.NullOrWhiteSpace())
{
throw new ArgumentException("Topic must be provided", nameof(config.Topic));
}
}
/// <inheritdoc />
public void SubscribeHandler <T>(PublishSubscribeConfig config, Action <T> handler, string name, bool durable, bool multiThreaded)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var subscribeHandler = CreateSubscribeHandler(config, name, durable).Set(typeof(T), multiThreaded, m => handler((T)m));
if (_cancellationTokenSource != null)
{
StartSubscribeHandler(subscribeHandler);
}
}
private void Publish <T>(PublishSubscribeConfig config, T message)
{
Console.WriteLine();
Console.WriteLine($"Publish - Topic: {config.Topic}");
Console.WriteLine("Message: " + message.SerializeToJson());
try
{
_messageBus.Publish(config, message);
}
catch (Exception exception)
{
Console.WriteLine("Exception publishing: " + exception.SerializeToJson());
}
}
/// <inheritdoc />
public void Publish <T>(PublishSubscribeConfig config, T message)
{
if (_cancellationTokenSource == null)
{
throw new ArgumentException("Cannot Request before Start");
}
ValidatePublishSubscribeConfig(config);
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_messageBroker.SendPublishMessage(config.Topic, message, config.Persistent, _cancellationTokenSource.Token);
}
/// <summary>
/// Publish Message, use the to simulate a Publish event from another service. This will trigger the appropriate registered subscribers
/// </summary>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="message">Message to Publish</param>
/// <typeparam name="T">Type of Message</typeparam>
public void Publish <T>(PublishSubscribeConfig config, T message)
{
foreach (var topicSubscribers in _topicSubscribers)
{
if (topicSubscribers.Key == config.Topic)
{
foreach (var queueName in topicSubscribers.Value)
{
var queue = _subscriberQueues.FirstOrDefault(s => s.Key == queueName);
MockMessage(queue.Value, CreatePublishMessage(config, message), true);
lock (_lock)
{
++_pendingMessages;
}
WaitForIt();
}
}
}
}
private SubscribeHandler CreateSubscribeHandler(PublishSubscribeConfig config, string name, bool durable)
{
ValidatePublishSubscribeConfig(config);
if (name.NullOrWhiteSpace())
{
throw new ArgumentException("Invalid subscriber name", nameof(name));
}
var subscribeHandler = new SubscribeHandler(_logger, _messageBroker, _queueHandlerFactory, name, config.Topic, durable, _queueNameUtility);
lock (_subscribeHandlers)
{
if (_subscribeHandlers.Any(h => h.Name == name && h.Topic == config.Topic))
{
throw new DoubleSubscribeHandlerException(config, name);
}
_subscribeHandlers.Add(subscribeHandler);
}
return(subscribeHandler);
}
/// <inheritdoc />
public void SubscribeHandler <T>(PublishSubscribeConfig config, Action <T> handler, string name, bool durable)
{
SubscribeHandler(config, handler, name, durable, false);
}
/// <inheritdoc />
public void SubscribeHandler <T>(PublishSubscribeConfig config, Action <T> handler, string name)
{
SubscribeHandler(config, handler, name, true);
}
/// <inheritdoc />
public void SubscribeHandler <T>(PublishSubscribeConfig config, Action <T> handler)
{
SubscribeHandler(config, handler, UniqueKeyUtility.Generate(), false);
}
/// <inheritdoc />
/// <summary>
/// You can not register two subscribe handlers with same name and topic
/// </summary>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="name">Subscriber name</param>
/// <exception cref="T:System.NotImplementedException"></exception>
public DoubleSubscribeHandlerException(PublishSubscribeConfig config, string name) : base("Double Subscribe Handler Exception")
{
Data.Add(nameof(config), config?.TrySerializeToJson());
Data.Add(nameof(name), name);
}
/// <summary>
/// Add Subscribe Handler
/// </summary>
/// <param name="messageBus">The Message Bus</param>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="handler">Subscribe handler</param>
/// <typeparam name="T">Type of Message Object</typeparam>
/// <returns>The Message Bus</returns>
public static IMessageBus AddSubscribeHandler <T>(this IMessageBus messageBus, PublishSubscribeConfig config, Action <T> handler)
{
messageBus.SubscribeHandler(config, handler);
return(messageBus);
}
/// <summary>
/// Add Subscribe Handler
/// </summary>
/// <param name="messageBus">The Message Bus</param>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="handler">Subscribe handler</param>
/// <param name="name">Subscriber name</param>
/// <param name="durable">Should subscriber be durable</param>
/// <param name="multiThreaded">Can subscriber handler, handle multi threaded messages, multiple messages in parallel</param>
/// <typeparam name="T">Type of Message Object</typeparam>
/// <returns>The Message Bus</returns>
public static IMessageBus AddSubscribeHandler <T>(this IMessageBus messageBus, PublishSubscribeConfig config, Action <T, CancellationToken> handler, string name, bool durable, bool multiThreaded)
{
messageBus.SubscribeHandler(config, handler, name, durable, multiThreaded);
return(messageBus);
}
/// <summary>
/// Add Subscribe Handler
/// </summary>
/// <param name="messageBus">The Message Bus</param>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="handler">Subscribe handler</param>
/// <param name="name">Subscriber name</param>
/// <typeparam name="T">Type of Message Object</typeparam>
/// <returns>The Message Bus</returns>
public static IMessageBus AddSubscribeHandler <T>(this IMessageBus messageBus, PublishSubscribeConfig config, Action <T, CancellationToken> handler, string name)
{
messageBus.SubscribeHandler(config, handler, name);
return(messageBus);
}
/// <summary>
/// Add Subscribe Handler
/// </summary>
/// <param name="messageBus">The Message Bus</param>
/// <param name="config">Publish/Subscribe Configuration</param>
/// <param name="handler">Subscribe handler</param>
/// <param name="name">Subscriber name</param>
/// <param name="durable">Should subscriber be durable</param>
/// <typeparam name="T">Type of Message Object</typeparam>
/// <returns>The Message Bus</returns>
public static IMessageBus AddSubscribeHandler <T>(this IMessageBus messageBus, PublishSubscribeConfig config, Action <T> handler, string name, bool durable)
{
messageBus.SubscribeHandler(config, handler, name, durable);
return(messageBus);
}
