static async Task CreateBucket(IAmazonS3 client)
{
try
{
PutBucketRequest putRequest1 = new PutBucketRequest
{
BucketName = bucket,
BucketRegion = Amazon.S3.S3Region.FindValue(region.SystemName)
};
PutBucketResponse response1 = await client.PutBucketAsync(putRequest1);
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Check the provided AWS Credentials.");
Console.WriteLine("For service sign up go to http://aws.amazon.com/s3");
}
else
{
Console.WriteLine(
"Error occurred. Message:'{0}' when writing an object"
, amazonS3Exception.Message);
}
}
}
private void CreateABucket(IAmazonS3 client, string bucketName)
{
try
{
PutBucketRequest putRequest1 = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse response1 = client.PutBucket(putRequest1);
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Check the provided AWS Credentials.");
Console.WriteLine(
"For service sign up go to http://aws.amazon.com/s3");
}
else
{
Console.WriteLine(
"Error occurred. Message:'{0}' when writing an object"
, amazonS3Exception.Message);
}
}
}
private static void DisplayPutBucketResponse(PutBucketResponse putBucketResponse)
{
var writer = Console.Out;
writer.WriteLine($"{nameof(putBucketResponse.HttpStatusCode)}: {putBucketResponse.HttpStatusCode}");
Construction.DisplayResponseMetadata(writer, putBucketResponse.ResponseMetadata);
}
private static async Task CreateBucketAsync()
{
var config = new AmazonS3Config
{
RegionEndpoint = RegionEndpoint.USEast1, // MUST set this before setting ServiceURL and it should match the `MINIO_REGION` environment variable.
ServiceURL = endpointURL, // replace http://localhost:9000 with URL of your MinIO server
ForcePathStyle = true // MUST be true to work correctly with MinIO server
};
var amazonS3Client = new AmazonS3Client(accessKey, secretKey, config);
try
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = await amazonS3Client.PutBucketAsync(putBucketRequest);
Console.Out.WriteLine("Status code = '" + putBucketResponse.HttpStatusCode);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
private static async Task CreateBucketUseCannedACLAsync()
{
try
{
// Add bucket (specify canned ACL).
PutBucketRequest putBucketRequest = new PutBucketRequest()
{
BucketName = newBucketName,
BucketRegion = S3Region.EUW1, // S3Region.US,
// Add canned ACL.
CannedACL = S3CannedACL.LogDeliveryWrite
};
PutBucketResponse putBucketResponse = await client.PutBucketAsync(putBucketRequest);
// Retrieve bucket ACL.
GetACLResponse getACLResponse = await client.GetACLAsync(new GetACLRequest
{
BucketName = newBucketName
});
}
catch (AmazonS3Exception amazonS3Exception)
{
Console.WriteLine("S3 error occurred. Exception: " + amazonS3Exception.ToString());
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.ToString());
}
}
private static async Task CreateBucketAndUploadFileAsync(IAmazonS3 s3Client, string bucketName, string path, string key)
{
try
{
if (!await AmazonS3Util.DoesS3BucketExistAsync(s3Client, bucketName))
{
var putBucketRequest = new PutBucketRequest {
BucketName = bucketName, UseClientRegion = true
};
PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
}
// Retrieve the bucket location.
string bucketLocation = await FindBucketLocationAsync(s3Client, bucketName);
var fileTransferUtility = new TransferUtility(s3Client);
await fileTransferUtility.UploadAsync(path, bucketName, key);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
// Let us make sure that the bucket exists..
private async Task CheckCreateBucketAsync(string bucketName)
{
AmazonS3Client s3Client = GetS3Client();
try
{
GetBucketLocationResponse gblr = await s3Client.GetBucketLocationAsync(bucketName);
if (gblr != null)
{
Console.WriteLine("Bucket " + bucketName + " Exists @ " + gblr.Location.Value);
}
}
catch (AmazonS3Exception se)
{
// Got an Exception so bucket may not exists..
// Lets try creating the bucket..
Console.WriteLine("Bucket " + bucketName + " Does not Exist, error code-> " + se.ErrorCode);
PutBucketRequest pbr = new PutBucketRequest();
pbr.BucketName = bucketName;
PutBucketResponse pbrr = await s3Client.PutBucketAsync(pbr);
Console.WriteLine("Bucket " + bucketName + " Created in client region.");
}
}
static async Task CreateBucketAsync()
{
try
{
if (!(await AmazonS3Util.DoesS3BucketExistAsync(s3Client, bucketName)))
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
}
// Retrieve the bucket location.
string bucketLocation = await FindBucketLocationAsync(s3Client);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
/*
* public async Task MergeIntoBucketAsync(string repoName, string branchName, string parentBranchName)
* {
* using (s3Client = new AmazonS3Client(bucketRegion))
* {
* // TODO TODO TODO TODO
*
*
*
*
*
* throw new NotImplementedException();
* }
* }
*/
private async Task <PutBucketResponse> CreateBucketAsync(string bucketName)
{
try
{
if (!(await AmazonS3Util.DoesS3BucketExistAsync(s3Client, bucketName)))
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
return(putBucketResponse);
}
else
{
return(new PutBucketResponse {
HttpStatusCode = HttpStatusCode.Conflict
});
}
}
catch (Exception)
{
return(new PutBucketResponse {
HttpStatusCode = HttpStatusCode.InternalServerError
});
}
}
public async Task <bool> CreateBucket(string name)
{
try
{
if (!(await AmazonS3Util.DoesS3BucketExistAsync(s3Client, name)))
{
var putBucketRequest = new PutBucketRequest
{
BucketName = name,
UseClientRegion = true,
};
PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
}
return(true);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
return(false);
}
public bool CreateS3Bucket(string bucketName)
{
try
{
if (!(AmazonS3Util.DoesS3BucketExistV2Async(client, bucketName).Result))
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = client.PutBucketAsync(putBucketRequest).Result;
return(putBucketResponse.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
}
catch (AmazonS3Exception e)
{
Logger.AddLog(string.Format("Error encountered on server. Message:'{0}' when writing an object", e.Message));
}
catch (Exception e)
{
Logger.AddLog(string.Format("Unknown encountered on server. Message:'{0}' when writing an object", e.Message));
}
return(false);
}
public async Task S3Service_Should_Create_A_Bucket()
{
var bucketName = Guid.NewGuid().ToString();
PutBucketResponse putBucketResponse = await CreateTestBucket(bucketName);
Assert.Equal(HttpStatusCode.OK, putBucketResponse.HttpStatusCode);
}
/// <summary>
/// Creates an Amazon S3 bucket and adds and 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
/// the ACL, create an S3 bucket, and then apply the ACL to the bucket.
/// </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, string newBucketName)
{
try
{
// Create a new S3 bucket with Canned ACL.
PutBucketRequest putBucketRequest = new ()
{
BucketName = newBucketName,
BucketRegion = S3Region.USE2, // S3Region.US,
CannedACL = S3CannedACL.LogDeliveryWrite,
};
PutBucketResponse putBucketResponse = await client.PutBucketAsync(putBucketRequest);
// Retrieve bucket ACL to show that the Access Control List
// was properly applied to the new bucket.
GetACLResponse getACLResponse = await client.GetACLAsync(new GetACLRequest
{
BucketName = newBucketName,
});
return(getACLResponse.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"S3 error: {ex.Message}");
}
return(false);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
PutBucketResponse putBucketResponse = new PutBucketResponse();
UnmarshallResult(context, putBucketResponse);
return(putBucketResponse);
}
void CreateBucketWebResponse(object sender, ResponseEventArgs args)
{
AmazonS3Exception response = args.Response as AmazonS3Exception;
S3Common.client.OnS3Response -= CreateBucketWebResponse;
if (null != response)
{
S3ErrorResponse(response);
return;
}
PutBucketResponse putBucketResponse = args.Response as PutBucketResponse;
if (null != putBucketResponse)
{
if (!string.IsNullOrEmpty(putBucketResponse.AmazonId2) &&
(!string.IsNullOrEmpty(putBucketResponse.RequestId)))
{
this.Dispatcher.BeginInvoke(() =>
{
GetBucketResult = string.Format(CultureInfo.InvariantCulture, "{0} bucket created Successfully", CreateBucketName);
});
}
}
else
{
this.Dispatcher.BeginInvoke(() =>
{
GetBucketResult = string.Format(CultureInfo.InvariantCulture, "Unsuccessul Creation of Bucket: {0}", CreateBucketName);
});
}
}
internal static void CreateABucket(IAmazonS3 client)
{
try
{
PutBucketRequest putRequest = new PutBucketRequest
{
//Envia o pedido para criar o bucket (caso ele não exista), concedendo controle total para o dono
BucketName = bucketName,
UseClientRegion = true,
Grants = new List <S3Grant>
{
new S3Grant {
Grantee = new S3Grantee {
DisplayName = "contato"
}, Permission = S3Permission.FULL_CONTROL
}
}
};
//Cria o bucket na região especificada pelo cliente
PutBucketResponse putResponse = client.PutBucket(putRequest);
}
catch (Exception e)
{
RService.Log("RService Exception AWS (CreateABucket): " + e.Message + " / " + e.StackTrace + " / " + e.InnerException + " / " + e.InnerException + " / " + e.InnerException + " at {0}", Path.GetTempPath() + "RSERVICE" + ".txt");
}
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
PutBucketResponse response = new PutBucketResponse();
UnmarshallResult(context,response);
return response;
}
public void CreateBucket(string bucketName)
{
PutBucketRequest bucketRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse bucketResp = s3Client.PutBucket(bucketRequest);
}
private static void UnmarshallResult(XmlUnmarshallerContext context,PutBucketResponse response)
{
return;
}
public async Task <PutBucketResponse> setupBucket()
{
var putBucketRequest = new PutBucketRequest
{
BucketName = s3BucketName,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = await s3Client.PutBucketAsync(putBucketRequest);
return(putBucketResponse);
}
public static async Task <bool> AddBuckets(AmazonS3Client amazonS3Client, string bucketName)
{
PutBucketResponse putBucketResponse = await amazonS3Client.PutBucketAsync(bucketName);
if (putBucketResponse.HttpStatusCode != HttpStatusCode.OK)
{
Console.WriteLine($"添加失败 {Environment.NewLine}BucketName:{bucketName}");
throw new Exception("添加失败");
}
return(true);
}
static void CreateABucket(IAmazonS3 client, string bucketName)
{
PutBucketRequest putRequest1 = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
PutBucketResponse response1 = client.PutBucket(putRequest1);
Trace.WriteLine("Creating a bucket " + bucketName);
}
public async Task PutWithObjectLocking()
{
string tempBucketName = "testbucket-" + Guid.NewGuid();
PutBucketResponse pResp = await BucketClient.PutBucketAsync(tempBucketName, request =>
{
request.EnableObjectLocking = true;
request.Region = Config.Region;
}).ConfigureAwait(false);
Assert.True(pResp.IsSuccess);
}
public void AddBucket(string bucketName)
{
PutBucketRequest request = new PutBucketRequest();
request.BucketName = bucketName;
if (!string.IsNullOrEmpty(m_locationConstraint))
{
request.BucketRegionName = m_locationConstraint;
}
PutBucketResponse response = m_client.PutBucket(request);
}
public override async Task CreateContainer(CancellationToken cancellationToken)
{
if (!await AmazonS3Util.DoesS3BucketExistV2Async(_s3Client.Value, Container).ConfigureAwait(false))
{
var putBucketRequest = new PutBucketRequest
{
BucketName = Container,
UseClientRegion = true
};
PutBucketResponse putBucketResponse = await _s3Client.Value.PutBucketAsync(putBucketRequest, cancellationToken).ConfigureAwait(false);
}
}
//bucket will be created in US-East-1 region
//If you specify us-east-1, you will get an error.
//If you don't specify a region, it will use us-east-1
//If you specify another region, it works
//not worth my time to code for any region.
private async Task <PutBucketResponse> createAwsS3Bucket(string bucketName)
{
logger.LogInformation($"Creating S3 bucket '{ bucketName }'...");
PutBucketRequest request = new PutBucketRequest
{
BucketName = bucketName,
CannedACL = S3CannedACL.PublicRead // make bucket publicly readable
};
PutBucketResponse bucket = await TheS3Client().PutBucketAsync(request);
return(bucket);
}
public async Task PutAndGet()
{
string tempBucketName = "testbucket-" + Guid.NewGuid();
PutBucketResponse pResp = await BucketClient.PutBucketAsync(tempBucketName, request =>
{
request.Region = Config.Region;
request.Acl = BucketCannedAcl.Private;
}).ConfigureAwait(false);
Assert.True(pResp.IsSuccess);
//We prefix with a number here to keep sort order when we download the list of objects further down
string tempObjName = "object-1" + Guid.NewGuid();
string tempObjName2 = "object-2" + Guid.NewGuid();
await ObjectClient.PutObjectStringAsync(tempBucketName, tempObjName, "hello").ConfigureAwait(false);
await ObjectClient.PutObjectStringAsync(tempBucketName, tempObjName2, "world!", null, request => request.StorageClass = StorageClass.OneZoneIa).ConfigureAwait(false);
GetBucketResponse gResp = await BucketClient.GetBucketAsync(tempBucketName).ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(2, gResp.KeyCount);
Assert.Equal(2, gResp.Objects.Count);
Assert.Equal(string.Empty, gResp.Prefix);
Assert.Equal(tempObjName, gResp.Objects[0].Name);
Assert.Equal(DateTime.UtcNow, gResp.Objects[0].LastModified.DateTime, TimeSpan.FromSeconds(5));
Assert.Equal("\"5d41402abc4b2a76b9719d911017c592\"", gResp.Objects[0].ETag);
Assert.Equal(5, gResp.Objects[0].Size);
Assert.Equal(StorageClass.Standard, gResp.Objects[0].StorageClass);
Assert.Equal(tempObjName2, gResp.Objects[1].Name);
Assert.Equal(DateTime.UtcNow, gResp.Objects[1].LastModified.DateTime, TimeSpan.FromSeconds(5));
Assert.Equal("\"08cf82251c975a5e9734699fadf5e9c0\"", gResp.Objects[1].ETag);
Assert.Equal(6, gResp.Objects[1].Size);
Assert.Equal(StorageClass.OneZoneIa, gResp.Objects[1].StorageClass);
GetBucketResponse gResp2 = await BucketClient.GetBucketAsync(tempBucketName, request => request.EncodingType = EncodingType.Url).ConfigureAwait(false);
Assert.True(gResp2.IsSuccess);
Assert.Equal(2, gResp2.KeyCount);
//The keys should be URL encoded at this point
Assert.Equal(UrlHelper.UrlEncode(tempObjName), gResp.Objects[0].Name);
Assert.Equal(UrlHelper.UrlEncode(tempObjName2), gResp.Objects[1].Name);
}
public async void SendSNS()
{
ListBucketsResponse buckets = await MyListBucketsAsync(S3Client).ConfigureAwait(false);
string bucketName = "";
// Call the API method directly
try
{
PutBucketResponse createResponse = await S3Client.PutBucketAsync(bucketName);
}
catch (Exception e)
{
}
}
/// <summary>
/// Create a new bucket
/// </summary>
/// <param name="bucketName">Name</param>
/// <returns></returns>
public static bool CreateBucket(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
return(false);
}
using (IAmazonS3 s3Client = GetAmazonS3ClientInstance())
{
PutBucketRequest putBucketRequest = new PutBucketRequest();
putBucketRequest.BucketName = bucketName;
putBucketRequest.BucketRegion = S3Region.US;
PutBucketResponse putBucketResponse = s3Client.PutBucket(putBucketRequest);
return(putBucketResponse.HttpStatusCode == HttpStatusCode.OK);
}
}
public async Task PutWithAcl()
{
string tempBucketName = "testbucket-" + Guid.NewGuid();
PutBucketResponse pResp = await BucketClient.PutBucketAsync(tempBucketName, request =>
{
request.AclGrantReadAcp.AddEmail(TestConstants.TestEmail);
request.AclGrantWriteAcp.AddEmail(TestConstants.TestEmail);
request.AclGrantRead.AddEmail(TestConstants.TestEmail);
request.AclGrantWrite.AddEmail(TestConstants.TestEmail);
request.AclGrantFullControl.AddEmail(TestConstants.TestEmail);
request.Region = Config.Region;
}).ConfigureAwait(false);
Assert.True(pResp.IsSuccess);
}
public async Task NewBucket(String bucketName)
{
PutBucketResponse response = null;
try
{
PutBucketRequest putRequest = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
bool found = await IfBucketExist(bucketName);
if (!found)
{
response = await client.PutBucketAsync(putRequest);
if (response.HttpStatusCode.ToString() == "OK")
{
Console.WriteLine("New bucket " + bucketName + " was created");
}
}
else
{
Console.WriteLine("Bucket already exists");
}
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId")
||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Check the provided AWS Credentials.");
Console.WriteLine(
"For service sign up go to http://aws.amazon.com/s3");
}
else
{
Console.WriteLine(
"Error occurred. Message:'{0}' when writing an object"
, amazonS3Exception.Message);
}
}
}
//S3 Methods//
//Create S3 Bucket//
private static void CreateBucket(IAmazonS3 client, string bucket)
{
bucket = bucket.Replace("\\", "/");
try
{
PutBucketRequest putRequest = new PutBucketRequest
{
BucketName = "srpdesign/" + bucket + "/",
UseClientRegion = true
};
PutBucketResponse response = client.PutBucket(putRequest);
}
catch (AmazonS3Exception amazonS3Exception)
{
Console.WriteLine(amazonS3Exception);
}
}
