/// <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 void EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdated(SqsBasicConfiguration queueConfig) { if (!Exists()) { Create(queueConfig); } else { UpdateQueueAttribute(queueConfig); } //Create an error queue for existing queues if they don't already have one if (ErrorQueue != null) { var errorQueueConfig = new SqsReadConfiguration(SubscriptionType.ToTopic) { ErrorQueueRetentionPeriodSeconds = queueConfig.ErrorQueueRetentionPeriodSeconds, ErrorQueueOptOut = true }; if (!ErrorQueue.Exists()) { ErrorQueue.Create(errorQueueConfig); } else { ErrorQueue.UpdateQueueAttribute(errorQueueConfig); } } UpdateRedrivePolicy(new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, ErrorQueue.Arn)); }
public ISubscriberIntoQueue WithSqsTopicSubscriber(string topicName = null) { _subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic) { BaseTopicName = (topicName ?? string.Empty).ToLower() }; return(this); }
public QueueWithAsyncStartup EnsureTopicExistsWithQueueSubscribed( string region, SqsReadConfiguration queueConfig) { var regionEndpoint = RegionEndpoint.GetBySystemName(region); var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint); var snsClient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(regionEndpoint); var queueWithStartup = EnsureQueueExists(region, queueConfig); async Task StartupTask(CancellationToken cancellationToken) { await queueWithStartup.StartupTask.Invoke(cancellationToken).ConfigureAwait(false); var queue = queueWithStartup.Queue; if (TopicExistsInAnotherAccount(queueConfig)) { var arnProvider = new ForeignTopicArnProvider(regionEndpoint, queueConfig.TopicSourceAccount, queueConfig.PublishEndpoint); var topicArn = await arnProvider.GetArnAsync().ConfigureAwait(false); await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, topicArn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false); } else { #pragma warning disable 618 var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsClient, _loggerFactory); #pragma warning restore 618 await eventTopic.CreateAsync(cancellationToken).ConfigureAwait(false); await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, eventTopic.Arn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false); var sqsDetails = new SqsPolicyDetails { SourceArn = eventTopic.Arn, QueueArn = queue.Arn, QueueUri = queue.Uri }; await SqsPolicy .SaveAsync(sqsDetails, sqsClient) .ConfigureAwait(false); } } return(new QueueWithAsyncStartup(StartupTask, queueWithStartup.Queue)); }
/// <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); }
/// <inheritdoc /> void ISubscriptionBuilder <T> .Configure( JustSayingBus bus, IHandlerResolver resolver, IVerifyAmazonQueues creator, ILoggerFactory loggerFactory) { var logger = loggerFactory.CreateLogger <QueueSubscriptionBuilder <T> >(); var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.PointToPoint) { QueueName = QueueName }; ConfigureReads?.Invoke(subscriptionConfig); var config = bus.Config; subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention); subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention); subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName; subscriptionConfig.Validate(); var queue = creator.EnsureQueueExists(config.Region, subscriptionConfig); bus.AddStartupTask( queue.Queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(subscriptionConfig)); bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queue.Queue); logger.LogInformation( "Created SQS subscriber for message type '{MessageType}' on queue '{QueueName}'.", typeof(T), 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); }
public async Task EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(SqsReadConfiguration queueConfig, CancellationToken cancellationToken) { if (queueConfig == null) { throw new ArgumentNullException(nameof(queueConfig)); } var exists = await ExistsAsync(cancellationToken).ConfigureAwait(false); if (!exists) { await CreateAsync(queueConfig, cancellationToken : cancellationToken).ConfigureAwait(false); } else { await UpdateQueueAttributeAsync(queueConfig, cancellationToken).ConfigureAwait(false); } await ApplyTagsAsync(this, queueConfig.Tags, cancellationToken).ConfigureAwait(false); //Create an error queue for existing queues if they don't already have one if (ErrorQueue != null && NeedErrorQueue(queueConfig)) { var errorQueueConfig = new SqsReadConfiguration(SubscriptionType.ToTopic) { ErrorQueueRetentionPeriod = queueConfig.ErrorQueueRetentionPeriod, ErrorQueueOptOut = true }; var errorQueueExists = await ErrorQueue.ExistsAsync(cancellationToken).ConfigureAwait(false); if (!errorQueueExists) { await ErrorQueue.CreateAsync(errorQueueConfig, cancellationToken : cancellationToken).ConfigureAwait(false); } else { await ErrorQueue.UpdateQueueAttributeAsync(errorQueueConfig, cancellationToken).ConfigureAwait(false); } await UpdateRedrivePolicyAsync( new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, ErrorQueue.Arn)).ConfigureAwait(false); await ApplyTagsAsync(ErrorQueue, queueConfig.Tags, cancellationToken).ConfigureAwait(false); } }
public QueueWithAsyncStartup EnsureQueueExists( string region, SqsReadConfiguration queueConfig) { var regionEndpoint = RegionEndpoint.GetBySystemName(region); var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint); #pragma warning disable 618 var queue = new SqsQueueByName(regionEndpoint, queueConfig.QueueName, sqsClient, queueConfig.RetryCountBeforeSendingToErrorQueue, _loggerFactory); #pragma warning restore 618 var startupTask = new Func <CancellationToken, Task>(ct => queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync( queueConfig, ct)); return(new QueueWithAsyncStartup(startupTask, queue)); }
public async Task TagsAreAppliedToParentAndErrorQueues() { // Arrange var sut = new SqsQueueByName(RegionEndpoint.EUWest1, QueueName, _client, 3, NullLoggerFactory.Instance); var config = new SqsReadConfiguration(SubscriptionType.ToTopic) { Tags = new Dictionary <string, string> { ["TagOne"] = "tag-one", ["TagTwo"] = "tag-two" } }; // Act await sut.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(config, CancellationToken.None); // Assert await _client.Received(1).TagQueueAsync(Arg.Is <TagQueueRequest>(req => req.QueueUrl == QueueUrl && req.Tags == config.Tags)); }
private IHaveFulfilledPublishRequirements AddSnsMessagePublisher <T>(Action <SnsWriteConfiguration> configBuilder) where T : Message { _log.LogInformation("Adding SNS publisher for message type '{MessageType}'.", typeof(T)); _subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic); var snsWriteConfig = new SnsWriteConfiguration(); configBuilder?.Invoke(snsWriteConfig); _subscriptionConfig.TopicName = GetOrUseTopicNamingConvention <T>(_subscriptionConfig.TopicName); Bus.SerializationRegister.AddSerializer <T>(); foreach (var region in Bus.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( _subscriptionConfig.TopicName, _awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)), Bus.SerializationRegister, _loggerFactory, snsWriteConfig, Bus.Config.MessageSubjectProvider) { MessageResponseLogger = Bus.Config.MessageResponseLogger }; CreatePublisher(eventPublisher, snsWriteConfig); eventPublisher.EnsurePolicyIsUpdatedAsync(Bus.Config.AdditionalSubscriberAccounts).GetAwaiter().GetResult(); Bus.AddMessagePublisher <T>(eventPublisher, region); } _log.LogInformation("Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'.", _subscriptionConfig.TopicName, typeof(T)); return(this); }
public async Task EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(SqsBasicConfiguration queueConfig) { var exists = await ExistsAsync(); if (!exists) { await CreateAsync(queueConfig); } else { await UpdateQueueAttributeAsync(queueConfig); } //Create an error queue for existing queues if they don't already have one if (ErrorQueue != null && NeedErrorQueue(queueConfig)) { var errorQueueConfig = new SqsReadConfiguration(SubscriptionType.ToTopic) { ErrorQueueRetentionPeriodSeconds = queueConfig.ErrorQueueRetentionPeriodSeconds, ErrorQueueOptOut = true }; var errorQueueExists = await ErrorQueue.ExistsAsync(); if (!errorQueueExists) { await ErrorQueue.CreateAsync(errorQueueConfig); } else { await ErrorQueue.UpdateQueueAttributeAsync(errorQueueConfig); } await UpdateRedrivePolicyAsync( new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, ErrorQueue.Arn)); } }
public string GetQueueName(SqsReadConfiguration sqsConfig, string messageType) { return($"{messageType}-{_env}"); }
public string GetQueueName(SqsReadConfiguration sqsConfig, string messageType) => string.IsNullOrWhiteSpace(sqsConfig.BaseQueueName) ? messageType.ToLower() : sqsConfig.BaseQueueName.ToLower();
public string GetQueueName(SqsReadConfiguration sqsConfig, Type messageType) => string.IsNullOrWhiteSpace(sqsConfig.BaseQueueName) ? messageType.ToTopicName().ToLowerInvariant() : sqsConfig.BaseQueueName.ToLowerInvariant();
public string GetQueueName(SqsReadConfiguration sqsConfig, Type messageType) { return((sqsConfig.BaseQueueName + ticks).ToLower()); }
public string GetQueueName(SqsReadConfiguration sqsConfig, string messageType) { throw new NotImplementedException(); }
public ISubscriberIntoQueue WithSqsPointToPointSubscriber() { _subscriptionConfig = new SqsReadConfiguration(SubscriptionType.PointToPoint); return(this); }
private static bool TopicExistsInAnotherAccount(SqsReadConfiguration queueConfig) { return(!string.IsNullOrWhiteSpace(queueConfig.TopicSourceAccount)); }
public string GetQueueName(SqsReadConfiguration sqsConfig, string messageType) { return("test-" + messageType); }
public virtual IPublishEndpointProvider CreatePublisherEndpointProvider(SqsReadConfiguration subscriptionConfig) { return(new SnsPublishEndpointProvider(subscriptionConfig.Topic)); }
public virtual IPublishSubscribtionEndpointProvider CreateSqsSubscriptionEndpointProvider(SqsReadConfiguration subscriptionConfig) { return(new SqsSubscribtionEndpointProvider(subscriptionConfig)); }
public ISubscriberIntoQueue WithSqsTopicSubscriber() { _subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic); return(this); }
private static void ReadConfig(SqsReadConfiguration readConfig) => readConfig.QueueName = QueueName;
public string GetQueueName(SqsReadConfiguration sqsConfig, Type messageType) { return("test-" + messageType.ToTopicName()); }
public SqsSubscribtionEndpointProvider(SqsReadConfiguration config) { _config = config; }