/// <summary> /// Register for publishing messages to SNS /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message { Log.Info("Adding SNS publisher"); _subscriptionConfig.Topic = GetMessageTypeName <T>(); var namingStrategy = GetNamingStrategy(); Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>()); var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, GetMessageTypeName <T>()); foreach (var region in Bus.Config.Regions) { var eventPublisher = new SnsTopicByName( topicName, _awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)), Bus.SerialisationRegister); if (!eventPublisher.Exists()) { eventPublisher.Create(); } Bus.AddMessagePublisher <T>(eventPublisher, region); } Log.Info(string.Format("Created SNS topic publisher - Topic: {0}", _subscriptionConfig.Topic)); return(this); }
private protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync() { var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), new NonGenericMessageSubjectProvider()); await topic.ExistsAsync(); return(topic); }
public SqsQueueByName VerifyOrCreateQueue(string region, IMessageSerialisationRegister serialisationRegister, SqsConfiguration queueConfig) { var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region)); var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region)); var queue = new SqsQueueByName(queueConfig.QueueName, sqsclient, queueConfig.RetryCountBeforeSendingToErrorQueue); var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister); if (!queue.Exists()) queue.Create(queueConfig.MessageRetentionSeconds, 0, queueConfig.VisibilityTimeoutSeconds, queueConfig.ErrorQueueOptOut, queueConfig.RetryCountBeforeSendingToErrorQueue); //Create an error queue for existing queues if they don't already have one if(queue.ErrorQueue != null && !queue.ErrorQueue.Exists()) queue.ErrorQueue.Create(JustSayingConstants.MAXIMUM_RETENTION_PERIOD, JustSayingConstants.DEFAULT_CREATE_REATTEMPT, JustSayingConstants.DEFAULT_VISIBILITY_TIMEOUT, errorQueueOptOut: true); queue.UpdateRedrivePolicy(new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, queue.ErrorQueue.Arn)); if (!eventTopic.Exists()) eventTopic.Create(); if (!eventTopic.IsSubscribed(queue)) eventTopic.Subscribe(queue); if (!queue.HasPermission(eventTopic)) queue.AddPermission(eventTopic); return queue; }
/// <summary> /// Register for publishing messages to SNS /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message { _log.LogInformation("Adding SNS publisher"); _subscriptionConfig.Topic = GetMessageTypeName <T>(); var namingStrategy = GetNamingStrategy(); Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>()); var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, GetMessageTypeName <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( topicName, _awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)), Bus.SerialisationRegister, _loggerFactory); if (!eventPublisher.Exists()) { eventPublisher.Create(); } eventPublisher.EnsurePolicyIsUpdated(Bus.Config.AdditionalSubscriberAccounts); Bus.AddMessagePublisher <T>(eventPublisher, region); } _log.LogInformation($"Created SNS topic publisher - Topic: {_subscriptionConfig.Topic}"); return(this); }
public async Task <SqsQueueByName> EnsureTopicExistsWithQueueSubscribedAsync(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig, IMessageSubjectProvider messageSubjectProvider) { var regionEndpoint = RegionEndpoint.GetBySystemName(region); var sqsClient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(regionEndpoint); var snsClient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(regionEndpoint); var queue = await EnsureQueueExistsAsync(region, queueConfig).ConfigureAwait(false); 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 { var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsClient, serialisationRegister, _loggerFactory, messageSubjectProvider); await eventTopic.CreateAsync().ConfigureAwait(false); await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, eventTopic.Arn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false); await SqsPolicy.SaveAsync(eventTopic.Arn, queue.Arn, queue.Uri, sqsClient).ConfigureAwait(false); } return(queue); }
public async Task Then_An_Exception_Is_Not_Thrown() { // Arrange string topicName = Guid.NewGuid().ToString(); ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAwsClientFactory clientFactory = CreateClientFactory(); var subjectProvider = new NonGenericMessageSubjectProvider(); var serializationRegister = new MessageSerializationRegister(subjectProvider); var client = clientFactory.GetSnsClient(Region); var topic = new SnsTopicByName( topicName, client, serializationRegister, loggerFactory, subjectProvider); // Act and Assert (await topic.CreateAsync()).ShouldBeTrue(); (await topic.CreateAsync()).ShouldBeTrue(); topic.Arn.ShouldNotBeNull(); topic.Arn.ShouldEndWith(topic.TopicName); }
/// <summary> /// Register for publishing messages to SNS /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public IHaveFulfilledPublishRequirements WithSnsMessagePublisher <T>() where T : Message { Log.Info("Adding SNS publisher"); _subscriptionConfig.Topic = typeof(T).ToTopicName(); var publishEndpointProvider = CreatePublisherEndpointProvider(_subscriptionConfig); Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>()); foreach (var region in Bus.Config.Regions) { var eventPublisher = new SnsTopicByName( publishEndpointProvider.GetLocationName(), AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region)), Bus.SerialisationRegister); if (!eventPublisher.Exists()) { eventPublisher.Create(); } Bus.AddMessagePublisher <T>(eventPublisher, region); } Log.Info(string.Format("Created SNS topic publisher - Topic: {0}", _subscriptionConfig.Topic)); return(this); }
/// <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>(); // 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(config.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); logger.LogInformation( "Created SNS topic publisher on topic '{TopicName}' for message type '{MessageType}'.", readConfiguration.TopicName, typeof(T)); }
private protected override Task <SnsTopicByName> CreateSystemUnderTestAsync() { var topicByName = new SnsTopicByName("TopicName", Sns, NullLoggerFactory.Instance) { Tags = _tags }; return(Task.FromResult(topicByName)); }
private protected override Task <SnsTopicByName> CreateSystemUnderTestAsync() { var topicByName = new SnsTopicByName("TopicName", Sns, Substitute.For <IMessageSerializationRegister>(), Substitute.For <ILoggerFactory>(), new NonGenericMessageSubjectProvider()) { Tags = _tags }; return(Task.FromResult(topicByName)); }
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)); }
private static SnsTopicByName EnsureTopicExists(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig) { var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region)); var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister); if (!eventTopic.Exists()) eventTopic.Create(); return eventTopic; }
public QueueWithAsyncStartup <SqsQueueByName> EnsureTopicExistsWithQueueSubscribed( string region, IMessageSerializationRegister serializationRegister, SqsReadConfiguration queueConfig, IMessageSubjectProvider messageSubjectProvider) { 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() { await queueWithStartup.StartupTask.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 { var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsClient, serializationRegister, _loggerFactory, messageSubjectProvider); await eventTopic.CreateAsync().ConfigureAwait(false); await SubscribeQueueAndApplyFilterPolicyAsync(snsClient, eventTopic.Arn, sqsClient, queue.Uri, queueConfig.FilterPolicy).ConfigureAwait(false); await SqsPolicy .SaveAsync(eventTopic.Arn, queue.Arn, queue.Uri, sqsClient) .ConfigureAwait(false); } } // This StartupTask is intentionally not awaited, as it will be run when the bus is started. return(new QueueWithAsyncStartup <SqsQueueByName>(StartupTask(), queueWithStartup.Queue)); }
private static void CreatePublisher(SnsTopicByName eventPublisher, SnsWriteConfiguration snsWriteConfig) { if (snsWriteConfig.Encryption != null) { eventPublisher.CreateWithEncryptionAsync(snsWriteConfig.Encryption).GetAwaiter().GetResult(); } else { eventPublisher.CreateAsync().GetAwaiter().GetResult(); } }
protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync() { var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), new SnsWriteConfiguration { HandleException = (ex, m) => false }, Substitute.For <IMessageSubjectProvider>()); await topic.ExistsAsync(); return(topic); }
protected override async Task When() { _topic = new SnsTopicByName( UniqueName, Client, new MessageSerialisationRegister(new NonGenericMessageSubjectProvider()), LoggerFactory, new NonGenericMessageSubjectProvider()); _createWasSuccessful = await _topic.CreateAsync(); }
private static void EnsureQueueIsSubscribedToTopic(SnsTopicByName eventTopic, SqsQueueByName queue) { if (!eventTopic.IsSubscribed(queue)) { eventTopic.Subscribe(queue); } if (!queue.HasPermission(eventTopic)) { queue.AddPermission(eventTopic); } }
private static SnsTopicByName EnsureTopicExists(string region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig) { var snsclient = AWSClientFactory.CreateAmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(region)); var eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister); if (!eventTopic.Exists()) { eventTopic.Create(); } return(eventTopic); }
protected override async Task When() { var snsClient = new NoTopicCreationAwsClientFactory().GetSnsClient(Region); _topic = new SnsTopicByName( UniqueName, snsClient, new MessageSerializationRegister(new NonGenericMessageSubjectProvider()), LoggerFactory, new NonGenericMessageSubjectProvider()); _createWasSuccessful = await _topic.CreateAsync(); }
private protected override async Task <SnsTopicByName> CreateSystemUnderTestAsync() { var topic = new SnsTopicByName("TopicName", Sns, _serializationRegister, Substitute.For <ILoggerFactory>(), Substitute.For <SnsWriteConfiguration>(), Substitute.For <IMessageSubjectProvider>()) { MessageResponseLogger = (r, m) => { _response = r; _message = m; } }; await topic.ExistsAsync(); return(topic); }
private SnsTopicByName EnsureTopicExists(RegionEndpoint region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig) { var snsclient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(region); var eventTopic = _topicCache.TryGetFromCache(region.SystemName, queueConfig.PublishEndpoint); if (eventTopic != null) return eventTopic; eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister); _topicCache.AddToCache(region.SystemName, queueConfig.PublishEndpoint, eventTopic); if (!eventTopic.Exists()) eventTopic.Create(); return eventTopic; }
public async Task Cannot_Create_Topic_Because_Not_Authorized() { // Arrange string topicName = Guid.NewGuid().ToString(); ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAmazonSimpleNotificationService client = CreateSnsClient(exists: false); var topic = new SnsTopicByName( topicName, client, loggerFactory); // Act and Assert await Assert.ThrowsAsync <InvalidOperationException>(() => topic.CreateAsync(CancellationToken.None)); }
public async Task Can_Create_Topic_With_Encryption() { // Arrange ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAwsClientFactory clientFactory = CreateClientFactory(); var client = clientFactory.GetSnsClient(Region); var topic = new SnsTopicByName( UniqueName, client, loggerFactory); // Act await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId }, CancellationToken.None); // Assert topic.ServerSideEncryption.KmsMasterKeyId.ShouldBe(JustSayingConstants.DefaultSnsAttributeEncryptionKeyId); }
public async Task Arn_Still_Retrieved_When_It_Already_Exists() { // Arrange string topicName = Guid.NewGuid().ToString(); ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAmazonSimpleNotificationService client = CreateSnsClient(exists: true); var topic = new SnsTopicByName( topicName, client, loggerFactory); // Act await topic.CreateAsync(CancellationToken.None); // Assert topic.Arn.ShouldNotBeNull(); }
private IHaveFulfilledPublishRequirements AddSnsMessagePublisher <T>(Action <SnsWriteConfiguration> configBuilder) where T : Message { _log.LogInformation("Adding SNS publisher for message type '{MessageType}'.", typeof(T)); var snsWriteConfig = new SnsWriteConfiguration(); configBuilder?.Invoke(snsWriteConfig); _subscriptionConfig.Topic = typeof(T).ToTopicName(); var namingStrategy = GetNamingStrategy(); Bus.SerializationRegister.AddSerializer <T>(_serializationFactory.GetSerializer <T>()); var topicName = namingStrategy.GetTopicName(_subscriptionConfig.BaseTopicName, typeof(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( topicName, _awsClientFactoryProxy.GetAwsClientFactory().GetSnsClient(RegionEndpoint.GetBySystemName(region)), Bus.SerializationRegister, _loggerFactory, snsWriteConfig, Bus.Config.MessageSubjectProvider) { MessageResponseLogger = Bus.Config.MessageResponseLogger }; eventPublisher.CreateAsync().GetAwaiter().GetResult(); 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.Topic, typeof(T)); return(this); }
private SnsTopicByName EnsureTopicExists(RegionEndpoint region, IMessageSerialisationRegister serialisationRegister, SqsReadConfiguration queueConfig) { var snsclient = _awsClientFactory.GetAwsClientFactory().GetSnsClient(region); var eventTopic = _topicCache.TryGetFromCache(region.SystemName, queueConfig.PublishEndpoint); if (eventTopic != null) { return(eventTopic); } eventTopic = new SnsTopicByName(queueConfig.PublishEndpoint, snsclient, serialisationRegister); _topicCache.AddToCache(region.SystemName, queueConfig.PublishEndpoint, eventTopic); if (!eventTopic.Exists()) { eventTopic.Create(); } return(eventTopic); }
public async Task Cannot_Create_Topic_Because_Not_Authorized() { // Arrange string topicName = Guid.NewGuid().ToString(); ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); var subjectProvider = new NonGenericMessageSubjectProvider(); var serializationRegister = new MessageSerializationRegister(subjectProvider); IAmazonSimpleNotificationService client = CreateSnsClient(exists: false); var topic = new SnsTopicByName( topicName, client, serializationRegister, loggerFactory, subjectProvider); // Act and Assert await Assert.ThrowsAsync <InvalidOperationException>(() => topic.CreateAsync()); }
public async Task Then_An_Exception_Is_Not_Thrown() { // Arrange string topicName = Guid.NewGuid().ToString(); ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAwsClientFactory clientFactory = CreateClientFactory(); var client = clientFactory.GetSnsClient(Region); var topic = new SnsTopicByName( topicName, client, loggerFactory); // Shouldn't throw await topic.CreateAsync(CancellationToken.None); await topic.CreateAsync(CancellationToken.None); topic.Arn.ShouldNotBeNull(); topic.Arn.ShouldEndWith(topic.TopicName); }
public async Task Can_Update_Encryption_For_Existing_Topic() { // Arrange ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAwsClientFactory clientFactory = CreateClientFactory(); var client = clientFactory.GetSnsClient(Region); var topic = new SnsTopicByName( UniqueName, client, null, loggerFactory, null); await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = "previousKeyId" }); // Act await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId }); // Assert topic.ServerSideEncryption.KmsMasterKeyId.ShouldBe(JustSayingConstants.DefaultSnsAttributeEncryptionKeyId); }
public async Task Can_Remove_Encryption() { // Arrange ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory(); IAwsClientFactory clientFactory = CreateClientFactory(); var client = clientFactory.GetSnsClient(Region); var topic = new SnsTopicByName( UniqueName, client, null, loggerFactory, null); await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = JustSayingConstants.DefaultSnsAttributeEncryptionKeyId }); // Act await topic.CreateWithEncryptionAsync(new ServerSideEncryption { KmsMasterKeyId = String.Empty }); // Assert topic.ServerSideEncryption.ShouldBeNull(); }
private void EnsureQueueIsSubscribedToTopic(RegionEndpoint region, SnsTopicByName eventTopic, SqsQueueByName queue) { var sqsclient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(region); eventTopic.Subscribe(sqsclient, queue); }
protected override void When() { _topic = new SnsTopicByName(UniqueName, Bus, new MessageSerialisationRegister(new NonGenericMessageSubjectProvider()), new LoggerFactory(), new NonGenericMessageSubjectProvider()); _createWasSuccessful = _topic.CreateAsync().GetAwaiter().GetResult(); }
private async Task <bool> EnsureQueueIsSubscribedToTopic(SnsTopicByName eventTopic, SqsQueueByName queue) { return(await eventTopic.SubscribeAsync(queue).ConfigureAwait(false)); }
private void EnsureQueueIsSubscribedToTopic(RegionEndpoint region, SnsTopicByName eventTopic, SqsQueueByName queue) { var sqsclient = _awsClientFactory.GetAwsClientFactory().GetSqsClient(region); eventTopic.Subscribe(sqsclient, queue); }
private static void EnsureQueueIsSubscribedToTopic(string region, SnsTopicByName eventTopic, SqsQueueByName queue) { var sqsclient = AWSClientFactory.CreateAmazonSQSClient(RegionEndpoint.GetBySystemName(region)); eventTopic.Subscribe(sqsclient, queue); }