/// <summary>
/// Creates a bucket in the S3 service
/// </summary>
/// <param name="bucketName">Name of the bucket to create. Use only text and dashes, no slashes or periods.</param>
/// <returns>The bucket object</returns>
public S3Bucket CreateBucket(string bucketName)
{
try
{
PutBucketRequest request = new PutBucketRequest()
{
BucketName = bucketName,
UseClientRegion = true,
CannedACL = S3CannedACL.PublicRead
};
s3Client.PutBucket(request);
}
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);
}
}
return(GetBucket(bucketName));
}
private void PutBucket()
{
try
{
PutBucketRequest request = new PutBucketRequest(bucket);
QCloudServer.SetRequestACLData(request);
//执行请求
PutBucketResult result = cosXml.PutBucket(request);
Assert.AreEqual(result.httpCode, 200);
isBucketCreatedByTest = true;
}
catch (COSXML.CosException.CosClientException clientEx)
{
Console.WriteLine("CosClientException: " + clientEx.Message);
Assert.Fail();
}
catch (COSXML.CosException.CosServerException serverEx)
{
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
if (serverEx.statusCode != 409)
{
Assert.Fail();
}
}
}
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 async Task CreateBucketWithDeploymentZipAsync(AmazonS3Client s3Client, string bucketName)
{
// create bucket if it doesn't exist
var listBucketsResponse = await s3Client.ListBucketsAsync();
if (listBucketsResponse.Buckets.Find((bucket) => bucket.BucketName == bucketName) == null)
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName
};
await s3Client.PutBucketAsync(putBucketRequest);
}
// write or overwrite deployment package
var putObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = DeploymentZipKey,
FilePath = GetDeploymentZipPath()
};
await s3Client.PutObjectAsync(putObjectRequest);
// Wait for bucket to propagate.
await Task.Delay(5000);
}
public static string CreateBucketWithWait(IAmazonS3 s3Client, PutBucketRequest bucketRequest)
{
string bucketName = CreateBucket(s3Client, bucketRequest);
WaitForBucket(s3Client, bucketName);
return(bucketName);
}
public async Task CreateBucketAsync(string bucketName)
{
try
{
if (await AmazonS3Util.DoesS3BucketExistAsync(_amazonS3, bucketName) == false)
{
var putBucketRequest = new PutBucketRequest
{
BucketName = bucketName
};
await _amazonS3.PutBucketAsync(putBucketRequest);
}
}
// Catch specific amazon errors
catch (AmazonS3Exception e)
{
throw e;
}
// Catch other errors
catch (Exception e)
{
throw e;
}
}
public async Task <PutBucketResponse> CreateBucketAsync(string bucketName)
{
PutBucketRequest request = new PutBucketRequest();
request.BucketName = bucketName;
return(await _client.PutBucketAsync(request));
}
public async Task CreateBucketAsync()
{
try
{
if (await AmazonS3Util.DoesS3BucketExistAsync(_client, BucketName) == false)
{
var putBucketRequest = new PutBucketRequest
{
BucketName = BucketName,
UseClientRegion = true
};
var response = await _client.PutBucketAsync(putBucketRequest);
_logger.LogInformation("Created Bucket - BucketName: {0}", BucketName);
}
else
{
_logger.LogInformation("Bucket is exist - BucketName: {0}", BucketName);
}
}
catch (AmazonS3Exception e)
{
_logger.LogInformation(e.Message);
throw;
}
catch (Exception e)
{
_logger.LogInformation(e.Message);
}
}
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);
}
}
static async Task RunExample()
{
// Identity
var client = new AmazonSecurityTokenServiceClient();
var getCallerIdReq = new GetCallerIdentityRequest();
var caller = await GetCallerIdentityResponseAsync(client, getCallerIdReq);
Console.WriteLine($"Caller identity: {caller.Arn} | {caller.Account} | {caller.UserId}");
// S3
RegionEndpoint region = RegionEndpoint.EUCentral1;
string bucketName = "dfds.static.content";
var s3Client = new AmazonS3Client(region);
var s3NewBucket = new PutBucketRequest
{
BucketName = bucketName,
BucketRegion = S3Region.EUC1,
CannedACL = S3CannedACL.Private
};
var s3BucketResponse = await s3Client.PutBucketAsync(s3NewBucket);
var s3PutObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "hello",
ContentBody = "Hi Pelle!",
ContentType = "text/plain"
};
var s3PutObjectResponse = await s3Client.PutObjectAsync(s3PutObjectRequest);
}
public async Task <S3Response> CreateBucketAsync(string bucketName)
{
try {
if (await AmazonS3Util.DoesS3BucketExistV2Async(_client, bucketName) == false)
{
var putBucketRequest = new PutBucketRequest {
BucketName = bucketName,
UseClientRegion = true
};
var response = await _client.PutBucketAsync(putBucketRequest);
return(new S3Response {
Message = response.ResponseMetadata.RequestId,
Status = response.HttpStatusCode
});
}
} catch (AmazonS3Exception e) {
return(new S3Response {
Message = e.Message,
Status = e.StatusCode
});
} catch (Exception ex) {
return(new S3Response {
Message = ex.Message,
Status = HttpStatusCode.InternalServerError
});
}
return(new S3Response {
Message = "Something went wrong...",
Status = HttpStatusCode.InternalServerError
});
}
public static string CreateBucket(string BucketName)
{
var status = "";
var client = GetS3Client();
var response = client.ListBucketsAsync().Result;
bool found = false;
foreach (var bucket in response.Buckets)
{
if (bucket.BucketName == BucketName)
{
found = true;
break;
}
}
if (found == false)
{
var bucketRequest = new PutBucketRequest();
bucketRequest.BucketName = BucketName;
bucketRequest.BucketRegionName = S3Region.US;
var output = client.PutBucketAsync(bucketRequest).Result;
status = output.HttpStatusCode.ToString();
}
return(status);
}
public static void Main(string[] args)
{
// create the AWS S3 client
AmazonS3Client s3 = AWSS3Factory.getS3Client();
// create bucket request
PutBucketRequest request = new PutBucketRequest()
{
BucketName = AWSS3Factory.S3_BUCKET
};
// create bucket - used for subsequent demos
s3.PutBucket(request);
// create bucket lising request
ListObjectsRequest objects = new ListObjectsRequest()
{
BucketName = AWSS3Factory.S3_BUCKET
};
// get bucket lising to retrieve bucket name
ListObjectsResponse result = s3.ListObjects(objects);
// print bucket name for validation
Console.WriteLine(string.Format("Successfully created bucket {0}.", result.Name));
Console.ReadLine();
}
public string CreateBucket()
{
NameValueCollection appSettings = ConfigurationManager.AppSettings;
using (AWSS3.client = new AmazonS3Client())
{
try
{
if (!AmazonS3Util.DoesS3BucketExist(AWSS3.client, appSettings["BucketName"]))
{
PutBucketRequest request = new PutBucketRequest
{
BucketName = appSettings["BucketName"],
UseClientRegion = true
};
AWSS3.client.PutBucket(request);
}
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode != null && (ex.ErrorCode.Equals("InvalidAccessKeyId") || ex.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", ex.Message);
}
}
}
return(appSettings["BucketName"]);
}
private void Initialise()
{
try
{
var request = new PutBucketRequest {
BucketName = _bucketName
};
#if NETSTANDARD
_client.PutBucketAsync(request).Wait();
#else
_client.PutBucket(request);
#endif
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode == "BucketAlreadyOwnedByYou")
{
//ignore this error as bucket already exists
}
else
{
throw;
}
}
}
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);
}
}
}
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");
}
}
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);
}
}
private static async Task CreateBucketAsync(AmazonS3Client client)
{
Console.Out.WriteLine("Checking S3 bucket with name " + BUCKET_NAME);
ListBucketsResponse response = await client.ListBucketsAsync();
bool found = false;
foreach (S3Bucket bucket in response.Buckets)
{
if (bucket.BucketName == BUCKET_NAME)
{
Console.Out.WriteLine("Bucket already Exists...............................");
found = true;
break;
}
}
if (found == false)
{
Console.Out.WriteLine("Bucket is Creating...............................");
PutBucketRequest request = new PutBucketRequest();
request.BucketName = BUCKET_NAME;
await client.PutBucketAsync(request);
Console.Out.WriteLine("Bucket has been Created S3 bucket with name " + BUCKET_NAME);
}
}
public async Task <S3Response> CreateLockerAsync(string LockerName)
{
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(_S3Settings, LockerName) == false)
{
var putLockerRequest = new PutBucketRequest
{
BucketName = LockerName,
UseClientRegion = true
};
var response = await _S3Settings.PutBucketAsync(putLockerRequest);
return(new S3Response
{
Message = response.ResponseMetadata.RequestId,
Status = response.HttpStatusCode
});
}
}
catch (AmazonS3Exception e)
{
return(new S3Response
{
Status = e.StatusCode,
Message = e.Message
});
}
return(new S3Response
{
Status = System.Net.HttpStatusCode.InternalServerError,
Message = ":("
});
}
private static async Task <PutBucketResponse> CreateIfNotExistsAsync(
AWSS3StorageCacheOptions options,
S3CannedACL acl)
{
AmazonS3Client client = AmazonS3ClientFactory.CreateClient(options);
bool foundBucket = false;
ListBucketsResponse listBucketsResponse = await client.ListBucketsAsync();
foreach (S3Bucket b in listBucketsResponse.Buckets)
{
if (b.BucketName == options.BucketName)
{
foundBucket = true;
break;
}
}
if (!foundBucket)
{
var putBucketRequest = new PutBucketRequest
{
BucketName = options.BucketName,
BucketRegion = options.Region,
CannedACL = acl
};
return(await client.PutBucketAsync(putBucketRequest));
}
return(null);
}
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());
}
}
static void Main(string[] args)
{
string AccessKey = " *** Enter Access Key Here *** ";
string SecretKey = " *** Enter Secret Key Here *** ";
string NameOFTheBucket = "*** Name Of The Bucket *** ";
string RegionOFTheBucket = " *** Enter the Region of the bucket (Eg: mumbai) *** ";
RegionOFTheBucket = RegionOFTheBucket.ToLower();
try
{
AmazonS3Client client = new AmazonS3Client(AccessKey, SecretKey, Amazon.RegionEndpoint.GetBySystemName(ClientRegion(RegionOFTheBucket)));
PutBucketRequest request = new PutBucketRequest
{
BucketName = NameOFTheBucket,
UseClientRegion = true
};
client.PutBucket(request);
Console.WriteLine("Bucket Created");
}
catch (Exception e)
{
Console.WriteLine("ERROR MESSAGE : " + e.Message);
}
Console.ReadLine();
}
public async Task <bool> TryCreateBucket(string bucketName, CancellationToken cancellationToken)
{
try
{
bool bucketExist = await _s3Client.DoesS3BucketExistAsync(bucketName);
if (!bucketExist)
{
var request = new PutBucketRequest {
BucketName = bucketName
};
var response = await _s3Client.PutBucketAsync(request, cancellationToken);
return(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
return(bucketExist);
}
catch (AmazonS3Exception amazonS3Exception)
{
_logger.LogError("S3 error occured. Exception:", amazonS3Exception.ToString());
throw;
}
catch (Exception e)
{
_logger.LogError(e.InnerException, e.Message);
throw;
}
}
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);
}
/// <summary>
/// Create a new Amazon S3 bucket using the supplied Access Key to
/// create an Amazon S3 client using the new user.
/// </summary>
/// <param name="accessKey">The AccessKey that will provide permissions
/// for the new user to call ListBucketsAsync.</param>
/// <param name="bucketName">The name of the Amazon S3 bucket to create.</param>
/// <returns>A boolean value indicating the success or failure of the operation.</returns>
public static async Task <bool> CreateS3BucketAsync(
AccessKey accessKey,
string bucketName)
{
// Creating a client that works with this user.
var client = new AmazonS3Client(accessKey.AccessKeyId, accessKey.SecretAccessKey);
var success = false;
try
{
var request = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true,
};
var response = await client.PutBucketAsync(request);
success = true;
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error creating bucket: '{ex.Message}'");
}
return(success);
}
// Create the output bucket if it does not exist already.
public static void CreateBucket(string bucket)
{
ListBucketsResponse responseBuckets = s3ForStudentBuckets.ListBuckets();
bool found = false;
foreach (S3Bucket s3Bucket in responseBuckets.Buckets)
{
if (s3Bucket.BucketName == bucket)
{
found = true;
VerifyBucketOwnership(bucket);
break;
}
else
{
found = false;
}
}
if (found == false)
{
Debug.Write("Transformer: Creating output bucket: " + bucket);
PutBucketRequest request = new PutBucketRequest();
request.BucketName = bucket;
s3ForStudentBuckets.PutBucket(request);
}
}
public async Task <PutBucketResponse> CreateBucket(String bucketName)
{
PutBucketRequest request = new PutBucketRequest();
request.BucketName = aWSUniqueDbKey + bucketName;
return(await s3Client.PutBucketAsync(request));
}
public void CreateS3Bucket(String name)
{
NameValueCollection appConfig = ConfigurationManager.AppSettings;
AmazonS3Client client = new AmazonS3Client(
appConfig["AWSAccessKey"],
appConfig["AWSSecretKey"],
Amazon.RegionEndpoint.USWest2
);
PutBucketRequest request = new PutBucketRequest();
request.BucketName = name;
client.PutBucket(request);
ListBucketsResponse response = client.ListBuckets();
//create folder
PutObjectRequest putObjectRequest = new PutObjectRequest
{
BucketName = name,
Key = "album/"
};
client.PutObject(putObjectRequest);
//upload to folder in bucket
}
public void CreateBucket(string bucket_name, AmazonS3Client client)
{
if (bucket_name is null)
{
throw new ArgumentNullException();
}
List <string> existing_buckets = GetAllBuckets(client);
try
{
if (existing_buckets.Where(b => b.ToString() == bucket_name).FirstOrDefault() is null)
{
var request = new PutBucketRequest
{
BucketName = bucket_name,
UseClientRegion = true
};
Task <PutBucketResponse> task = client.PutBucketAsync(request);
task.Wait();
}
}
catch (Exception e)
{
throw e;
}
}
