private CliManager(string profileName, AwsRegion region)
{
ServiceCollection services = new ServiceCollection();
IS3ClientBuilder builder = services.AddSimpleS3();
builder.CoreBuilder.UseProfileManager()
.UseDataProtection();
//Override the region if it is set via commandline
builder.Services.PostConfigure <S3Config>(config =>
{
if (region != AwsRegion.Unknown)
{
config.Region = region;
}
});
services.AddSingleton <BucketManager>();
services.AddSingleton <ObjectManager>();
ServiceProvider provider = services.BuildServiceProvider();
ProfileManager = provider.GetRequiredService <IProfileManager>();
IProfile profile = ProfileManager.GetProfile(profileName) ?? ConsoleSetup.SetupProfile(ProfileManager, profileName);
S3Client = provider.GetRequiredService <IClient>();
BucketManager = provider.GetRequiredService <BucketManager>();
ObjectManager = provider.GetRequiredService <ObjectManager>();
}
public static S3Client Create(string profileName)
{
ServiceCollection services = new ServiceCollection();
//Here we setup our S3Client
IS3ClientBuilder builder = services.AddSimpleS3();
//Here we enable in-memory encryption using Microsoft Data Protection
builder.CoreBuilder
.UseProfileManager()
.BindConfigToProfile(profileName)
.UseDataProtection();
//Finally we build the service provider and return the S3Client
IServiceProvider serviceProvider = services.BuildServiceProvider();
IProfileManager manager = serviceProvider.GetRequiredService <IProfileManager>();
IProfile? profile = manager.GetProfile(profileName);
//If profile is null, then we do not yet have a profile stored on disk. We use ConsoleSetup as an easy and secure way of asking for credentials
if (profile == null)
{
ConsoleSetup.SetupProfile(manager, profileName);
}
return(serviceProvider.GetRequiredService <S3Client>());
}
public static IHttpClientBuilder UseHttpClientFactory(this IS3ClientBuilder builder)
{
IHttpClientBuilder httpBuilder = builder.Services.AddHttpClient <INetworkDriver, HttpClientNetworkDriver>((provider, client) =>
client.DefaultRequestHeaders.UserAgent.TryParseAdd(Constants.DefaultUserAgent));
return(httpBuilder);
}
public S3Client(S3Config config, HttpMessageHandler messageHandler)
{
ServiceCollection services = new ServiceCollection();
services.AddSingleton(x => Options.Create(config));
IS3ClientBuilder builder = services.AddSimpleS3Core();
IHttpClientBuilder httpBuilder = builder.UseHttpClientFactory();
if (messageHandler != null)
{
httpBuilder.ConfigurePrimaryHttpMessageHandler(x => messageHandler);
}
httpBuilder.SetHandlerLifetime(TimeSpan.FromMinutes(5));
Random random = new Random();
// Policy is:
// Retries: 3
// Timeout: 2^attempt seconds (2, 4, 8 seconds) + -100 to 100 ms jitter
httpBuilder.AddTransientHttpErrorPolicy(p => p.WaitAndRetryAsync(3,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
+ TimeSpan.FromMilliseconds(random.Next(-100, 100))));
_provider = services.BuildServiceProvider();
_objectClient = _provider.GetRequiredService <IS3ObjectClient>();
_bucketClient = _provider.GetRequiredService <IS3BucketClient>();
_serviceClient = _provider.GetRequiredService <IS3ServiceClient>();
}
private static async Task Main(string[] args)
{
IConfigurationRoot configRoot = new ConfigurationBuilder()
.AddJsonFile("Config.json", false)
.Build();
ServiceCollection services = new ServiceCollection();
services.Configure <S3Config>(configRoot);
IS3ClientBuilder clientBuilder = services.AddSimpleS3((s3Config, provider) => configRoot.Bind(s3Config));
string profileName = configRoot["ProfileName"];
clientBuilder.CoreBuilder.UseProfileManager()
.BindConfigToProfile(profileName)
.UseDataProtection();
IConfigurationSection proxySection = configRoot.GetSection("Proxy");
if (proxySection != null && proxySection["UseProxy"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
clientBuilder.HttpBuilder.WithProxy(proxySection["ProxyAddress"]);
}
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
IProfileManager manager = serviceProvider.GetRequiredService <IProfileManager>();
IProfile? profile = manager.GetProfile(profileName);
//If profile is null, then we do not yet have a profile stored on disk. We use ConsoleSetup as an easy and secure way of asking for credentials
if (profile == null)
{
ConsoleSetup.SetupProfile(manager, profileName);
}
S3Client client = serviceProvider.GetRequiredService <S3Client>();
await foreach (S3Bucket bucket in client.ListAllBucketsAsync())
{
if (!bucket.Name.StartsWith("testbucket-", StringComparison.OrdinalIgnoreCase))
{
continue;
}
DeleteAllObjectsStatus objDelResp = await client.DeleteAllObjectsAsync(bucket.Name).ConfigureAwait(false);
if (objDelResp == DeleteAllObjectsStatus.Ok)
{
await client.DeleteBucketAsync(bucket.Name).ConfigureAwait(false);
}
}
//Empty the main test bucket
await client.DeleteAllObjectsAsync(configRoot["BucketName"]).ConfigureAwait(false);
}
}
protected LiveTestBase(ITestOutputHelper outputHelper)
{
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("TestConfig.json", false);
ServiceCollection collection = new ServiceCollection();
//Set the configuration from the config file
configBuilder.AddUserSecrets(GetType().Assembly);
_configRoot = configBuilder.Build();
IS3ClientBuilder builder = collection.AddSimpleS3Core(ConfigureS3);
IHttpClientBuilder httpClientBuilder = builder.UseHttpClientFactory();
IConfigurationSection proxySection = _configRoot.GetSection("Proxy");
if (proxySection != null && proxySection["UseProxy"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
httpClientBuilder.ConfigurePrimaryHttpMessageHandler(x => new HttpClientHandler {
Proxy = new WebProxy(proxySection["ProxyAddress"])
});
}
collection.AddLogging(x =>
{
x.AddConfiguration(_configRoot.GetSection("Logging"));
x.AddXUnit(outputHelper);
});
//A small hack to remove all validators, as we test them separately
collection.RemoveAll(typeof(IValidator <>));
collection.RemoveAll <IValidator>();
Services = collection.BuildServiceProvider();
//var _bucketClient = Services.GetRequiredService<IS3BucketClient>();
//var serviceClient = Services.GetRequiredService<IS3ServiceClient>();
//var enumerator = serviceClient.GetAllAsync().ToListAsync().Result;
//foreach (S3Bucket bucket in enumerator)
//{
// if (bucket.Name.Contains("test", StringComparison.OrdinalIgnoreCase))
// _bucketClient.DeleteBucketRecursiveAsync(bucket.Name).Wait();
//}
BucketName = _configRoot["BucketName"] ?? "main-test-bucket-2019";
Config = Services.GetRequiredService <IOptions <S3Config> >().Value;
ObjectClient = Services.GetRequiredService <IS3ObjectClient>();
BucketClient = Services.GetRequiredService <IS3BucketClient>();
ServiceClient = Services.GetRequiredService <IS3ServiceClient>();
Transfer = Services.GetRequiredService <Transfer>();
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="logger"></param>
/// <param name="configuration"></param>
/// <param name="s3ClientBuilder"></param>
public DefaultS3ClientPool(
ILogger <DefaultS3ClientPool> logger,
S3ClientConfiguration configuration,
IS3ClientBuilder s3ClientBuilder)
{
_logger = logger;
_configuration = configuration;
_s3ClientBuilder = s3ClientBuilder;
_clients = new ConcurrentDictionary <int, IAmazonS3>();
}
public static S3Client Create()
{
//In this example we are using Dependency Injection (DI) using Microsoft's DI framework
ServiceCollection services = new ServiceCollection();
//We use Microsoft.Extensions.Configuration framework here to load our config file
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("Config.json", false);
IConfigurationRoot root = configBuilder.Build();
//We use Microsoft.Extensions.Logging here to add support for logging
services.AddLogging(x =>
{
x.AddConsole();
x.AddConfiguration(root.GetSection("Logging"));
});
//Here we setup our S3Client
IS3ClientBuilder clientBuilder = services.AddSimpleS3Core(s3Config =>
{
root.Bind(s3Config);
s3Config.Credentials = new StringAccessKey("Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG");
s3Config.Region = AwsRegion.USEast1;
s3Config.Endpoint = new Uri("https://play.min.io:9000/");
});
//We enable HTTP Factory support here.
IHttpClientBuilder httpBuilder = clientBuilder.UseHttpClientFactory();
//Every 5 minutes we create a new connection, thereby reacting to DNS changes
httpBuilder.SetHandlerLifetime(TimeSpan.FromMinutes(5));
//Uncomment this line if you want to use a proxy
//httpBuilder.ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler { Proxy = new WebProxy("http://<YourProxy>:<ProxyPort>") });
//Here we enable retrying. We retry 3 times with a delay of 600 ms between attempts. For more examples, see https://github.com/App-vNext/Polly
httpBuilder.AddTransientHttpErrorPolicy(p => p.WaitAndRetryAsync(3, _ => TimeSpan.FromMilliseconds(600)));
//Finally we build the service provider and return the S3Client
IServiceProvider serviceProvider = services.BuildServiceProvider();
return(serviceProvider.GetRequiredService <S3Client>());
}
public static S3Client Create(IWebProxy proxy = null)
{
ServiceCollection services = new ServiceCollection();
//Here we custom build the client
IS3ClientBuilder builder = services.AddSimpleS3(s3Config =>
{
s3Config.Credentials = new StringAccessKey("Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG");
s3Config.Region = AwsRegion.UsEast1;
s3Config.Endpoint = new Uri("https://play.min.io:9000/");
});
builder.HttpBuilder.WithProxy(proxy);
IServiceProvider serviceProvider = services.BuildServiceProvider();
return(serviceProvider.GetRequiredService <S3Client>());
}
public static S3Client Create(string keyId, string accessKey, string proxyUri)
{
ServiceCollection services = new ServiceCollection();
IS3ClientBuilder clientBuilder = services.AddSimpleS3Core(s3Config =>
{
s3Config.Credentials = new StringAccessKey(keyId, accessKey);
s3Config.Region = AwsRegion.EUWest1;
});
IHttpClientBuilder httpBuilder = clientBuilder.UseHttpClientFactory();
httpBuilder.ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler {
Proxy = new WebProxy(proxyUri)
});
IServiceProvider serviceProvider = services.BuildServiceProvider();
return(serviceProvider.GetRequiredService <S3Client>());
}
private static async Task Main(string[] args)
{
IConfigurationRoot root = new ConfigurationBuilder()
.AddJsonFile("Config.json", false)
.Build();
ServiceCollection services = new ServiceCollection();
services.Configure <S3Config>(root);
IS3ClientBuilder clientBuilder = services.AddSimpleS3();
clientBuilder.CoreBuilder.UseProfileManager()
.BindConfigToDefaultProfile()
.UseDataProtection();
IConfigurationSection proxySection = root.GetSection("Proxy");
if (proxySection != null && proxySection["UseProxy"].Equals("true", StringComparison.OrdinalIgnoreCase))
{
clientBuilder.HttpBuilder.WithProxy(proxySection["ProxyAddress"]);
}
using (ServiceProvider provider = services.BuildServiceProvider())
{
IProfileManager manager = provider.GetRequiredService <IProfileManager>();
IProfile? profile = manager.GetDefaultProfile();
//If profile is null, then we do not yet have a profile stored on disk. We use ConsoleSetup as an easy and secure way of asking for credentials
if (profile == null)
{
Console.WriteLine("No profile found. Starting setup.");
ConsoleSetup.SetupDefaultProfile(manager);
}
IBucketClient bucketClient = provider.GetRequiredService <IBucketClient>();
string bucketName = root["BucketName"];
Console.WriteLine($"Setting up bucket '{bucketName}'");
HeadBucketResponse headResp = await bucketClient.HeadBucketAsync(bucketName).ConfigureAwait(false);
if (headResp.IsSuccess)
{
Console.WriteLine($"'{bucketName}' already exist.");
}
else
{
Console.WriteLine($"'{bucketName}' does not exist - creating.");
CreateBucketResponse createResp = await bucketClient.CreateBucketAsync(bucketName, x => x.EnableObjectLocking = true).ConfigureAwait(false);
if (createResp.IsSuccess)
{
Console.WriteLine($"Successfully created '{bucketName}'.");
}
else
{
Console.Error.WriteLine($"Failed to create '{bucketName}'. Exiting.");
return;
}
}
Console.WriteLine("Adding lock configuration");
PutBucketLockConfigurationResponse putLockResp = await bucketClient.PutBucketLockConfigurationAsync(bucketName, true).ConfigureAwait(false);
if (putLockResp.IsSuccess)
{
Console.WriteLine("Successfully applied lock configuration.");
}
else
{
Console.Error.WriteLine("Failed to apply lock configuration.");
}
List <S3Rule> rules = new List <S3Rule>
{
new S3Rule("ExpireAll", true)
{
AbortIncompleteMultipartUploadDays = 1,
NonCurrentVersionExpirationDays = 1,
Expiration = new S3Expiration(1),
Filter = new S3Filter {
Prefix = ""
}
}
};
Console.WriteLine("Adding lifecycle configuration");
PutBucketLifecycleConfigurationResponse putLifecycleResp = await bucketClient.PutBucketLifecycleConfigurationAsync(bucketName, rules).ConfigureAwait(false);
if (putLifecycleResp.IsSuccess)
{
Console.WriteLine("Successfully applied lifecycle configuration.");
}
else
{
Console.Error.WriteLine("Failed to apply lifecycle configuration.");
}
}
}
public static IS3ClientBuilder UseHttpClient(this IS3ClientBuilder builder)
{
builder.Services.TryAddSingleton <System.Net.Http.HttpClient>();
builder.Services.TryAddSingleton <INetworkDriver, HttpClientNetworkDriver>();
return(builder);
}
