public MemoryMessageBus(MessageBusSettings settings, MemoryMessageBusSettings providerSettings) : base(settings)
{
_logger = LoggerFactory.CreateLogger <MemoryMessageBus>();
ProviderSettings = providerSettings ?? throw new ArgumentNullException(nameof(providerSettings));
OnBuildProvider();
}
public EventHubMessageBus(MessageBusSettings settings, EventHubMessageBusSettings eventHubSettings)
: base(settings)
{
EventHubSettings = eventHubSettings;
_producersByTopic.ValueFactory = topic =>
{
Log.DebugFormat("Creating EventHubClient for path {0}", topic);
return(EventHubSettings.EventHubClientFactory(topic));
};
Log.Info("Creating consumers");
foreach (var consumerSettings in settings.Consumers)
{
Log.InfoFormat("Creating consumer for Topic: {0}, Group: {1}, MessageType: {2}", consumerSettings.Topic, consumerSettings.Group, consumerSettings.MessageType);
//var consumer = new EventHubConsumer(this, group, messageType, subscribersByMessageType.ToList());
_consumers.Add(new EventHubConsumer(this, consumerSettings));
}
if (settings.RequestResponse != null)
{
Log.InfoFormat("Creating response consumer for Topic: {0}, Group: {1}", settings.RequestResponse.Topic, settings.RequestResponse.Group);
// _consumers.Add(new EvenHubResponseConsumer(this, settings.RequestResponse));
_consumers.Add(new EventHubConsumer(this, settings.RequestResponse));
}
}
public KafkaMessageBus(MessageBusSettings settings, KafkaMessageBusSettings kafkaSettings)
: base(settings)
{
AssertSettings(settings);
KafkaSettings = kafkaSettings;
Log.Info("Creating producer");
_producer = CreateProducer();
Log.InfoFormat("Producer has been assigned name: {0}", _producer.Name);
Log.Info("Creating subscribers");
foreach (var subscribersByGroup in settings.Consumers.GroupBy(x => x.Group))
{
var group = subscribersByGroup.Key;
foreach (var subscribersByMessageType in subscribersByGroup.GroupBy(x => x.MessageType))
{
var messageType = subscribersByMessageType.Key;
Log.InfoFormat("Creating consumer for topics {0}, group {1}, message type {2}", string.Join(",", subscribersByMessageType.Select(x => x.Topic)), group, messageType);
var consumer = new KafkaGroupConsumer(this, group, messageType, subscribersByMessageType.ToList());
_groupConsumers.Add(consumer);
}
}
if (settings.RequestResponse != null)
{
Log.InfoFormat("Creating response consumer for topic {0} and group {1}", settings.RequestResponse.Group, settings.RequestResponse.Topic);
_groupConsumers.Add(new KafkaResponseConsumer(this, settings.RequestResponse));
}
}
public HybridMessageBus(MessageBusSettings settings, HybridMessageBusSettings providerSettings)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
ProviderSettings = providerSettings ?? throw new ArgumentNullException(nameof(providerSettings));
// Use the configured logger factory, if not provided try to resolve from DI, if also not available supress logging using the NullLoggerFactory
LoggerFactory = settings.LoggerFactory
?? (ILoggerFactory)settings.DependencyResolver?.Resolve(typeof(ILoggerFactory))
?? NullLoggerFactory.Instance;
_logger = LoggerFactory.CreateLogger <HybridMessageBus>();
_routeByMessageType = new Dictionary <Type, string>();
_busByName = new Dictionary <string, MessageBusBase>(providerSettings.Count);
foreach (var name in providerSettings.Keys)
{
var builderFunc = providerSettings[name];
var bus = BuildBus(builderFunc);
_busByName.Add(name, bus);
BuildAutoRouting(name, bus);
}
// ToDo: defer start of busses until here
}
public EventHubMessageBus(MessageBusSettings settings, EventHubMessageBusSettings eventHubSettings)
: base(settings)
{
ProviderSettings = eventHubSettings;
OnBuildProvider();
}
public EventHubMessageBus(MessageBusSettings settings, EventHubMessageBusSettings eventHubSettings)
: base(settings)
{
_logger = LoggerFactory.CreateLogger <EventHubMessageBus>();
ProviderSettings = eventHubSettings;
OnBuildProvider();
}
private static void AssertSettings(MessageBusSettings settings)
{
if (settings.RequestResponse != null)
{
Assert.IsTrue(settings.RequestResponse.Group != null,
() => new InvalidConfigurationMessageBusException($"Request-response: group was not provided"));
}
}
public MessageBusTested(MessageBusSettings settings)
: base(settings)
{
// by default no responses will arrive
OnReply = (type, payload, req) => null;
OnBuildProvider();
}
public ElasticStorage(
IElasticClient client,
ILogger <ElasticStorage> logger,
MessageBusSettings settings)
{
_client = client;
_logger = logger;
_settings = settings;
}
public ChannelPool(
IConnection connection,
MessageBusSettings settings,
ILogger <ChannelPool> logger)
{
_channels = new ConcurrentBag <IModel>();
_connection = connection;
_maxCount = settings.MaxConcurrentChannels;
_logger = logger;
}
public KafkaMessageBus(MessageBusSettings settings, KafkaMessageBusSettings providerSettings)
: base(settings)
{
ProviderSettings = providerSettings ?? throw new ArgumentNullException(nameof(providerSettings));
OnBuildProvider();
// TODO: Auto start should be a setting
Start();
}
private static void AssertSettings(MessageBusSettings settings)
{
Assert.IsTrue(settings.Serializer != null,
() => new InvalidConfigurationMessageBusException($"Serializer was not provided"));
if (settings.RequestResponse != null)
{
Assert.IsTrue(settings.RequestResponse.Topic != null,
() => new InvalidConfigurationMessageBusException($"Request-response: topic was not provided"));
}
}
private static void AssertSettings(MessageBusSettings settings)
{
if (settings.RequestResponse != null)
{
Assert.IsTrue(settings.RequestResponse.Group != null,
() => new InvalidConfigurationMessageBusException($"Request-response: group was not provided"));
Assert.IsFalse(settings.Consumers.Any(x => x.Group == settings.RequestResponse.Group && x.Topic == settings.RequestResponse.Topic),
() => new InvalidConfigurationMessageBusException($"Request-response: cannot use topic that is already being used by a consumer"));
}
}
public MemoryMessageBus(MessageBusSettings settings, MemoryMessageBusSettings providerSettings)
: base(settings)
{
ProviderSettings = providerSettings;
var consumers = settings.Consumers.Select(x => new ConsumerRuntimeInfo(x)).ToList();
_consumersByTopic = consumers
.GroupBy(x => x.ConsumerSettings.Topic)
.ToDictionary(x => x.Key, x => x.ToList());
}
protected MessageBusBase(MessageBusSettings settings)
{
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
// Use the configured logger factory, if not provided try to resolve from DI, if also not available supress logging using the NullLoggerFactory
LoggerFactory = settings.LoggerFactory
?? (ILoggerFactory)settings.DependencyResolver?.Resolve(typeof(ILoggerFactory))
?? NullLoggerFactory.Instance;
_logger = LoggerFactory.CreateLogger <MessageBusBase>();
}
public KafkaMessageBus(MessageBusSettings settings, KafkaMessageBusSettings providerSettings)
: base(settings)
{
_logger = LoggerFactory.CreateLogger <KafkaMessageBus>();
ProviderSettings = providerSettings ?? throw new ArgumentNullException(nameof(providerSettings));
OnBuildProvider();
// TODO: Auto start should be a setting
Start();
}
public PipelineBuilder(Action <PipelineContext> publish, MessageBusSettings settings)
{
Steps = new List <Step>();
Steps.Add(new Step(WellKnownStep.MutateOutgoingMessages));
Steps.Add(new Step(WellKnownStep.MutateOutgoingTransportMessage));
Steps.Add(new PipelineStages.GetTopicStage(settings));
Steps.Add(new PipelineStages.GetRequestTimeoutStage(settings));
Steps.Add(new PipelineStages.SerializeTransportMessageStage(settings.Serializer));
Steps.Add(new SendInternalStage(settings));
Steps.Add(new PipelineStages.SerializeRequestResponseMessage(settings.Serializer, settings.MessageWithHeadersSerializer, settings.RequestResponse));
Steps.Add(new PublishStage(publish));
}
public KafkaMessageBusTest()
{
MbSettings = new MessageBusSettings
{
Serializer = new Mock <IMessageSerializer>().Object,
DependencyResolver = new Mock <IDependencyResolver>().Object
};
KafkaMbSettings = new KafkaMessageBusSettings("host")
{
ProducerFactory = (producerSettings) => new Mock <Producer>(Enumerable.Empty <KeyValuePair <string, object> >()).Object
};
KafkaMb = new Lazy <WrappedKafkaMessageBus>(() => new WrappedKafkaMessageBus(MbSettings, KafkaMbSettings));
}
public RedisMessageBus(MessageBusSettings settings, RedisMessageBusSettings redisSettings)
: base(settings)
{
RedisSettings = redisSettings;
IsRunning = false;
Connection = RedisSettings.ConnectionFactory();
Database = Connection.GetDatabase();
if (RedisSettings.AutoStartConsumers)
{
Start().Wait();
}
}
private static void AssertSettings(MessageBusSettings settings)
{
Assert.IsTrue(settings.Serializer != null,
() => new InvalidConfigurationMessageBusException($"{nameof(MessageBusSettings.Serializer)} was not set on {nameof(MessageBusSettings)} object"));
Assert.IsTrue(settings.DependencyResolver != null,
() => new InvalidConfigurationMessageBusException($"{nameof(MessageBusSettings.DependencyResolver)} was not set on {nameof(MessageBusSettings)} object"));
if (settings.RequestResponse != null)
{
Assert.IsTrue(settings.RequestResponse.Topic != null,
() => new InvalidConfigurationMessageBusException($"Request-response: topic was not set"));
}
}
public KafkaMessageBus(MessageBusSettings settings, KafkaMessageBusSettings kafkaSettings)
: base(settings)
{
AssertSettings(settings);
KafkaSettings = kafkaSettings;
CreateProducer();
CreateGroupConsumers(settings);
CreateProviders();
// TODO: Auto start should be a setting
Start();
}
protected MessageBusBase(MessageBusSettings settings)
{
AssertSettings(settings);
Settings = settings;
PublisherSettingsByMessageType = settings.Publishers.ToDictionary(x => x.MessageType);
PendingRequestStore = new InMemoryPendingRequestStore();
PendingRequestTimer = new Timer
{
Interval = 1000,
AutoReset = true
};
PendingRequestTimer.Elapsed += CleanPendingRequests;
PendingRequestTimer.Start();
}
protected MessageBusBase(MessageBusSettings settings)
{
AssertSettings(settings);
Settings = settings;
PublisherSettingsByMessageType = settings.Publishers.ToDictionary(x => x.MessageType);
PendingRequestStore = new InMemoryPendingRequestStore();
PendingRequestManager = new PendingRequestManager(PendingRequestStore, () => CurrentTime, TimeSpan.FromSeconds(1), request =>
{
// Execute the event hook
// ToDo: sort out the ConsumerSettings arg for req/resp, for now pass null
(Settings.RequestResponse.OnMessageExpired ?? Settings.OnMessageExpired)?.Invoke(null, request);
});
PendingRequestManager.Start();
}
public MessageBusMock()
{
ConsumerMock = new Mock <IConsumer <SomeMessage> >();
HandlerMock = new Mock <IRequestHandler <SomeRequest, SomeResponse> >();
ChildDependencyResolverMocks = new List <Mock <IDependencyResolver> >();
void SetupDependencyResolver(Mock <IDependencyResolver> mock)
{
mock.Setup(x => x.Resolve(typeof(IConsumer <SomeMessage>))).Returns(ConsumerMock.Object);
mock.Setup(x => x.Resolve(typeof(IRequestHandler <SomeRequest, SomeResponse>))).Returns(HandlerMock.Object);
}
DependencyResolverMock = new Mock <IDependencyResolver>();
SetupDependencyResolver(DependencyResolverMock);
DependencyResolverMock.Setup(x => x.CreateScope()).Returns(() =>
{
var mock = new Mock <IDependencyResolver>();
SetupDependencyResolver(mock);
ChildDependencyResolverMocks.Add(mock);
OnChildDependencyResolverCreated?.Invoke(mock);
mock.Setup(x => x.Dispose()).Callback(() =>
{
ChildDependencyResolverMocks.Remove(mock);
});
return(mock.Object);
});
SerializerMock = new Mock <IMessageSerializer>();
var mbSettings = new MessageBusSettings
{
DependencyResolver = DependencyResolverMock.Object,
Serializer = SerializerMock.Object
};
CurrentTime = DateTimeOffset.UtcNow;
BusMock = new Mock <MessageBusBase>(mbSettings);
BusMock.SetupGet(x => x.Settings).Returns(mbSettings);
BusMock.SetupGet(x => x.CurrentTime).Returns(() => CurrentTime);
}
public MessageBusMock()
{
DependencyResolverMock = new Mock <IDependencyResolver>();
SerializerMock = new Mock <IMessageSerializer>();
BusSettings = new MessageBusSettings
{
DependencyResolver = DependencyResolverMock.Object,
Serializer = SerializerMock.Object
};
CurrentTime = DateTimeOffset.UtcNow;
BusMock = new Mock <MessageBusBase>(BusSettings);
BusMock.SetupGet(x => x.Settings).Returns(BusSettings);
BusMock.SetupGet(x => x.CurrentTime).Returns(() => CurrentTime);
}
private void CreateGroupConsumers(MessageBusSettings settings)
{
Log.Info("Creating group consumers...");
var responseConsumerCreated = false;
Func <TopicPartition, IKafkaCommitController, IKafkaTopicPartitionProcessor> responseProcessorFactory =
(tp, cc) => new KafkaResponseProcessor(settings.RequestResponse, tp, cc, this);
foreach (var consumersByGroup in settings.Consumers.GroupBy(x => x.Group))
{
var group = consumersByGroup.Key;
var consumerByTopic = consumersByGroup.ToDictionary(x => x.Topic);
Func <TopicPartition, IKafkaCommitController, IKafkaTopicPartitionProcessor> consumerProcessorFactory =
(tp, cc) => new KafkaConsumerProcessor(consumerByTopic[tp.Topic], tp, cc, this);
var topics = consumerByTopic.Keys.ToList();
var processorFactory = consumerProcessorFactory;
// if responses are used and shared with the regular consumers group
if (settings.RequestResponse != null && group == settings.RequestResponse.Group)
{
// Note: response topic cannot be used in consumer topics - this is enforced in AssertSettings method
topics.Add(settings.RequestResponse.Topic);
processorFactory = (tp, cc) => tp.Topic == settings.RequestResponse.Topic
? responseProcessorFactory(tp, cc)
: consumerProcessorFactory(tp, cc);
responseConsumerCreated = true;
}
AddGroupConsumer(group, topics.ToArray(), processorFactory);
}
if (settings.RequestResponse != null && !responseConsumerCreated)
{
AddGroupConsumer(settings.RequestResponse.Group, new[] { settings.RequestResponse.Topic }, responseProcessorFactory);
}
Log.InfoFormat("Created {0} group consumers", _groupConsumers.Count);
}
public HybridMessageBus(MessageBusSettings settings, HybridMessageBusSettings providerSettings)
{
Settings = settings;
ProviderSettings = providerSettings;
_routeByMessageType = new Dictionary <Type, string>();
_busByName = new Dictionary <string, MessageBusBase>(providerSettings.Count);
foreach (var name in providerSettings.Keys)
{
var builderFunc = providerSettings[name];
var bus = BuildBus(builderFunc);
_busByName.Add(name, bus);
BuildAutoRouting(name, bus);
}
// ToDo: defer start of busses until here
}
public KafkaMessageBusTest()
{
var producerMock = new Mock <IProducer <byte[], byte[]> >();
producerMock.SetupGet(x => x.Name).Returns("Producer Name");
var producerBuilderMock = new Mock <ProducerBuilder <byte[], byte[]> >(new ProducerConfig());
producerBuilderMock.Setup(x => x.Build()).Returns(producerMock.Object);
MbSettings = new MessageBusSettings
{
Serializer = new Mock <IMessageSerializer>().Object,
DependencyResolver = new Mock <IDependencyResolver>().Object,
LoggerFactory = NullLoggerFactory.Instance
};
KafkaMbSettings = new KafkaMessageBusSettings("host")
{
ProducerBuilderFactory = (config) => producerBuilderMock.Object
};
KafkaMb = new Lazy <WrappedKafkaMessageBus>(() => new WrappedKafkaMessageBus(MbSettings, KafkaMbSettings));
}
public void BuildsProperSettings()
{
// arrange
var topic = "topic";
var settings = new MessageBusSettings();
// act
var subject = new ConsumerBuilder <SomeMessage>(settings)
.Topic(topic)
.Instances(3)
.WithConsumer <SomeMessageConsumer>();
// assert
subject.ConsumerSettings.MessageType.Should().Be(typeof(SomeMessage));
subject.MessageType.Should().Be(typeof(SomeMessage));
subject.Topic.Should().Be(topic);
subject.ConsumerSettings.Topic.Should().Be(topic);
subject.ConsumerSettings.Instances.Should().Be(3);
subject.ConsumerSettings.ConsumerType.Should().Be(typeof(SomeMessageConsumer));
subject.ConsumerSettings.ConsumerMode.Should().Be(ConsumerMode.Consumer);
subject.ConsumerSettings.IsRequestMessage.Should().BeFalse();
subject.ConsumerSettings.ResponseType.Should().BeNull();
}
public MessageBusMock()
{
ConsumerMock = new Mock <IConsumer <SomeMessage> >();
HandlerMock = new Mock <IRequestHandler <SomeRequest, SomeResponse> >();
DependencyResolverMock = new Mock <IDependencyResolver>();
DependencyResolverMock.Setup(x => x.Resolve(typeof(IConsumer <SomeMessage>))).Returns(ConsumerMock.Object);
DependencyResolverMock.Setup(x => x.Resolve(typeof(IRequestHandler <SomeRequest, SomeResponse>))).Returns(HandlerMock.Object);
SerializerMock = new Mock <IMessageSerializer>();
var mbSettings = new MessageBusSettings
{
DependencyResolver = DependencyResolverMock.Object,
Serializer = SerializerMock.Object
};
CurrentTime = DateTimeOffset.UtcNow;
BusMock = new Mock <MessageBusBase>(mbSettings);
BusMock.SetupGet(x => x.Settings).Returns(mbSettings);
BusMock.SetupGet(x => x.CurrentTime).Returns(() => CurrentTime);
}
