public async Task Can_Update_Retention_Period()
{
// Arrange
var oldRetentionPeriod = TimeSpan.FromSeconds(600);
var newRetentionPeriod = TimeSpan.FromSeconds(700);
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration { MessageRetention = oldRetentionPeriod });
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration { MessageRetention = newRetentionPeriod }, CancellationToken.None);
// Assert
queue.MessageRetentionPeriod.ShouldBe(newRetentionPeriod);
}
public KinesisStreamCreator(IAwsClientFactory clientFactory, string rawStreamName, string measurementsStreamName, ILogger logger)
{
_client = clientFactory.CreateKinesisClient();
_rawStreamName = rawStreamName;
_measurementsStreamName = measurementsStreamName;
_logger = logger;
}
public async Task Then_The_Error_Queue_Is_Not_Created()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
// Act
await queue.CreateAsync(new SqsBasicConfiguration()
{
ErrorQueueOptOut = true
});
// Assert
await Patiently.AssertThatAsync(
OutputHelper, async() => !await queue.ErrorQueue.ExistsAsync(CancellationToken.None));
}
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);
}
public UpdateItemHandler(DynamoDbConfiguration configuration,
IAwsClientFactory <AmazonDynamoDBClient> clientFactory)
{
var dynamoClient = clientFactory.GetAwsClient();
_table = Table.LoadTable(dynamoClient, configuration.TableName);
}
public async Task Can_Update_Redrive_Policy()
{
// Arrange
int maximumReceives = 42;
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(new SqsBasicConfiguration());
// Act
await queue.UpdateRedrivePolicyAsync(
new RedrivePolicy(maximumReceives, queue.ErrorQueue.Arn));
// Assert
queue.RedrivePolicy.ShouldNotBeNull();
queue.RedrivePolicy.MaximumReceives.ShouldBe(maximumReceives);
}
protected AwsTaskBase(IAwsClientFactory awsClientFactory, ITaskLogger logger)
: this(awsClientFactory)
{
if (logger == null) throw new ArgumentNullException("logger");
Logger = logger;
}
public UpdateAllStacks(
IAwsClientFactory awsClientFactory,
IRepository <AwsProfile> profileRepository,
StackLoader stackLoader) : base(profileRepository, awsClientFactory)
{
_stackLoader = stackLoader;
}
public AwsBusConfig(Dictionary <Type, string> queueUrlsByType, Dictionary <Type, string> topicArnsByType, IQueueAndTopicNamingConvention queueAndTopicNamingConvention, IAwsClientFactory clientFactory)
{
QueueUrlsByType = queueUrlsByType;
TopicArnsByType = topicArnsByType;
QueueAndTopicNamingConvention = queueAndTopicNamingConvention;
ClientFactory = clientFactory;
}
public async Task Can_Remove_Encryption()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration { ServerSideEncryption = new ServerSideEncryption() });
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration { ServerSideEncryption = null });
// Assert
queue.ServerSideEncryption.ShouldBeNull();
}
public UpdateAllImages(
IAwsClientFactory awsClientFactory,
IRepository <BaseImage> imageRepository,
IRepository <AwsProfile> profileRepository) : base(profileRepository, awsClientFactory)
{
_imageRepository = imageRepository;
}
public async Task Can_Update_Delivery_Delay()
{
// Arrange
var oldDeliveryDelay = TimeSpan.FromMinutes(2);
var newDeliveryDelay = TimeSpan.FromMinutes(5);
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration()
{
DeliveryDelay = oldDeliveryDelay
});
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration()
{
DeliveryDelay = newDeliveryDelay
});
// Assert
queue.DeliveryDelay.ShouldBe(newDeliveryDelay);
}
public async Task Then_The_Message_Retention_Period_Is_Updated()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new ErrorQueue(
Region,
UniqueName,
client,
loggerFactory);
var queueConfig = new SqsBasicConfiguration()
{
ErrorQueueRetentionPeriod = JustSayingConstants.MaximumRetentionPeriod,
ErrorQueueOptOut = true,
};
// Act
await queue.CreateAsync(queueConfig);
queueConfig.ErrorQueueRetentionPeriod = TimeSpan.FromSeconds(100);
await queue.UpdateQueueAttributeAsync(queueConfig, CancellationToken.None);
// Assert
queue.MessageRetentionPeriod.ShouldBe(TimeSpan.FromSeconds(100));
}
public UpdateAllInstances(
IAwsClientFactory awsClientFactory,
IRepository <InstanceEntity> instanceRepository,
IRepository <AwsProfile> profileRepository
) : base(profileRepository, awsClientFactory)
{
_instanceRepository = instanceRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TemplateResolver"/> class.
/// </summary>
/// <param name="clientFactory">The client factory.</param>
/// <param name="context">The context.</param>
/// <param name="templateStage">Template stage to retrieve.</param>
/// <param name="stackName">Name of the stack.</param>
/// <param name="usePreviousTemplate">if set to <c>true</c> [use previous template].</param>
/// <param name="forceS3">If set to <c>true</c>, force template upload to S3 even if less than max size.</param>
public TemplateResolver(IAwsClientFactory clientFactory, ICloudFormationContext context, TemplateStage templateStage, string stackName, bool usePreviousTemplate, bool forceS3)
: base(clientFactory, context)
{
this.usePreviousTemplate = usePreviousTemplate;
this.stackName = stackName;
this.ForceS3 = forceS3;
this.templateStage = templateStage;
}
public UpdateStack(
IAwsClientFactory awsClientFactory,
IRepository<AwsProfile> profileRepository,
StackLoader stackLoader)
: base(profileRepository, awsClientFactory)
{
_stackLoader = stackLoader;
}
public StreamProcessor(IBusFactory busFactory,
IAwsClientFactory awsClientFactory,
IAwsKinesisFactory awsKinesisFactory,
IOptions <AwsSettings> awsOptions,
IOptions <ServerSettings> serverOptions,
IMapper mapper,
ILogger <StreamProcessor> logger,
IMembershipService membershipService,
ICheckpointRepository checkpointRepository)
{
if (busFactory == null)
{
throw new ArgumentNullException(nameof(busFactory));
}
if (awsClientFactory == null)
{
throw new ArgumentNullException("awsClientFactory");
}
if (awsOptions == null)
{
throw new ArgumentNullException(nameof(awsOptions));
}
if (serverOptions == null)
{
throw new ArgumentNullException(nameof(serverOptions));
}
if (mapper == null)
{
throw new ArgumentNullException(nameof(mapper));
}
_eventBus = busFactory.CreateEventsBus();
_kinesisFactory = awsKinesisFactory;
_mapper = mapper;
_logger = logger;
_membershipService = membershipService;
_serverSettings = serverOptions.Value;
_checkpointRepository = checkpointRepository;
var processedMeasurementStreamWriter = _kinesisFactory.CreateWriter();
var recordProcessingFactory = new RecordProcessorFactory(membershipService, logger);
_rawMeasurementsStreamReader = _kinesisFactory.CreateReader(
recordProcessingFactory,
_checkpointRepository,
processedMeasurementStreamWriter);
// Handle processed measurements.
// Read from the processed measurements stream and publish out to
// EasyNetQ/RabbitQ. This should be removed once
// all other services (Web/MQTT/Notifier/Membership) are getting measurements
// from the processed stream rather than the queue
_processedMeasurementsStreamReader = _kinesisFactory.CreateProcesssedMeasurementsReader(
_checkpointRepository,
_eventBus);
}
public UpdateAllInstances(
IAwsClientFactory awsClientFactory,
IRepository<InstanceEntity> instanceRepository,
IRepository<AwsProfile> profileRepository
)
: base(profileRepository, awsClientFactory)
{
_instanceRepository = instanceRepository;
}
internal AwsTaskBase(IAwsClientFactory awsClientFactory)
{
if (awsClientFactory == null)
{
throw new ArgumentNullException("awsClientFactory");
}
AwsClientFactory = awsClientFactory;
}
public NoteDynamoRepository(DynamoDbConfiguration configuration,
IAwsClientFactory <AmazonDynamoDBClient> clientFactory)
{
_client = clientFactory.GetAwsClient();
_configuration = new DynamoDBOperationConfig
{
OverrideTableName = $"{Environment.GetEnvironmentVariable("stage")}-notes",
SkipVersionCheck = true
};
}
protected DynamoRepositoryBase(IAwsClientFactory clientFactory, IOptions <AwsSettings> awsOptions)
{
if (clientFactory == null)
{
throw new ArgumentNullException("clientFactory");
}
TablePrefix = awsOptions.Value.DynamoDbTablePrefix;
Client = clientFactory.CreateDynamoDBClient();
}
public AwsKinesisFactory(IAwsClientFactory clientFactory,
IOptions <AwsSettings> awsOptions,
IHeartbeatService heartbeatService,
ILogger logger)
{
_clientFactory = clientFactory;
_heartbeatService = heartbeatService;
_logger = logger;
_awsSettings = awsOptions.Value;
}
public RemoveStaleInstances(
IAwsClientFactory awsClientFactory,
IRepository <Instance> instanceRepository,
IRepository <AwsProfile> profileRepository,
IBackgroundJobClient backgroundJobClient)
: base(profileRepository, awsClientFactory)
{
_instanceRepository = instanceRepository;
_backgroundJobClient = backgroundJobClient;
}
public MediaRepositoryMigrationV3(AwsDynamoDbConfig config, IAwsClientFactory clientFactory)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_tablePrefix = config.TablePrefix;
_client = clientFactory.CreateDynamoDBClient();
}
public RemoveStaleInstances(
IAwsClientFactory awsClientFactory,
IRepository<Instance> instanceRepository,
IRepository<AwsProfile> profileRepository,
IBackgroundJobClient backgroundJobClient)
: base(profileRepository, awsClientFactory)
{
_instanceRepository = instanceRepository;
_backgroundJobClient = backgroundJobClient;
}
protected AwsTaskBase(IAwsClientFactory awsClientFactory, ITaskLogger logger)
: this(awsClientFactory)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Logger = logger;
}
public ItemDynamoRepository(DynamoDbConfiguration configuration,
IAwsClientFactory <AmazonDynamoDBClient> clientFactory)
{
_client = clientFactory.GetAwsClient();
_configuration = new DynamoDBOperationConfig
{
OverrideTableName = configuration.TableName,
SkipVersionCheck = true
};
}
public async Task CanSubscribeUsingQueueArn()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var snsClient = clientFactory.GetSnsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var anotherUniqueName = $"{Guid.NewGuid():N}-integration-tests";
var topicResponse = await snsClient.CreateTopicAsync(anotherUniqueName);
var subscriptionArn = await snsClient.SubscribeQueueAsync(topicResponse.TopicArn, sqsClient, queueResponse.QueueUrl);
var queueArn = (await sqsClient.GetQueueAttributesAsync(queueResponse.QueueUrl, new List <string> {
SQSConstants.ATTRIBUTE_QUEUE_ARN
})).Attributes[SQSConstants.ATTRIBUTE_QUEUE_ARN];
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueArn <SimpleMessage>(queueArn))
.Publications(c =>
c.WithTopicArn <SimpleMessage>(topicResponse.TopicArn)
)
)
.AddJustSayingHandlers(new[] { handler });
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
public UpdateBillingData(
IAwsClientFactory awsClientFactory,
IRepository <AwsProfile> awsProfileRepository,
IBillingManager billingManager,
IClock clock,
IS3PathParser pathParser
) : base(awsProfileRepository, awsClientFactory)
{
_awsProfileRepository = awsProfileRepository;
_billingManager = billingManager;
_clock = clock;
_pathParser = pathParser;
}
public UpdateBillingData(
IAwsClientFactory awsClientFactory,
IRepository<AwsProfile> awsProfileRepository,
IBillingManager billingManager,
IClock clock,
IS3PathParser pathParser
)
: base(awsProfileRepository, awsClientFactory)
{
_awsProfileRepository = awsProfileRepository;
_billingManager = billingManager;
_clock = clock;
_pathParser = pathParser;
}
public UniqueNameRepository(AwsDynamoDbConfig config, IAwsClientFactory clientFactory)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (clientFactory == null)
{
throw new ArgumentNullException("clientFactory");
}
_tablePrefix = config.TablePrefix;
_client = clientFactory.CreateDynamoDBClient();
}
public AwsProfileController(
IRepository <AwsProfile> profileRepository,
IRepository <IPRange> ipRangeRepository,
ICryptoProvider cryptoProvider,
IBackgroundJobClient backgroundJobClient,
IAuthenticatedUserClient userClient,
IAwsClientFactory awsClientFactory)
{
_profileRepository = profileRepository;
_ipRangeRepository = ipRangeRepository;
_cryptoProvider = cryptoProvider;
_backgroundJobClient = backgroundJobClient;
_userClient = userClient;
_awsClientFactory = awsClientFactory;
}
public AwsProfileController(
IRepository<AwsProfile> profileRepository,
IRepository<IPRange> ipRangeRepository,
ICryptoProvider cryptoProvider,
IBackgroundJobClient backgroundJobClient,
IAuthenticatedUserClient userClient,
IAwsClientFactory awsClientFactory)
{
_profileRepository = profileRepository;
_ipRangeRepository = ipRangeRepository;
_cryptoProvider = cryptoProvider;
_backgroundJobClient = backgroundJobClient;
_userClient = userClient;
_awsClientFactory = awsClientFactory;
}
public CreateStack(
IRepository <AwsProfile> profileRepository,
IRepository <IPRange> ipRangeRepository,
IRepository <Instance> instanceRepository,
IRepository <Stack> stackRepository,
IRepository <BaseImage> baseImageRepository,
IRepository <Schedule> scheduleRepository,
IStackPowerKickstarter stackPowerKickstarter,
IAwsClientFactory awsClientFactory) : base(profileRepository, awsClientFactory)
{
_ipRangeRepository = ipRangeRepository;
_instanceRepository = instanceRepository;
_stackRepository = stackRepository;
_baseImageRepository = baseImageRepository;
_scheduleRepository = scheduleRepository;
_stackPowerKickstarter = stackPowerKickstarter;
}
public CreateStack(
IRepository<AwsProfile> profileRepository,
IRepository<IPRange> ipRangeRepository,
IRepository<Instance> instanceRepository,
IRepository<Stack> stackRepository,
IRepository<BaseImage> baseImageRepository,
IRepository<Schedule> scheduleRepository,
IStackPowerKickstarter stackPowerKickstarter,
IAwsClientFactory awsClientFactory)
: base(profileRepository, awsClientFactory)
{
_ipRangeRepository = ipRangeRepository;
_instanceRepository = instanceRepository;
_stackRepository = stackRepository;
_baseImageRepository = baseImageRepository;
_scheduleRepository = scheduleRepository;
_stackPowerKickstarter = stackPowerKickstarter;
}
public async Task CanPublishUsingQueueUrl()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueUrl <SimpleMessage>(queueResponse.QueueUrl))
.Publications(c =>
c.WithQueueUrl <SimpleMessage>(queueResponse.QueueUrl)
)
)
.AddJustSayingHandlers(new[] { handler });
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
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 CreateUserTask(IAwsClientFactory awsClientFactory, ITaskLogger logger)
: base(awsClientFactory, logger)
{
}
internal AwsTaskBase(IAwsClientFactory awsClientFactory)
{
if (awsClientFactory == null) throw new ArgumentNullException("awsClientFactory");
AwsClientFactory = awsClientFactory;
}
public CreateDefaultSecurityGroup(
IRepository<AwsProfile> profileRepository,
IAwsClientFactory clientFactory)
: base(profileRepository, clientFactory)
{
}
public RefreshIpRanges(IRepository<AwsProfile> profileRepository, IRepository<IPRange> ipRangeRepository, IAwsClientFactory awsClientFactory)
: base(profileRepository, awsClientFactory)
{
_ipRangeRepository = ipRangeRepository;
}
public CreateSQSQueueTask(IAwsClientFactory awsClientFactory, ITaskLogger logger)
: base(awsClientFactory, logger)
{
}
public SendSQSMessageTask(IAwsClientFactory awsClientFactory, ITaskLogger logger)
: base(awsClientFactory, logger)
{
}
public DeleteStack(
IRepository<AwsProfile> profileRepository,
IAwsClientFactory awsClientFactory)
: base(profileRepository, awsClientFactory)
{
}
protected SqsTaskBase(IAwsClientFactory awsClientFactory, Logging.ITaskLogger logger)
: base(awsClientFactory, logger)
{
}
public CreateIpRange(IRepository<IPRange> ipRangeRepository, IRepository<AwsProfile> profileRepository, IAwsClientFactory awsClientFactory)
{
_ipRangeRepository = ipRangeRepository;
_profileRepository = profileRepository;
_awsClientFactory = awsClientFactory;
}
public RemoveStaleStacks(IAwsClientFactory awsClientFactory, IRepository<Stack> stackRepository, IRepository<AwsProfile> profileRepository)
: base(profileRepository, awsClientFactory)
{
_stackRepository = stackRepository;
}
public UpdateInstance(IRepository<AwsProfile> profileRepository, IAwsClientFactory awsClientFactory, IRepository<Instance> instanceRepository)
: base(profileRepository, awsClientFactory)
{
_instanceRepository = instanceRepository;
}
public StopInstances(
IRepository<AwsProfile> profileRepository,
IAwsClientFactory awsClientFactory)
: base(profileRepository, awsClientFactory)
{
}
protected CommandBase(IRepository<AwsProfile> profileRepository, IAwsClientFactory clientFactory)
{
ProfileRepository = profileRepository;
_clientFactory = clientFactory;
}
