public async Task <IEnumerable <S3Object> > GetObjectsList() { using var s3Client = awsOptions.CreateServiceClient <IAmazonS3>(); var listObjectsResponse = await s3Client.ListObjectsAsync(new ListObjectsRequest { BucketName = bucketName }); return(listObjectsResponse.S3Objects); }
protected void ResolveHostConfig() { _logger.LogInformation("Resolving Host Configuration"); var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddEnvironmentVariables(prefix: HostSettings.ConfigEnvPrefix); _hostConfig = configBuilder.Build(); _settings = _hostConfig.Get <HostSettings>(); _awsOptions = _hostConfig.GetAWSOptions(); if (_settings.AppSettingsS3Bucket != null && _settings.AppSettingsS3Key != null) { _logger.LogInformation($"Resolved AppSettings S3 source as" + $" [{_settings.AppSettingsS3Bucket}][{_settings.AppSettingsS3Key}]"); var s3 = _awsOptions.CreateServiceClient <IAmazonS3>(); var getResp = s3.GetObjectAsync(_settings.AppSettingsS3Bucket, _settings.AppSettingsS3Key).Result; var localJson = HostSettings.AppSettingsLocalJsonFile; using (getResp) using (var rs = getResp.ResponseStream) using (var fs = File.OpenWrite(localJson)) { rs.CopyTo(fs); } _logger.LogInformation($"Copied AppSettings from S3 source to local file at [{localJson}]"); } }
public async Task Start(AWSOptions awsOptions, string queueName, CancellationToken cancel) { using (var client = awsOptions.CreateServiceClient <IAmazonSQS>()) { var getQueueResult = await client.GetQueueUrlAsync(queueName, cancel); while (cancel.IsCancellationRequested == false) { Console.WriteLine("Waiting for messages...."); ReceiveMessageRequest rxMessage = new ReceiveMessageRequest(); rxMessage.QueueUrl = getQueueResult.QueueUrl; rxMessage.WaitTimeSeconds = 20; rxMessage.MaxNumberOfMessages = 10; ReceiveMessageResponse rxMessageResponse = await client.ReceiveMessageAsync(rxMessage); if (rxMessageResponse.Messages.Any() == false) { return; } Console.WriteLine($"Got {rxMessageResponse.Messages.Count} messages"); var deletions = rxMessageResponse.Messages.Select(m => new DeleteMessageBatchRequestEntry(m.MessageId, m.ReceiptHandle)); Console.WriteLine("Deleting messages...."); await client.DeleteMessageBatchAsync(getQueueResult.QueueUrl, deletions.ToList()); } } }
/// <summary> /// This exists only to populate some sample data to be used by this example project /// </summary> private static async Task PopulateSampleDataForThisProject() { var awsOptions = new AWSOptions { Region = RegionEndpoint.USEast1 }; var root = $"/dotnet-aws-samples/systems-manager-sample/common"; var parameters = new[] { new { Name = "StringValue", Value = "string-value" }, new { Name = "IntegerValue", Value = "10" }, new { Name = "DateTimeValue", Value = "2000-01-01" }, new { Name = "BooleanValue", Value = "True" }, new { Name = "TimeSpanValue", Value = "00:05:00" }, }; using (var client = awsOptions.CreateServiceClient <IAmazonSimpleSystemsManagement>()) { var result = await client.GetParametersByPathAsync(new GetParametersByPathRequest { Path = root, Recursive = true }).ConfigureAwait(false); if (result.Parameters.Count == parameters.Length) { return; } foreach (var parameter in parameters) { var name = $"{root}/settings/{parameter.Name}"; await client.PutParameterAsync(new PutParameterRequest { Name = name, Value = parameter.Value, Type = ParameterType.String, Overwrite = true }).ConfigureAwait(false); } } }
//[Fact] public async Task TestGenerateCredentialReport() { IAmazonIdentityManagementService iamClient = _awsOptions.CreateServiceClient <IAmazonIdentityManagementService>(); IAmazonSimpleEmailService sesClient = _awsOptions.CreateServiceClient <IAmazonSimpleEmailService>(); var logger = new TestLambdaLogger(); var context = new TestLambdaContext { Logger = logger }; var function = new Function(iamClient, sesClient); await function.FunctionHandler(Function.GenerateReportCommand, context); }
public T GetAWSClient <T>(AWSCredentials credentials, string region) where T : IAmazonService { var awsOptions = new AWSOptions { Credentials = credentials, Region = RegionEndpoint.GetBySystemName(region) }; return(awsOptions.CreateServiceClient <T>()); }
public SnsSink(IFormatProvider formatProvider, AWSOptions awsOptions, string logTopicArn, LogEventLevel minimumLevel, string outputTemplate) { _minimumLevel = minimumLevel; _formatProvider = formatProvider; _textFormatter = new Serilog.Formatting.Display.MessageTemplateTextFormatter(outputTemplate, formatProvider); _logTopicArn = logTopicArn; _snsClient = awsOptions.CreateServiceClient <IAmazonSimpleNotificationService>(); }
public T GetAWSClient <T>() where T : IAmazonService { var awsOptions = new AWSOptions(); _awsOptionsAction?.Invoke(awsOptions); return(awsOptions.CreateServiceClient <T>()); }
public SQSQueueMananger( AWSOptions options, string queueName) { _AmazonSQSClient = options.CreateServiceClient <IAmazonSQS>(); _QueueName = queueName; _QueueUrl = GetQueueUrl().Result.QueueUrl; }
private void seedTestData() { bool success = false; using (var client = AWSOptions.CreateServiceClient <IAmazonSimpleSystemsManagement>()) { var tasks = new List <Task>(); foreach (var kv in TestData) { Console.WriteLine($"Adding parameter: ({ParameterPrefix + kv.Key}, {kv.Value})"); tasks.Add(client.PutParameterAsync(new PutParameterRequest { Name = ParameterPrefix + kv.Key, Value = kv.Value, Type = ParameterType.String })); } ; Task.WaitAll(tasks.ToArray()); // due to eventual consistency, wait for 5 sec increments for 3 times to verify // test data is correctly set before executing tests. const int tries = 3; for (int i = 0; i < tries; i++) { int count = 0; GetParametersByPathResponse response; do { response = client.GetParametersByPathAsync(new GetParametersByPathRequest { Path = ParameterPrefix }).Result; count += response.Parameters.Count; } while (!string.IsNullOrEmpty(response.NextToken)); success = (count == TestData.Count); if (success) { Console.WriteLine("Verified that test data is available."); break; } else { Console.WriteLine($"Waiting on test data to be available. Waiting {count + 1}/{tries}"); Thread.Sleep(5 * 1000); } } } if (!success) { throw new Exception("Failed to seed integration test data"); } }
public AwsManagers(AwsConfig config) { var options = new AWSOptions { Credentials = new BasicAWSCredentials(config.AccessKey, config.SecretKey), Region = RegionEndpoint.GetBySystemName(config.Region) }; s3Client = options.CreateServiceClient <IAmazonS3>(); sqsCLient = options.CreateServiceClient <IAmazonSQS>(); textractClient = options.CreateServiceClient <IAmazonTextract>(); dbClient = new AmazonDynamoDBClient(config.AccessKey, config.SecretKey, RegionEndpoint.GetBySystemName(config.Region)); bucketName = config.Bucket; queueUrl = config.Queue; tableName = config.Table; }
public DynamoLogic() { var options = new AWSOptions { Profile = "PortfolioDBUser", Region = RegionEndpoint.USEast1 }; DynamoClient = options.CreateServiceClient <IAmazonDynamoDB>(); }
public static async Task <AssumeRoleResponse> ManualAssume(AWSOptions options) { var stsClient = options.CreateServiceClient <IAmazonSecurityTokenService>(); var assumedRoleResponse = await stsClient.AssumeRoleAsync(new AssumeRoleRequest() { RoleArn = "arn:aws:iam::464534050515:role/SimpleStepFunction-StateMachineRole-1N638DC3RLA16", RoleSessionName = "test" }); return(assumedRoleResponse); }
public static async Task AssumeGivenRole(AWSOptions awsOptions, string roleArn, string roleSessionName, Action <AssumeRoleResponse> execute) { var stsClient = awsOptions.CreateServiceClient <IAmazonSecurityTokenService>(); var assumedRoleResponse = await stsClient.AssumeRoleAsync(new AssumeRoleRequest() { RoleArn = roleArn, RoleSessionName = roleSessionName }); execute(assumedRoleResponse); }
public static IS3ClientFactory Create(string[] regions, AWSOptions options) { var factory = new S3ClientFactory(); foreach (var region in regions) { var regionEndPoint = RegionEndpoint.GetBySystemName(region); options.Region = regionEndPoint; factory._container.Add(region, options.CreateServiceClient <IAmazonS3>()); } return(factory); }
public S3FileService(ILogger <S3FileService> logger, IOptions <S3StorageOptions> awsConfiguration) { _logger = logger; _s3Configuration = awsConfiguration.Value; var awsOptions = new AWSOptions { Region = RegionEndpoint.GetBySystemName(_s3Configuration.Region), Credentials = new BasicAWSCredentials(_s3Configuration.ApiKey, _s3Configuration.Secret) }; _client = awsOptions.CreateServiceClient <IAmazonS3>(); }
/// <summary> /// Creates a new <see cref="S3StorageSession"/> with a specified configuration. /// </summary> /// <param name="storageOptions"><see cref="PiranhaS3StorageOptions"/> used to configure the Piranda S3 storage.</param> /// <param name="awsOptions">The <see cref="AWSOptions"/> used to create the S3 service client.</param> /// <param name="logger">Namespace <see cref="ILogger"/> used for logging.</param> public S3StorageSession(PiranhaS3StorageOptions storageOptions, AWSOptions awsOptions, ILogger logger) { StorageOptions = storageOptions ?? throw new ArgumentNullException(nameof(storageOptions)); if (awsOptions != null) { S3Client = awsOptions.CreateServiceClient <IAmazonS3>(); } else { S3Client = new AmazonS3Client(); } Logger = logger; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddCors(); services.AddControllers(); AWSOptions options = Configuration.GetAWSOptions(); IAmazonSecretsManager client = options.CreateServiceClient <IAmazonSecretsManager>(); DBSettings DBSecret = JsonConvert.DeserializeObject <DBSettings>(GetDBSecret(client)); JWTSettings JWTSecret = JsonConvert.DeserializeObject <JWTSettings>(GetJWTSecret(client)); services.AddSingleton <DBSettings>(DBSecret); services.AddSingleton <JWTSettings>(JWTSecret); // configure jwt authentication var key = Encoding.ASCII.GetBytes(JWTSecret.JWTSecret); services.AddAuthentication(x => { x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(x => { x.RequireHttpsMetadata = false; x.SaveToken = true; x.TokenValidationParameters = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(key), ValidateIssuer = false, ValidateAudience = false }; }); // configure DI for application services services.AddScoped <IJWTService, JWTService>(); services.AddScoped <IDBService, DBService>(); }
private void cleanupTestData() { Console.Write($"Delete all test parameters with prefix '{ParameterPrefix}'... "); using (var client = AWSOptions.CreateServiceClient <IAmazonSimpleSystemsManagement>()) { GetParametersByPathResponse response; do { response = client.GetParametersByPathAsync(new GetParametersByPathRequest { Path = ParameterPrefix }).Result; client.DeleteParametersAsync(new DeleteParametersRequest { Names = response.Parameters.Select(p => p.Name).ToList() }).Wait(); } while (!string.IsNullOrEmpty(response.NextToken)); // no need to wait for eventual consistency here given we are not running tests back-to-back } Console.WriteLine("Done"); }
public string CreateQueue(string QueueName, bool FIFOQueue = false, bool ContentBasedDeDuplication = false) { var attrs = new Dictionary <string, string>(); if (FIFOQueue) { attrs.Add(QueueAttributeName.FifoQueue, "true"); } if (ContentBasedDeDuplication) { attrs.Add(QueueAttributeName.ContentBasedDeduplication, "true"); } Client = Options.CreateServiceClient <IAmazonSQS>(); var sqsResponse = Client.CreateQueueAsync(new CreateQueueRequest { QueueName = QueueName, Attributes = attrs }).Result; return(sqsResponse.QueueUrl); }
internal static async Task <int> SendToQ(AWSOptions options, string sqsQName, int numberOfMessage, bool confirm) { try { using (var sqs = options.CreateServiceClient <IAmazonSQS>()) { var qUrl = await GetQueueUrl(sqs, sqsQName); if (!confirm) { confirm = Confirmation(numberOfMessage, qUrl); } Console.WriteLine($"Sending at {DateTime.UtcNow}:{DateTime.UtcNow.Millisecond}"); while (confirm && _messageCount < numberOfMessage) { var requestMsg = Math.Abs(numberOfMessage - _messageCount); requestMsg = requestMsg > BATCH_SIZE ? BATCH_SIZE : requestMsg; await SendBatchMessage(sqs, qUrl, requestMsg); _messageCount += requestMsg; } } } catch (AmazonSQSException ex) { ConsoleError(ex); } catch (Exception ex) { Console.WriteLine("Caught Exception: " + ex.Message); } return(_messageCount); }
protected virtual IAmazonSQS CreateAmazonSqsClient(AWSOptions options) { return(options.CreateServiceClient <IAmazonSQS>()); }
public S3ImagePersistor(IConfiguration config) { awsOptions = config.GetAWSOptions(); bucketName = config.GetSection("S3")["BucketName"]; client = awsOptions.CreateServiceClient <IAmazonS3>(); }