public S3Service(ILogger logger, AWSOptions options = null) { this.logger = logger; var s3Access = Environment.GetEnvironmentVariable("S3Access"); var s3Secret = Environment.GetEnvironmentVariable("S3Secret"); var s3Region = Environment.GetEnvironmentVariable("S3Region"); try { if (options != null && options.Credentials != null) { s3Client = new(options.Credentials, options.Region); } else if (!string.IsNullOrEmpty(s3Access) && !string.IsNullOrEmpty(s3Secret) && !string.IsNullOrEmpty(s3Region)) { s3Client = new AmazonS3Client(s3Access, s3Secret, GetRegionFromString(s3Region)); } else { var creds = Amazon.Runtime.FallbackCredentialsFactory.GetCredentials(); s3Client = new(creds); } } catch (Exception ex) { logger.LogError(ex, "Error Starting S3 Service"); } }
/// <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); } } }
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 void Test() { var graphQLOptions = new GraphQLClientOptions { EndPoint = new Uri("") }; var awsOptions = new AWSOptions() { AccessKey = "", SecretKey = "", SessionToken = "", }; var client = new GraphQLAWSClient(graphQLOptions, awsOptions, RegionEndpoint.USEast1, ""); var request = new GraphQLRequest { Query = "" }; var response = await client.PostSignedRequestAsync(request, null); response.Should().NotBeNull(); }
static void ExecuteStepFunctionUsingAssumedExistingStateMachineRole() { var options = new AWSOptions() { Profile = "default", Region = RegionEndpoint.EUWest2 }; var assumedRoleResponse = ManualAssume(options).ConfigureAwait(false).GetAwaiter().GetResult(); var assumedCredentials = assumedRoleResponse.Credentials; var amazonStepFunctionsConfig = new AmazonStepFunctionsConfig { RegionEndpoint = RegionEndpoint.EUWest2 }; using (var amazonStepFunctionsClient = new AmazonStepFunctionsClient( assumedCredentials.AccessKeyId, assumedCredentials.SecretAccessKey, amazonStepFunctionsConfig)) { var state = new State { Name = "MyStepFunctions" }; var jsonData1 = JsonConvert.SerializeObject(state); var startExecutionRequest = new StartExecutionRequest { Input = jsonData1, Name = $"SchedulingEngine_{Guid.NewGuid().ToString("N")}", StateMachineArn = "arn:aws:states:eu-west-2:464534050515:stateMachine:StateMachine-z8hrOwmL9CiG" }; var taskStartExecutionResponse = amazonStepFunctionsClient.StartExecutionAsync(startExecutionRequest).ConfigureAwait(false).GetAwaiter().GetResult(); } Console.ReadLine(); }
public static ConfigurationManager BuildConfiguration(string rootPath, string environmentName) { //Log.Information("Building Configuration from Path {rootPath} for environmentName {environmentName}", rootPath, environmentName.ToLower()); Console.WriteLine("Create builder"); var builder = new ConfigurationBuilder().SetBasePath(rootPath) //.AddJsonFile("appsettings.json", true, true) //.AddJsonFile($"appsettings.{environmentName.ToLower()}.json", true, true) //.AddJsonFile($"appsettings.{environmentName.ToLower()}.private.json", true, true) .AddEnvironmentVariables(); if (IsProduction()) { var awsOptions = new AWSOptions { Region = RegionEndpoint.APSoutheast2 }; Console.WriteLine("Add Systems Manager Parameter Store"); builder.AddSystemsManager($"/tbi/{environmentName.ToLower()}", awsOptions); } try { Console.WriteLine("Build config"); var newConfigManager = builder.Build(); Console.WriteLine("Return builder"); return(new ConfigurationManager(newConfigManager)); } catch (Exception e) { Console.WriteLine(e); throw; } }
/// <summary> /// Creates the AWS service client that implements the service client interface. The AWSOptions object /// will be searched for in the IServiceProvider. /// </summary> /// <param name="provider">The dependency injection provider.</param> /// <returns>The AWS service client</returns> internal static object CreateServiceClient(Type serviceInterfaceType, AWSOptions options) { var credentials = CreateCredentials(options); var config = CreateConfig(serviceInterfaceType, options); var client = CreateClient(serviceInterfaceType, credentials, config); return client; }
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 constructor instantiates a new ElasticClient using the AWSOptions and AWS cluster URI /// </summary> /// <param name="awsOptions">AWSOptions containing the credentials and region endpoint</param> /// <param name="esClusterUri">URI of the Elasticsearch cluster in AWS</param> /// <param name="defaultIndex">(Optional) default index to use for writing documents</param> /// <param name="numberOfBulkDocumentsToWriteAtOnce"> /// (Optional) number of documents to write to Elasticsearch /// - set to 0 to write every record immediately, default is 5 /// </param> /// <param name="rollingDate">(Optional) whether or not to use a rolling date pattern when writing to indices, default is false</param> /// <param name="logger">(Optional) ILogger to use</param> public Floe( AWSOptions awsOptions, Uri esClusterUri, string defaultIndex = null, int numberOfBulkDocumentsToWriteAtOnce = _defaultNumberOfBulkDocumentsToWriteAtOnce, bool rollingDate = false, ILogger logger = null) { if (awsOptions == null) { throw new ArgumentNullException(nameof(awsOptions)); } if (!string.IsNullOrEmpty(defaultIndex)) { _defaultIndex = defaultIndex; } _rollingDate = rollingDate; if (numberOfBulkDocumentsToWriteAtOnce > -1) { _numberOfBulkDocumentsToWriteAtOnce = numberOfBulkDocumentsToWriteAtOnce; } AwsHttpConnection httpConnection = new AwsHttpConnection(awsOptions); SingleNodeConnectionPool connectionPool = new SingleNodeConnectionPool(esClusterUri); ConnectionSettings connectionSettings = new ConnectionSettings(connectionPool, httpConnection); _client = new ElasticClient(connectionSettings); _logger = logger; }
public S3StreamingCarrier(ILogger <S3StreamingCarrier> logger, Amazon.Extensions.NETCore.Setup.AWSOptions options, S3BucketsOptions s3BucketsConfiguration = null) { this.logger = logger; this.options = options; this.s3BucketsConfiguration = s3BucketsConfiguration; Priority = 75; }
//private static CognitoAWSCredentials awsCredentials; public AWSLexService(IOptions <AWSOptions> awsOptions) { _awsOptions = awsOptions.Value; InitLexService(); /* * Use CognitoID as the Identifying User ID if you have the User Authenticate with Cognito * If using UnAuth, CognitoID changes and will affect bot response */ //LexUserID += awsCredentials.GetIdentityId().Split(':')[1].Substring(0,7); #region CognitoSTS /* * This if for using initializing Cognito with STS, not needed */ /*cognitoClient = new AmazonCognitoIdentityClient( * awsCreds, // the anonymous credentials * RegionEndpoint.USEast1); //Region * * _awsCredentials = Task.Run(async () => * {try * { return await GetAWSCredentialsFromSTS( * await GetCognitoIDToken( * await GetCognitoID() * )); * } * catch (Exception ex) * { return null; } * }).Result.Credentials;*/ #endregion }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.Configure <CookiePolicyOptions>(options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); services.AddDefaultAWSOptions(this.Configuration.GetAWSOptions()); AWSOptions awsOptions = Configuration.GetAWSOptions(); CredentialProfileStoreChain chain = new CredentialProfileStoreChain(awsOptions.ProfilesLocation); if (chain.TryGetAWSCredentials(awsOptions.Profile, out AWSCredentials result)) { ImmutableCredentials credentials = result.GetCredentials(); Environment.SetEnvironmentVariable("AWS_ACCESS_KEY_ID", credentials.AccessKey); Environment.SetEnvironmentVariable("AWS_SECRET_ACCESS_KEY", credentials.SecretKey); } else { throw new Exception("Could not get Amazon credentials"); } Environment.SetEnvironmentVariable("AWS_REGION", awsOptions.Region.SystemName); services.AddAWSService <IAmazonS3>(); }
private SendMessageResponse SendTestMessage() { var input = new SendParameters { QueueUrl = queueURL, Message = $@"Frends.Community.AWS.SQS.Tests.SendMessage() test. Datetime: {DateTime.Now.ToString("o")} " }; var options = new SendOptions { DelaySeconds = 0, MessageDeduplicationId = queueURL.Contains(".fifo") ? Guid.NewGuid().ToString() : "", // FIFO, ContentBasedDeduplication disabled MessageGroupId = queueURL.Contains(".fifo") ? "1" : "" // FIFO }; var awsOptions = new AWSOptions { AWSCredentials = SQS.GetBasicAWSCredentials(credParams), UseDefaultCredentials = false, Region = region }; return(SQS.SendMessage(input, options, awsOptions, new System.Threading.CancellationToken()).Result); }
/// <summary> /// Contructor initializing test fixture. /// </summary> public BucketIntegrationFixture() { // Setup Configuration var configBuilder = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: false); var configuration = configBuilder.Build(); AWSOptions options = configuration.GetAWSOptions(); // S3 Configuration BucketName = Environment.GetEnvironmentVariable("BUCKET_NAME"); BucketWebsite = $"http://{BucketName}.s3-website.{options.Region.SystemName}.amazonaws.com/"; var storageConfig = new PiranhaS3StorageOptions { BucketName = BucketName, PublicUrlRoot = BucketWebsite }; // Service Provider IServiceCollection services = new ServiceCollection(); services.AddPiranhaS3StorageOptions(storageConfig); services.AddDefaultAWSOptions(configuration.GetAWSOptions()); services.AddPiranhaS3Storage(); services.AddAWSService <IAmazonS3>(); var serviceProvider = services.BuildServiceProvider(); // Get the services S3Storage = serviceProvider.GetService <IStorage>(); S3Client = serviceProvider.GetService <IAmazonS3>(); }
public void DeleteMessage() { var ret = SendTestMessage(); Assert.IsTrue(ret.HttpStatusCode == System.Net.HttpStatusCode.OK); var rec = ReceiveTestMessage(); Assert.IsTrue(rec.HttpStatusCode == System.Net.HttpStatusCode.OK); Assert.IsTrue(rec.Messages.Count > 0); var input = new DeleteParameters { QueueUrl = queueURL, ReceiptHandle = rec.Messages[0].ReceiptHandle }; var awsOptions = new AWSOptions { AWSCredentials = SQS.GetBasicAWSCredentials(credParams), UseDefaultCredentials = false, Region = region }; var delres = SQS.DeleteMessage(input, awsOptions, new System.Threading.CancellationToken()).Result; Assert.IsTrue(delres.HttpStatusCode == System.Net.HttpStatusCode.OK); }
private static ServiceDescriptor GetServiceFactoryDescriptor <TService>(AWSOptions options, ServiceLifetime lifetime) where TService : IAmazonService { var descriptor = new ServiceDescriptor(typeof(TService), provider => { LocalStackOptions localStackOptions = provider.GetRequiredService <IOptions <LocalStackOptions> >().Value; AmazonServiceClient serviceInstance; if (localStackOptions.UseLocalStack) { var session = provider.GetRequiredService <ISession>(); serviceInstance = session.CreateClientByInterface <TService>(); } else { var clientFactory = provider.GetRequiredService <IAwsClientFactoryWrapper>(); serviceInstance = clientFactory.CreateServiceClient <TService>(provider, options); } return(serviceInstance); }, lifetime); return(descriptor); }
/// <summary> /// Contructor initializing test fixture. /// </summary> public TestConfigurationFixture() { // Fake AWS Options FakeAwsOptions = new AWSOptions { Region = RegionEndpoint.USWest2, Credentials = new BasicAWSCredentials("accessId", "secretKey") }; // Main Configuration var configBuilder = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: false); MainConfiguration = configBuilder.Build(); // Root Configuration configBuilder = new ConfigurationBuilder() .AddJsonFile("appsettings.root.json", optional: false); RootConfiguration = configBuilder.Build(); // Other Configuration configBuilder = new ConfigurationBuilder() .AddJsonFile("appsettings.other.json", optional: false); OtherConfiguration = configBuilder.Build(); }
public IntegTestFixture() { AWSOptions = new AWSOptions(); AWSOptions.Region = Amazon.RegionEndpoint.USWest2; seedTestData(); }
private static CloudConfig CreateCloudConfig() { AWSCredentials credentials; bool isInAws = false; var chain = new CredentialProfileStoreChain(); AWSCredentials awsCredentials; if (chain.TryGetAWSCredentials("chessdb-prod", out awsCredentials)) { credentials = awsCredentials; } else { credentials = FallbackCredentialsFactory.GetCredentials(); isInAws = true; } var options = new AWSOptions() { Credentials = credentials, Region = RegionEndpoint.USEast2, }; string stage = Environment.GetEnvironmentVariable("JANUS_STAGE") ?? "prod"; return(new CloudConfig() { Stage = stage, Options = options, IsInCloud = isInAws, }); }
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 SQSQueueMananger( AWSOptions options, string queueName) { _AmazonSQSClient = options.CreateServiceClient <IAmazonSQS>(); _QueueName = queueName; _QueueUrl = GetQueueUrl().Result.QueueUrl; }
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 FunctionTest() { var builder = new ConfigurationBuilder() .AddJsonFile("appsettings.json"); _config = builder.Build(); _awsOptions = _config.GetAWSOptions(); }
public AdminController(IOptions <AWSOptions> awsOptions) { _awsOptions = awsOptions.Value; Amazon.RegionEndpoint AppRegion = Amazon.RegionEndpoint.GetBySystemName(_awsOptions.Region); _cloudAuthService = new CloudAuthService(_awsOptions.CognitoPoolId, AppRegion); _dbDataService = new DBDataService(_cloudAuthService.GetAWSCredentials(), AppRegion); }
public T GetAWSClient <T>() where T : IAmazonService { var awsOptions = new AWSOptions(); _awsOptionsAction?.Invoke(awsOptions); return(awsOptions.CreateServiceClient <T>()); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { services.AddHostedService <Worker>(); IConfiguration config = hostContext.Configuration; AWSOptions options = config.GetAWSOptions(); services.AddAWSService <IAmazonSQS>(options); });
public static IServiceCollection AddDynamoDbServices( this IServiceCollection services, AWSOptions awsConfig) { services.AddDefaultAWSOptions(awsConfig); services.AddAWSService <IAmazonDynamoDB>(); return(services); }
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"); } }
/// <summary> /// Adds the Amazon service client to the dependency injection framework. The Amazon service client is not /// created until it is requested. If the ServiceLifetime property is set to Singleton, the default, then the same /// instance will be reused for the lifetime of the process and the object should not be disposed. /// </summary> /// <typeparam name="TService">The AWS service interface, like IAmazonS3.</typeparam> /// <param name="collection"></param> /// <param name="options">The AWS options used to create the service client overriding the default AWS options added using AddDefaultAWSOptions.</param> /// <param name="lifetime">The lifetime of the service client created. The default is Singleton.</param> /// <returns>Returns back the IServiceCollection to continue the fluent system of IServiceCollection.</returns> public static IServiceCollection AddAwsService <TService>(this IServiceCollection collection, AWSOptions options, ServiceLifetime lifetime = ServiceLifetime.Singleton) where TService : IAmazonService { ServiceDescriptor descriptor = GetServiceFactoryDescriptor <TService>(options, lifetime); collection.Add(descriptor); return(collection); }
//public CloudAuthService(string appPoolID, string awsRegion): // this(appPoolID, Amazon.RegionEndpoint.GetBySystemName(awsRegion)){ } public CloudAuthService(IOptions <AWSOptions> awsOptions) { _awsOptions = awsOptions.Value; _awsRegion = Amazon.RegionEndpoint.GetBySystemName( _awsOptions.Region); if (!InitService()) { throw new AmazonCognitoIdentityException("Couldn't connect to Cognito Service", new Exception("InitService - CognitoClient")); } }
public IAmazonSQS CreateClient(string profileName, string regionName) { var options = new AWSOptions { Profile = profileName, Region = RegionEndpoint.GetBySystemName(regionName), }; return(CreateAmazonSqsClient(options)); }
/// <summary> /// Constructs an AWSOptions class with the options specifed in the "AWS" section in the IConfiguration object. /// </summary> /// <param name="config"></param> /// <param name="configSection">The config section to extract AWS options from.</param> /// <returns>The AWSOptions containing the values set in configuration system.</returns> public static AWSOptions GetAWSOptions(this IConfiguration config, string configSection) { var options = new AWSOptions(); IConfiguration section; if (string.IsNullOrEmpty(configSection)) section = config; else section = config.GetSection(configSection); if (section == null) return options; var clientConfigTypeInfo = typeof(ClientConfig).GetTypeInfo(); foreach(var element in section.GetChildren()) { try { var property = clientConfigTypeInfo.GetDeclaredProperty(element.Key); if (property == null || property.SetMethod == null) continue; if (property.PropertyType == typeof(string) || property.PropertyType.GetTypeInfo().IsPrimitive) { var value = Convert.ChangeType(element.Value, property.PropertyType); property.SetMethod.Invoke(options.DefaultClientConfig, new object[] { value }); } else if (property.PropertyType == typeof(TimeSpan) || property.PropertyType == typeof(Nullable<TimeSpan>)) { var milliSeconds = Convert.ToInt64(element.Value); var timespan = TimeSpan.FromMilliseconds(milliSeconds); property.SetMethod.Invoke(options.DefaultClientConfig, new object[] { timespan }); } } catch(Exception e) { throw new ConfigurationException($"Error reading value for property {element.Key}.", e) { PropertyName = element.Key, PropertyValue = element.Value }; } } if (!string.IsNullOrEmpty(section["Profile"])) { options.Profile = section["Profile"]; } // Check legacy name if the new name isn't set else if (!string.IsNullOrEmpty(section["AWSProfileName"])) { options.Profile = section["AWSProfileName"]; } if (!string.IsNullOrEmpty(section["ProfilesLocation"])) { options.ProfilesLocation = section["ProfilesLocation"]; } // Check legacy name if the new name isn't set else if (!string.IsNullOrEmpty(section["AWSProfilesLocation"])) { options.ProfilesLocation = section["AWSProfilesLocation"]; } if (!string.IsNullOrEmpty(section["Region"])) { options.Region = RegionEndpoint.GetBySystemName(section["Region"]); } // Check legacy name if the new name isn't set else if (!string.IsNullOrEmpty(section["AWSRegion"])) { options.Region = RegionEndpoint.GetBySystemName(section["AWSRegion"]); } return options; }
private Options(GeneralOptions generalOpts, AWSOptions awsOpts) { this.generalOptions = generalOpts; this.awsOptions = awsOpts; }
// Factory method to read from config public static Options loadFromConfig(bool withDefaults = false) { lock (lockObject) { logger.Info("Loading configuration"); GeneralOptions generalOpts = null; AWSOptions awsOpts = null; try { generalOpts = GeneralOptions.load(); awsOpts = AWSOptions.load(); if (!String.IsNullOrEmpty(generalOpts.DomainName) && generalOpts.DomainName[generalOpts.DomainName.Length - 1] != '.') { logger.Debug("Forcefully terminating domain name with dot."); generalOpts.DomainName = generalOpts.DomainName + "."; } } catch (FileNotFoundException) { if (generalOpts == null) { generalOpts = new GeneralOptions(); generalOpts.ExternalIPNeeded = true; generalOpts.HasInitialDelay = true; generalOpts.IPProviders = new List<IPProvider>(); generalOpts.RunOnStart = false; generalOpts.TimerPeriodSec = 300; } if (awsOpts == null) { awsOpts = new AWSOptions(); awsOpts.AWSAccessKey = String.Empty; awsOpts.AWSSecretKey = String.Empty; awsOpts.HostedZoneId = String.Empty; } } return new Options(generalOpts, awsOpts); } }
/// <summary> /// Creates the AWSCredentials using either the profile indicated from the AWSOptions object /// of the SDK fallback credentials search. /// </summary> /// <param name="options"></param> /// <returns></returns> private static AWSCredentials CreateCredentials(AWSOptions options) { if (options != null && !string.IsNullOrEmpty(options.Profile) && StoredProfileAWSCredentials.IsProfileKnown(options.Profile, options.ProfilesLocation)) { return new StoredProfileAWSCredentials(options.Profile, options.ProfilesLocation); } return FallbackCredentialsFactory.GetCredentials(); }
/// <summary> /// Creates the ClientConfig object for the service client. /// </summary> /// <param name="options"></param> /// <returns></returns> private static ClientConfig CreateConfig(Type serviceInterfaceType, AWSOptions options) { var configTypeName = serviceInterfaceType.Namespace + "." + serviceInterfaceType.Name.Substring(1) + "Config"; var configType = serviceInterfaceType.GetTypeInfo().Assembly.GetType(configTypeName); var constructor = configType.GetConstructor(EMPTY_TYPES); ClientConfig config = constructor.Invoke(EMPTY_PARAMETERS) as ClientConfig; var defaultConfig = options.DefaultClientConfig; if (options.IsDefaultClientConfigSet) { var emptyArray = new object[0]; var singleArray = new object[1]; var clientConfigTypeInfo = typeof(ClientConfig).GetTypeInfo(); foreach (var property in clientConfigTypeInfo.DeclaredProperties) { if (property.GetMethod != null && property.SetMethod != null) { // Skip RegionEndpoint because it is set below and calling the get method on the // property triggers the default region fallback mechanism. if (string.Equals(property.Name, "RegionEndpoint", StringComparison.Ordinal)) continue; singleArray[0] = property.GetMethod.Invoke(defaultConfig, emptyArray); if (singleArray[0] != null) { property.SetMethod.Invoke(config, singleArray); } } } } // Setting RegionEndpoint only if ServiceURL was not set, because ServiceURL value will be lost otherwise if (options.Region != null && string.IsNullOrEmpty(defaultConfig.ServiceURL)) { config.RegionEndpoint = options.Region; } return config; }
/// <summary> /// Constructs an instance of the ClientFactory /// </summary> /// <param name="type">The type object for the Amazon service client interface, for example IAmazonS3.</param> internal ClientFactory(Type type, AWSOptions awsOptions) { _serviceInterfaceType = type; _awsOptions = awsOptions; }