/// <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));
}
/// <inheritdoc />
public void Configure(JustSayingBus bus, IAwsClientFactoryProxy proxy, ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicAddressPublicationBuilder <T> >();
logger.LogInformation("Adding SNS publisher for message type '{MessageType}'", typeof(T));
var config = bus.Config;
var arn = Arn.Parse(_topicAddress.TopicArn);
bus.SerializationRegister.AddSerializer <T>();
var eventPublisher = new TopicAddressPublisher(
proxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(arn.Region)),
loggerFactory,
config.MessageSubjectProvider,
bus.SerializationRegister,
_exceptionHandler,
_topicAddress);
bus.AddMessagePublisher <T>(eventPublisher);
logger.LogInformation(
"Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'",
arn.Resource,
typeof(T));
}
/// <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 IVerifyAmazonQueues CreateQueueCreator(ILoggerFactory loggerFactory)
{
IAwsClientFactoryProxy proxy = CreateFactoryProxy();
IVerifyAmazonQueues queueCreator = new AmazonQueueCreator(proxy, loggerFactory);
return(queueCreator);
}
/// <inheritdoc />
void IPublicationBuilder <T> .Configure(
JustSayingBus bus,
IAwsClientFactoryProxy proxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueuePublicationBuilder <T> >();
logger.LogInformation("Adding SQS publisher for message type '{MessageType}'.",
typeof(T));
var config = bus.Config;
var region = config.Region ?? throw new InvalidOperationException($"Config cannot have a blank entry for the {nameof(config.Region)} property.");
var writeConfiguration = new SqsWriteConfiguration();
ConfigureWrites?.Invoke(writeConfiguration);
writeConfiguration.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
bus.SerializationRegister.AddSerializer <T>();
var regionEndpoint = RegionEndpoint.GetBySystemName(region);
var sqsClient = proxy.GetAwsClientFactory().GetSqsClient(regionEndpoint);
var eventPublisher = new SqsMessagePublisher(
sqsClient,
bus.SerializationRegister,
loggerFactory)
{
MessageResponseLogger = config.MessageResponseLogger
};
#pragma warning disable 618
var sqsQueue = new SqsQueueByName(
regionEndpoint,
writeConfiguration.QueueName,
sqsClient,
writeConfiguration.RetryCountBeforeSendingToErrorQueue,
loggerFactory);
#pragma warning restore 618
async Task StartupTask(CancellationToken cancellationToken)
{
if (!await sqsQueue.ExistsAsync(cancellationToken).ConfigureAwait(false))
{
await sqsQueue.CreateAsync(writeConfiguration, cancellationToken : cancellationToken).ConfigureAwait(false);
}
eventPublisher.QueueUrl = sqsQueue.Uri;
}
bus.AddStartupTask(StartupTask);
bus.AddMessagePublisher <T>(eventPublisher);
logger.LogInformation(
"Created SQS publisher for message type '{MessageType}' on queue '{QueueName}'.",
typeof(T),
writeConfiguration.QueueName);
}
protected internal JustSayingFluently(IAmJustSaying bus, IVerifyAmazonQueues queueCreator, IAwsClientFactoryProxy awsClientFactoryProxy, ILoggerFactory loggerFactory)
{
_loggerFactory = loggerFactory;
_log = _loggerFactory.CreateLogger("JustSaying");
Bus = bus;
_amazonQueueCreator = queueCreator;
_awsClientFactoryProxy = awsClientFactoryProxy;
}
/// <inheritdoc />
void IPublicationBuilder <T> .Configure(
JustSayingBus bus,
IAwsClientFactoryProxy proxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueuePublicationBuilder <T> >();
logger.LogInformation("Adding SQS publisher for message type '{MessageType}'.",
typeof(T));
var config = bus.Config;
var writeConfiguration = new SqsWriteConfiguration();
ConfigureWrites?.Invoke(writeConfiguration);
writeConfiguration.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
bus.SerializationRegister.AddSerializer <T>();
var regionEndpoint = RegionEndpoint.GetBySystemName(config.Region);
var sqsClient = proxy.GetAwsClientFactory().GetSqsClient(regionEndpoint);
#pragma warning disable 618
var eventPublisher = new SqsPublisher(
regionEndpoint,
writeConfiguration.QueueName,
sqsClient,
writeConfiguration.RetryCountBeforeSendingToErrorQueue,
bus.SerializationRegister,
loggerFactory)
{
MessageResponseLogger = config.MessageResponseLogger
};
#pragma warning restore 618
async Task StartupTask()
{
if (!await eventPublisher.ExistsAsync().ConfigureAwait(false))
{
await eventPublisher.CreateAsync(writeConfiguration).ConfigureAwait(false);
}
}
bus.AddStartupTask(StartupTask);
bus.AddMessagePublisher <T>(eventPublisher);
logger.LogInformation(
"Created SQS publisher for message type '{MessageType}' on queue '{QueueName}'.",
typeof(T),
writeConfiguration.QueueName);
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver handlerResolver,
IServiceResolver serviceResolver,
IVerifyAmazonQueues creator,
IAwsClientFactoryProxy awsClientFactoryProxy,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueueSubscriptionBuilder <T> >();
var attachedQueueConfig = new QueueAddressConfiguration();
ConfigureReads?.Invoke(attachedQueueConfig);
IAmazonSQS sqsClient = awsClientFactoryProxy
.GetAwsClientFactory()
.GetSqsClient(RegionEndpoint.GetBySystemName(_queueAddress.RegionName));
var queue = new QueueAddressQueue(_queueAddress, sqsClient);
attachedQueueConfig.SubscriptionGroupName ??= queue.QueueName;
attachedQueueConfig.Validate();
bus.AddQueue(attachedQueueConfig.SubscriptionGroupName, queue);
logger.LogInformation(
"Created SQS queue subscription for '{MessageType}' on '{QueueName}'",
typeof(T), queue.QueueName);
var resolutionContext = new HandlerResolutionContext(queue.QueueName);
var proposedHandler = handlerResolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
var middlewareBuilder = new HandlerMiddlewareBuilder(handlerResolver, serviceResolver);
var handlerMiddleware = middlewareBuilder
.Configure(MiddlewareConfiguration ?? (b => b.UseDefaults <T>(proposedHandler.GetType())))
.Build();
bus.AddMessageMiddleware <T>(queue.QueueName, handlerMiddleware);
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on queue '{QueueName}'",
typeof(T), queue.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);
}
private JustSayingFluently CreateFluent(JustSayingBus bus, ILoggerFactory loggerFactory)
{
IAwsClientFactoryProxy proxy = CreateFactoryProxy();
IVerifyAmazonQueues queueCreator = new AmazonQueueCreator(proxy, loggerFactory);
var fluent = new JustSayingFluently(bus, queueCreator, proxy, loggerFactory);
IMessageMonitor messageMonitor = CreateMessageMonitor();
IMessageContextAccessor messageContextAccessor = CreateMessageContextAccessor();
fluent.WithMonitoring(messageMonitor)
.WithMessageContextAccessor(messageContextAccessor);
if (ServicesBuilder?.MessageLock != null)
{
fluent.WithMessageLockStoreOf(ServicesBuilder.MessageLock());
}
return(fluent);
}
/// <inheritdoc />
public void Configure(JustSayingBus bus, IAwsClientFactoryProxy proxy, ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicAddressPublicationBuilder <T> >();
logger.LogInformation("Adding SQS publisher for message type '{MessageType}'", typeof(T));
bus.SerializationRegister.AddSerializer <T>();
var eventPublisher = new SqsMessagePublisher(
_queueAddress.QueueUrl,
proxy.GetAwsClientFactory().GetSqsClient(RegionEndpoint.GetBySystemName(_queueAddress.RegionName)),
bus.SerializationRegister,
loggerFactory);
bus.AddMessagePublisher <T>(eventPublisher);
logger.LogInformation(
"Created SQS queue publisher on queue URL '{QueueName}' for message type '{MessageType}'",
_queueAddress.QueueUrl,
typeof(T));
}
/// <summary>
/// Configures the subscriptions for the <see cref="JustSayingBus"/>.
/// </summary>
/// <param name="bus">The <see cref="JustSayingBus"/> to configure subscriptions for.</param>
/// <param name="serviceResolver">The <see cref="IServiceResolver"/> to use to resolve middleware with</param>
/// <param name="creator">The <see cref="IVerifyAmazonQueues"/>to use to create queues with.</param>
/// <param name="awsClientFactoryProxy">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>
/// <exception cref="InvalidOperationException">
/// No instance of <see cref="IHandlerResolver"/> could be resolved.
/// </exception>
internal void Configure(
JustSayingBus bus,
IServiceResolver serviceResolver,
IVerifyAmazonQueues creator,
IAwsClientFactoryProxy awsClientFactoryProxy,
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, serviceResolver, creator, awsClientFactoryProxy, loggerFactory);
}
}
public AmazonQueueCreator(IAwsClientFactoryProxy awsClientFactory, ILoggerFactory loggerFactory)
{
_awsClientFactory = awsClientFactory;
_loggerFactory = loggerFactory;
}
public AmazonQueueCreator(IAwsClientFactoryProxy awsClientFactory, ILoggerFactory loggerFactory)
{
_awsClientFactory = awsClientFactory;
_loggerFactory = loggerFactory;
_log = loggerFactory.CreateLogger("JustSaying");
}
public AmazonQueueCreator(IAwsClientFactoryProxy awsClientFactory)
{
_awsClientFactory = awsClientFactory;
}
internal protected JustSayingFluently(IAmJustSaying bus, IVerifyAmazonQueues queueCreator, IAwsClientFactoryProxy awsClientFactoryProxy)
{
Bus = bus;
_amazonQueueCreator = queueCreator;
this._awsClientFactoryProxy = awsClientFactoryProxy;
}
public AmazonQueueCreator(IAwsClientFactoryProxy awsClientFactory)
{
_awsClientFactory = awsClientFactory;
}
