private static RegionEndpoint toRegionEndpoint(S3Region region)
{
return(RegionEndpoint.GetBySystemName(region.Value));
//if (S3Region.APN1 == region)
// return RegionEndpoint.APNortheast1; // Tokyo
//else if (S3Region.APN2 == region)
// return RegionEndpoint.APNortheast2; // Seoul
//else if (S3Region.APS1 == region)
// return RegionEndpoint.APSoutheast1; // Singapore
//else if (S3Region.APS2 == region)
// return RegionEndpoint.APSoutheast2; // Sydney
//else if (S3Region.EU == region)
// return RegionEndpoint.EUWest1; // Ireland
//else if (S3Region.EUC1 == region)
// return RegionEndpoint.EUCentral1; // Frankfurt
//else if (S3Region.SAE1 == region)
// return RegionEndpoint.SAEast1; // Sao Paulo
//else if (S3Region.US == region)
// return RegionEndpoint.USEast1; // Virginia
//else if (S3Region.USW1 == region)
// return RegionEndpoint.USWest1; // N.California
//else if (S3Region.USW2 == region)
// return RegionEndpoint.USWest2; // Oregon
//else if (S3Region.CN1 == region)
// return RegionEndpoint.CNNorth1; // Beijing
//else if (S3Region.APS3 == region)
// return RegionEndpoint.APSouth1; // Mumbai
//throw new ArgumentException("region");
}
private async Task CheckBucketExists()
{
if (!_bucketExist)
{
_bucketExist = await _s3Client.DoesS3BucketExistAsync(_bucketName);
while (_bucketExist == false)
{
S3Region s3region = S3Region.FindValue(_config.AmazonRegion);
var putBucketRequest = new PutBucketRequest {
BucketName = _bucketName,
BucketRegion = s3region,
};
try
{
EnsureValidResponse(await _s3Client.PutBucketAsync(putBucketRequest), HttpStatusCode.OK);
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode == "BucketAlreadyOwnedByYou")
{
break;
}
throw;
}
_bucketExist = await _s3Client.DoesS3BucketExistAsync(_bucketName);
}
}
}
public static RegionEndpoint GetBucketLocation(IAmazonS3 s3Client, string bucketName)
{
GetBucketLocationRequest getBucketLocationRequest = new GetBucketLocationRequest()
{
BucketName = bucketName
};
GetBucketLocationResponse getBucketLocationResponse = s3Client.GetBucketLocation(getBucketLocationRequest);
S3Region s3Region = getBucketLocationResponse.Location;
return(toRegionEndpoint(s3Region));
}
public static async Task DeleteAllBucketsWithPrefix(IAmazonS3 s3Client, string namePrefix)
{
var listBucketsResponse = await s3Client.ListBucketsAsync(new ListBucketsRequest()).ConfigureAwait(false);
await Task.WhenAll(listBucketsResponse.Buckets.Where(x => x.BucketName.StartsWith(namePrefix, StringComparison.OrdinalIgnoreCase))
.Select(x => x.BucketName).Select(async bucketName =>
{
try
{
if (!await s3Client.DoesS3BucketExistAsync(bucketName))
{
return;
}
var response = await s3Client.GetBucketLocationAsync(bucketName);
S3Region region;
switch (response.Location)
{
case "":
{
region = new S3Region("us-east-1");
break;
}
case "EU":
{
region = S3Region.EUW1;
break;
}
default:
region = response.Location;
break;
}
await s3Client.DeleteBucketAsync(new DeleteBucketRequest
{
BucketName = bucketName,
BucketRegion = region
});
}
catch (AmazonS3Exception)
{
Console.WriteLine($"Unable to delete bucket '{bucketName}'");
}
}));
}
internal static RegionEndpoint RegionToEndpoint(S3Region region)
{
RegionEndpoint regionEp;
if (String.IsNullOrEmpty(region.Value))//By AWS doc, if empty, it is USEast1.
{
regionEp = RegionEndpoint.USEast1;
}
else
{
if (!RegionAliasTable.TryGetValue(region.Value, out regionEp))
{
regionEp = RegionEndpoint.GetBySystemName(region.Value);
}
}
return(regionEp);
}
public static async Task Delete(IAmazonS3 s3, string endpointName, string bucketName)
{
await Console.Out.WriteLineAsync($"Delete bucket with name '{bucketName}' for endpoint '{endpointName}'.");
if (await s3.DoesS3BucketExistAsync(bucketName))
{
var response = await s3.GetBucketLocationAsync(bucketName);
S3Region region;
switch (response.Location)
{
case "":
{
region = new S3Region("us-east-1");
break;
}
case "EU":
{
region = S3Region.EUW1;
break;
}
default:
region = response.Location;
break;
}
var deleteRequest = new DeleteBucketRequest
{
BucketName = bucketName,
BucketRegion = region,
};
await s3.DeleteBucketAsync(deleteRequest).ConfigureAwait(false);
await Console.Out.WriteLineAsync($"Delete bucket with name '{bucketName}' for endpoint '{endpointName}'.");
}
else
{
await Console.Out.WriteLineAsync($"Bucket with name '{bucketName}' does not exist.");
}
}
// Open connection.
// Returns true on success, false on error.
public override bool Open()
{
try
{
this.Exception = null;
if (this.AccessKey != null)
{
this.Credentials = new BasicAWSCredentials(this.AccessKey, this.SecretKey);
}
this.Region = S3Region.US;
AmazonS3Config config = new AmazonS3Config {
ServiceURL = this.S3Endpoint
};
String regionName = this.S3Endpoint;
config.RegionEndpoint = this.RegionEndpoint = RegionEndpoint.GetBySystemName(this.S3Endpoint);
if (this.AccessKey != null)
{
StorageClient = new AmazonS3Client(this.Credentials, config); // Explicit authentication from supplied access key & secret key
}
else
{
StorageClient = new AmazonS3Client(config); // Implicit authentication from EC2 role
}
return(true);
}
catch (Exception ex)
{
this.Exception = ex;
if (!this.HandleErrors)
{
throw ex;
}
return(false);
}
}
public AmazonPictureService(IRepository <Picture> pictureRepository,
ISettingService settingService,
IWebHelper webHelper,
ILogger logger,
IEventPublisher eventPublisher,
MediaSettings mediaSettings,
GrandConfig config)
: base(pictureRepository,
settingService,
webHelper,
logger,
eventPublisher,
mediaSettings)
{
this._config = config;
//Arguments guard
if (string.IsNullOrEmpty(_config.AmazonAwsAccessKeyId))
{
throw new ArgumentNullException("AmazonAwsAccessKeyId");
}
if (string.IsNullOrEmpty(_config.AmazonAwsSecretAccessKey))
{
throw new ArgumentNullException("AmazonAwsSecretAccessKey");
}
if (string.IsNullOrEmpty(_config.AmazonBucketName))
{
throw new ArgumentNullException("AmazonBucketName");
}
//Region guard
RegionEndpoint regionEndpoint = RegionEndpoint.GetBySystemName(_config.AmazonRegion);
if (regionEndpoint.DisplayName == "Unknown")
{
throw new NullReferenceException("specified Region is invalid");
}
//Client guard
_s3Client = new AmazonS3Client(_config.AmazonAwsAccessKeyId, _config.AmazonAwsSecretAccessKey, regionEndpoint);
try
{
EnsureValidResponse(_s3Client.ListBucketsAsync().Result, HttpStatusCode.OK);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
//Bucket guard
_bucketName = _config.AmazonBucketName;
var bucketExists = _s3Client.DoesS3BucketExistAsync(_bucketName).Result;
while (bucketExists == false)
{
S3Region s3region = S3Region.FindValue(_config.AmazonRegion);
var putBucketRequest = new PutBucketRequest
{
BucketName = _bucketName,
BucketRegion = s3region,
};
try
{
EnsureValidResponse(_s3Client.PutBucketAsync(putBucketRequest).Result, HttpStatusCode.OK);
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode == "BucketAlreadyOwnedByYou")
{
break;
}
throw;
}
bucketExists = _s3Client.DoesS3BucketExistAsync(_bucketName).Result;
}
}
/// <summary>
/// Creates an Amazon S3 bucket with an ACL to control access to the
/// bucket and the objects stored in it.
/// </summary>
/// <param name="client">The initialized client object used to create
/// an Amazon S3 bucket, with an ACL applied to the bucket.
/// </param>
/// <param name="region">The AWS Region where the bucket will be created.</param>
/// <param name="newBucketName">The name of the bucket to create.</param>
/// <returns>A boolean value indicating success or failure.</returns>
public static async Task <bool> CreateBucketUseCannedACLAsync(IAmazonS3 client, S3Region region, string newBucketName)
{
try
{
// Create a new Amazon S3 bucket with Canned ACL.
var putBucketRequest = new PutBucketRequest()
{
BucketName = newBucketName,
BucketRegion = region,
CannedACL = S3CannedACL.LogDeliveryWrite,
};
PutBucketResponse putBucketResponse = await client.PutBucketAsync(putBucketRequest);
return(putBucketResponse.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Amazon S3 error: {ex.Message}");
}
return(false);
}
/// <summary>
/// Sets the BucketRegion property for this request.
/// When set, this will determine where your data will
/// reside in S3. Refer <see cref="T:Amazon.S3.Model.S3Region"/>
/// for a list of possible values.
/// </summary>
/// <param name="bucketRegion">The value that BucketRegion is set to</param>
/// <returns>the request with the BucketRegion set</returns>
public PutBucketRequest WithBucketRegion(S3Region bucketRegion)
{
BucketRegion = bucketRegion;
return this;
}
/// <summary>
/// Sets the BucketRegion property for this request.
/// Default: S3Region.US
/// </summary>
/// <remarks>
/// When set, this will determine where your data will
/// reside in S3. Refer <see cref="T:Amazon.S3.Model.S3Region"/>
/// for a list of possible values.
/// </remarks>
/// <param name="bucketRegion">The region locality to use for the new bucket</param>
/// <returns>the request with the BucketRegion set</returns>
public PutBucketRequest WithBucketRegion(S3Region bucketRegion)
{
BucketRegion = bucketRegion;
return(this);
}
public IRequest Marshall(PutBucketRequest putBucketRequest)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
IRequest val = new DefaultRequest(putBucketRequest, "AmazonS3");
val.set_HttpMethod("PUT");
if (putBucketRequest.IsSetCannedACL())
{
val.get_Headers().Add("x-amz-acl", putBucketRequest.CannedACL.get_Value());
}
else if (putBucketRequest.Grants != null && putBucketRequest.Grants.Count > 0)
{
ConvertPutWithACLRequest(putBucketRequest, val);
}
string resourcePath = "/" + S3Transforms.ToStringValue(putBucketRequest.BucketName);
val.set_ResourcePath(resourcePath);
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true
}))
{
string text = null;
S3Region bucketRegion = putBucketRequest.BucketRegion;
if (bucketRegion != null && !string.IsNullOrEmpty(bucketRegion.get_Value()))
{
text = bucketRegion.get_Value();
}
else if (!string.IsNullOrEmpty(putBucketRequest.BucketRegionName))
{
if (putBucketRequest.BucketRegionName == "eu-west-1")
{
text = "EU";
}
else if (putBucketRequest.BucketRegionName != "us-east-1")
{
text = putBucketRequest.BucketRegionName;
}
}
if (text != null)
{
xmlWriter.WriteStartElement("CreateBucketConfiguration", "");
xmlWriter.WriteElementString("LocationConstraint", "", text);
xmlWriter.WriteEndElement();
}
}
try
{
string text2 = stringWriter.ToString();
val.set_Content(Encoding.UTF8.GetBytes(text2));
val.get_Headers()["Content-Type"] = "application/xml";
string value = AmazonS3Util.GenerateChecksumForContent(text2, fBase64Encode: true);
val.get_Headers()["Content-MD5"] = value;
return(val);
}
catch (EncoderFallbackException ex)
{
throw new AmazonServiceException("Unable to marshall request to XML", (Exception)ex);
}
}
