/// <inheritdoc />
void IPublicationBuilder <T> .Configure(
JustSayingBus bus,
IAwsClientFactoryProxy proxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicPublicationBuilder <T> >();
logger.LogInformation("Adding SNS publisher for message type '{MessageType}'.",
typeof(T));
var config = bus.Config;
var readConfiguration = new SqsReadConfiguration(SubscriptionType.ToTopic);
var writeConfiguration = new SnsWriteConfiguration();
ConfigureWrites?.Invoke(writeConfiguration);
readConfiguration.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
bus.SerializationRegister.AddSerializer <T>();
foreach (var region in config.Regions)
{
// TODO pass region down into topic creation for when we have foreign topics so we can generate the arn
var eventPublisher = new SnsTopicByName(
readConfiguration.TopicName,
proxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)),
bus.SerializationRegister,
loggerFactory,
writeConfiguration,
config.MessageSubjectProvider)
{
MessageResponseLogger = config.MessageResponseLogger
};
async Task StartupTask()
{
if (writeConfiguration.Encryption != null)
{
await eventPublisher.CreateWithEncryptionAsync(writeConfiguration.Encryption)
.ConfigureAwait(false);
}
else
{
await eventPublisher.CreateAsync().ConfigureAwait(false);
}
await eventPublisher.EnsurePolicyIsUpdatedAsync(config.AdditionalSubscriberAccounts)
.ConfigureAwait(false);
}
bus.AddStartupTask(StartupTask());
bus.AddMessagePublisher <T>(eventPublisher, region);
}
logger.LogInformation(
"Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'.",
readConfiguration.TopicName,
typeof(T));
}
public static IMayWantOptionalSettings InRegions(params string[] regions)
{
var config = new MessagingConfig();
if (regions != null)
foreach (var region in regions)
{
config.Regions.Add(region);
}
config.Validate();
var messageSerialisationRegister = new MessageSerialisationRegister();
var justSayingBus = new JustSayingBus(config, messageSerialisationRegister);
var awsClientFactoryProxy = new AwsClientFactoryProxy(() => DefaultClientFactory());
var amazonQueueCreator = new AmazonQueueCreator(awsClientFactoryProxy);
var bus = new JustSayingFluently(justSayingBus, amazonQueueCreator, awsClientFactoryProxy);
bus
.WithMonitoring(new NullOpMessageMonitor())
.WithSerialisationFactory(new NewtonsoftSerialisationFactory());
return bus;
}
/// <summary>
/// Configures the publications for the <see cref="JustSayingBus"/>.
/// </summary>
/// <param name="bus">The <see cref="JustSayingBus"/> to configure subscriptions for.</param>
/// <param name="proxy">The <see cref="IAwsClientFactoryProxy"/> to use to create SQS/SNS clients with.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/> logger factory to use.</param>
internal void Configure(JustSayingBus bus, IAwsClientFactoryProxy proxy, ILoggerFactory loggerFactory)
{
foreach (IPublicationBuilder <Message> builder in Publications)
{
builder.Configure(bus, proxy, loggerFactory);
}
}
private JustSayingBus CreateBus(IMessagingConfig config, ILoggerFactory loggerFactory)
{
IMessageSerializationRegister register = ServiceResolver.ResolveService <IMessageSerializationRegister>();
IMessageMonitor monitor = ServiceResolver.ResolveOptionalService <IMessageMonitor>() ?? new NullOpMessageMonitor();
var bus = new JustSayingBus(config, register, loggerFactory, monitor);
return(bus);
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver resolver,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicSubscriptionBuilder <T> >();
var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic)
{
QueueName = TopicName
};
ConfigureReads?.Invoke(subscriptionConfig);
var config = bus.Config;
subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName;
subscriptionConfig.PublishEndpoint = subscriptionConfig.TopicName;
subscriptionConfig.Validate();
var queueWithStartup = creator.EnsureTopicExistsWithQueueSubscribed(
config.Region,
bus.SerializationRegister,
subscriptionConfig,
config.MessageSubjectProvider);
bus.AddStartupTask(queueWithStartup.StartupTask);
bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queueWithStartup.Queue);
logger.LogInformation(
"Created SQS topic subscription on topic '{TopicName}' and queue '{QueueName}'.",
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
var resolutionContext = new HandlerResolutionContext(subscriptionConfig.QueueName);
var proposedHandler = resolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
bus.AddMessageHandler(subscriptionConfig.QueueName,
() => resolver.ResolveHandler <T>(resolutionContext));
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
}
/// <summary>
/// Creates a new instance of <see cref="IMessagingBus"/>.
/// </summary>
/// <returns>
/// The created instance of <see cref="IMessagingBus"/>
/// </returns>
public IMessagingBus BuildSubscribers()
{
IMessagingConfig config = MessagingConfig.Build();
config.Validate();
ILoggerFactory loggerFactory = ServiceResolver.ResolveService <ILoggerFactory>();
JustSayingBus bus = CreateBus(config, loggerFactory);
IAwsClientFactoryProxy proxy = CreateFactoryProxy();
IVerifyAmazonQueues creator = new AmazonQueueCreator(proxy, loggerFactory);
SubscriptionBuilder.Configure(bus, ServiceResolver, creator, proxy, loggerFactory);
return(bus);
}
/// <summary>
/// Creates a new instance of <see cref="IMessagePublisher"/>.
/// </summary>
/// <returns>
/// The created instance of <see cref="IMessagePublisher"/>
/// </returns>
public IMessagePublisher BuildPublisher()
{
IMessagingConfig config = MessagingConfig.Build();
config.Validate();
ILoggerFactory loggerFactory = ServiceResolver.ResolveService <ILoggerFactory>();
JustSayingBus bus = CreateBus(config, loggerFactory);
IAwsClientFactoryProxy proxy = CreateFactoryProxy();
if (PublicationsBuilder != null)
{
PublicationsBuilder.Configure(bus, proxy, loggerFactory);
}
return(bus);
}
public static IMayWantOptionalSettings InRegion(string region)
{
var config = new MessagingConfig();
config.Regions.Add(region);
config.Validate();
var messageSerialisationRegister = new MessageSerialisationRegister();
var justSayingBus = new JustSayingBus(config, messageSerialisationRegister);
var amazonQueueCreator = new AmazonQueueCreator();
var bus = new JustSayingFluently(justSayingBus, amazonQueueCreator);
bus
.WithMonitoring(new NullOpMessageMonitor())
.WithSerialisationFactory(new NewtonsoftSerialisationFactory());
return bus;
}
/// <summary>
/// Configures the subscriptions for the <see cref="JustSayingBus"/>.
/// </summary>
/// <param name="bus">The <see cref="JustSayingBus"/> to configure subscriptions for.</param>
/// <param name="creator">The <see cref="IVerifyAmazonQueues"/>to use to create queues with.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/>logger factory to use.</param>
/// <exception cref="InvalidOperationException">
/// No instance of <see cref="IHandlerResolver"/> could be resolved.
/// </exception>
internal void Configure(
JustSayingBus bus,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var resolver = Parent.ServicesBuilder?.HandlerResolver?.Invoke() ??
Parent.ServiceResolver.ResolveService <IHandlerResolver>();
if (resolver == null)
{
throw new InvalidOperationException($"No {nameof(IHandlerResolver)} is registered.");
}
Defaults.Validate();
bus.SetGroupSettings(Defaults, SubscriptionGroupSettings);
foreach (ISubscriptionBuilder <Message> builder in Subscriptions)
{
builder.Configure(bus, resolver, creator, loggerFactory);
}
}
