public static void AsynDeleteBucket(COSXML.CosXml cosXml, string bucket)
{
DeleteBucketRequest request = new DeleteBucketRequest(bucket);
//设置签名有效时长
request.SetSign(TimeUtils.GetCurrentTime(TimeUnit.SECONDS), 600);
///执行请求
cosXml.DeleteBucket(request,
delegate(CosResult cosResult)
{
DeleteBucketResult result = cosResult as DeleteBucketResult;
Console.WriteLine(result.GetResultInfo());
},
delegate(CosClientException clientEx, CosServerException serverEx)
{
if (clientEx != null)
{
QLog.D("XIAO", clientEx.Message);
Console.WriteLine("CosClientException: " + clientEx.StackTrace);
}
if (serverEx != null)
{
QLog.D("XIAO", serverEx.Message);
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
}
});
}
public async Task <S3Response> DeleteBucketAsync(string bucketName)
{
try
{
var deleteBucketRequest = new DeleteBucketRequest
{
BucketName = bucketName,
UseClientRegion = true,
};
var response = await _client.DeleteBucketAsync(deleteBucketRequest);
return(new S3Response
{
Message = response.ResponseMetadata.RequestId,
Status = response.HttpStatusCode,
});
}
catch (AmazonS3Exception e)
{
return(new S3Response
{
Status = e.StatusCode,
Message = e.Message
});
throw;
}
}
public async Task DeleteBucket(String bucketName)
{
DeleteBucketResponse response = null;
DeleteBucketRequest request = new DeleteBucketRequest
{
BucketName = bucketName
};
bool found = await IfBucketExist(bucketName);
if (!found)
{
Console.WriteLine("bucket not found");
}
else
{
try
{
response = await client.DeleteBucketAsync(request);
if (response.HttpStatusCode.ToString() == "OK")
{
Console.WriteLine("Bucket " + bucketName + " was deleted");
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Bucket is not empty.. Emptying bucket");
Console.WriteLine(e.ToString());
}
}
}
/// 删除存储桶
public void DeleteBucket()
{
//.cssg-snippet-body-start:[delete-bucket]
try
{
string bucket = "examplebucket-1250000000"; //格式：BucketName-APPID
DeleteBucketRequest request = new DeleteBucketRequest(bucket);
//执行请求
DeleteBucketResult result = cosXml.DeleteBucket(request);
//请求成功
Console.WriteLine(result.GetResultInfo());
}
catch (COSXML.CosException.CosClientException clientEx)
{
//请求失败
Console.WriteLine("CosClientException: " + clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
//请求失败
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
}
//.cssg-snippet-body-end
}
public void DeleteBucketTest()
{
var entity = new DeleteBucketRequest("icyufile");
var response = ufile.DeleteBucket(entity);
Assert.AreEqual(response.RetCode, 0);
}
public async Task DeleteBucketAsync(string bucketName)
{
var deleteBucketRequest = new DeleteBucketRequest {
BucketName = bucketName, UseClientRegion = true
};
var response = await _s3Client.DeleteBucketAsync(deleteBucketRequest);
}
static void Main(string[] args)
{
SharedCredentialsFile sharedCredentialsFile = new SharedCredentialsFile();
CredentialProfile defaultProfile = GetDefaultProfile(sharedCredentialsFile);
if (defaultProfile != null)
{
AWSCredentials credentials = AWSCredentialsFactory.GetAWSCredentials(defaultProfile, new SharedCredentialsFile());
AmazonS3Client s3Client = new AmazonS3Client(credentials, RegionEndpoint.USEast1);
DeleteBucketRequest request = new DeleteBucketRequest
{
//How to get this name programatically without hard coding? bucket.name?
BucketName = "20411141-0e46-4b95-8074-1e28cb421306"
};
if (request.Equals(null))
{
DeleteBucketResponse dResponse = s3Client.DeleteBucket(request);
}
ListBucketsResponse response = s3Client.ListBuckets();
foreach (S3Bucket r in response.Buckets)
{
Console.WriteLine(r.BucketName + " created at " + r.CreationDate + " type = " + r.GetType());
}
}
Console.ReadLine();
}
public void DeleteBucket(string bucket_name, AWS_Credentials credentials)
{
if (credentials is null || credentials.AWS_AccessKey is null || credentials.AWS_SecretKey is null || credentials.Region is null)
{
throw new CredentialsNotProvidedException();
}
if (bucket_name is null)
{
throw new ArgumentNullException();
}
using (AmazonS3Client client = getS3Client(credentials))
{
List <string> existing_buckets = GetAllBuckets(credentials);
try
{
if (!(existing_buckets.Where(b => b.ToString() == bucket_name).FirstOrDefault() is null))
{
var request = new DeleteBucketRequest
{
BucketName = bucket_name,
UseClientRegion = true
};
Task <DeleteBucketResponse> task = client.DeleteBucketAsync(request);
task.Wait();
}
}
catch (Exception e)
{
throw e;
}
}
}
public void DeleteBucket(DeleteBucketRequest request)
{
using (var response = _netLayer.Invoke(request))
{
ResponseParseUtilities.HandleStatusCode(response, HttpStatusCode.NoContent);
}
}
/// <summary>
/// 删除Bucket
/// </summary>
/// <param name="requestParams">请求参数.</param>
/// <returns>返回对象<see cref="UCloudSDK.Models.DeleteBucketResponse"/></returns>
public DeleteBucketResponse DeleteBucket(DeleteBucketRequest requestParams)
{
var request = new RestRequest(Method.GET);
request.AddUObject(requestParams);
return(Execute <DeleteBucketResponse>(request));
}
public async Task <DeleteBucketResponse> DeleteBucketAsync(string bucketName)
{
DeleteBucketRequest request = new DeleteBucketRequest();
request.BucketName = bucketName;
return(await _client.DeleteBucketAsync(request));
}
/// <summary>
/// Method deletes bucket from the S3
/// </summary>
/// <param name="bucketName">Name of the bucket</param>
public void DeleteBucket(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
DeleteBucketRequest s3DeleteBucketRequest = new DeleteBucketRequest();
s3DeleteBucketRequest.BucketName = bucketName;
s3DeleteBucketRequest.UseClientRegion = true;
try
{
Task <DeleteBucketResponse> s3DeleteBucketResponse = _client.DeleteBucketAsync(s3DeleteBucketRequest);
Console.WriteLine($"HTTP status code : {s3DeleteBucketResponse.Result.HttpStatusCode}");
}
catch (System.AggregateException ex)
{
if (ex.InnerException != null)
{
Console.WriteLine($"Message: {ex.InnerException.Message}");
}
}
}
public void TestCleanup()
{
try
{
var objRequest = new ListObjectsRequest()
{
BucketName = this.bucketName
};
using (var objResponse = client.ListObjects(objRequest))
{
var delRequest = new DeleteObjectsRequest()
{
BucketName = this.bucketName,
Quiet = true
};
delRequest.AddKeys(objResponse.S3Objects.Select(o => new KeyVersion(o.Key)).ToArray());
using (var delResponse = client.DeleteObjects(delRequest))
{
}
}
var deleteRequest = new DeleteBucketRequest()
{
BucketName = this.bucketName
};
using (var deleteResponse = client.DeleteBucket(deleteRequest)) { }
}
catch (Exception ex)
{
this.TestContext.WriteLine("Warning: Could not cleanup bucket: {0}. {1}", this.bucketName, ex);
}
}
public void DeleteBucket(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 DeleteBucketRequest
{
BucketName = bucket_name,
UseClientRegion = true
};
Task <DeleteBucketResponse> task = client.DeleteBucketAsync(request);
task.Wait();
}
}
catch (Exception e)
{
throw e;
}
}
private async Task DeleteDeploymentZipAndBucketAsync(AmazonS3Client s3Client, string bucketName)
{
// Delete the deployment zip.
// This is idempotent - it works even if the object is not there.
var deleteObjectRequest = new DeleteObjectRequest
{
BucketName = bucketName,
Key = DeploymentZipKey
};
await s3Client.DeleteObjectAsync(deleteObjectRequest);
// Delete the bucket.
// Make idempotent by checking exception.
var deleteBucketRequest = new DeleteBucketRequest
{
BucketName = bucketName
};
try
{
await s3Client.DeleteBucketAsync(deleteBucketRequest);
}
catch (AmazonS3Exception e)
{
// If it's just telling us the bucket's not there then continue, otherwise throw.
if (!e.Message.Contains("The specified bucket does not exist"))
{
throw;
}
}
}
public bool DeleteBucket()
{
try
{
ListObjectsRequest request = new ListObjectsRequest();
request.BucketName = this.bucketName;
ListObjectsResponse response = amazonS3Client.ListObjects(request);
foreach (S3Object o in response.S3Objects)
{
DeleteObjectRequest delrequest = new DeleteObjectRequest();
delrequest.BucketName = this.bucketName;
delrequest.Key = o.Key;
amazonS3Client.DeleteObject(delrequest);
}
DeleteBucketRequest delbucketrequest = new DeleteBucketRequest();
delbucketrequest.BucketName = this.bucketName;
amazonS3Client.DeleteBucket(delbucketrequest);
return(true);
}
catch (Exception e)
{
structuredLog("E", "Exception in DeleteBucket: " + e);
return(false);
}
}
private static async Task DeleteBucketAsync()
{
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 deleteBucketRequest = new DeleteBucketRequest
{
BucketName = bucketName,
UseClientRegion = true
};
DeleteBucketResponse deleteBucketResponse = await amazonS3Client.DeleteBucketAsync(bucketName);
Console.Out.WriteLine("Status code = '" + deleteBucketResponse.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);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
if (!ConfirmDelete("OCIObjectstorageBucket", "Remove"))
{
return;
}
DeleteBucketRequest request;
try
{
request = new DeleteBucketRequest
{
NamespaceName = NamespaceName,
BucketName = BucketName,
IfMatch = IfMatch,
OpcClientRequestId = OpcClientRequestId
};
response = client.DeleteBucket(request).GetAwaiter().GetResult();
WriteOutput(response);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public void DeleteBucket(string bucketName, string bucketKey = null)
{
#region Delete Bucket Policy
DeleteBucketPolicyResponse delBucketResp = new DeleteBucketPolicyResponse();
Console.WriteLine("Bucket policy del -1");
delBucketResp = s3Client.DeleteBucketPolicy(bucketName);
Console.WriteLine("Bucket policy del -2");
Console.WriteLine("s3Client");
#endregion
if (bucketKey != null)
{
GetObjectRequest getObjectRequest = new GetObjectRequest();
getObjectRequest.BucketName = bucketName;
getObjectRequest.Key = bucketKey;
// GetObjectResponse getObjectResponse = s3Client.GetObject(getObjectRequest);
DeleteObjectResponse deleteObjectResponse = s3Client.DeleteObject(bucketName, bucketKey);
}
#region Delete Bucket Request
DeleteBucketRequest req = new DeleteBucketRequest();
Console.WriteLine("Req");
req.BucketName = bucketName;
Console.WriteLine(bucketName);
req.UseClientRegion = true;
#endregion
#region Delete Bucket Responce
DeleteBucketResponse resp = s3Client.DeleteBucket(req);
Console.WriteLine("Bucket deleted");
#endregion
}
protected override void ExecuteTask()
{
Project.Log(Level.Info, "Deleting S3 bucket: {0}", BucketName);
/// Check to see if the bucket exists before we try to delete it.
if (!BucketExists(BucketName))
{
Project.Log(Level.Warning, "Bucket: {0} not found!", BucketName);
return;
}
else
{
using (Client)
{
try
{
DeleteBucketRequest request = new DeleteBucketRequest();
request.BucketName = BucketName;
Client.DeleteBucket(request);
}
catch (AmazonS3Exception ex)
{
ShowError(ex);
}
}
}
}
private static void DeleteBucket(AmazonS3 s3Client, string bucket)
{
var deleteBucketRequest = new DeleteBucketRequest {
BucketName = bucket
};
s3Client.DeleteBucket(deleteBucketRequest);
}
/// <summary>
/// Delete a S3 Bucket.
/// </summary>
/// <param name="bucketName"></param>
public void DeleteBucket(string bucketName)
{
var request = new DeleteBucketRequest {
BucketName = bucketName
};
Client.DeleteBucket(request);
}
public async Task Delete(string name)
{
var request = new DeleteBucketRequest
{
BucketName = name
};
await amazonS3Client.DeleteBucketAsync(request);
}
public Task <DeleteBucketResponse> DeleteBucketAsync(string bucketName, Action <DeleteBucketRequest>?config = null, CancellationToken token = default)
{
DeleteBucketRequest request = new DeleteBucketRequest(bucketName);
config?.Invoke(request);
return(BucketOperations.DeleteBucketAsync(request, token));
}
protected Task <DeleteBucketResponse> DeleteTestBucket(string bucketName = null)
{
var deleteBucketRequest = new DeleteBucketRequest {
BucketName = bucketName ?? BucketName, UseClientRegion = true
};
return(AmazonS3.DeleteBucketAsync(deleteBucketRequest));
}
internal static void DeleteBucket(CosXmlServer cosXml)
{
DeleteBucketRequest request = new DeleteBucketRequest(bucket);
DeleteBucketResult result = cosXml.DeleteBucket(request);
Console.WriteLine(result.GetResultInfo());
}
public Task <DeleteBucketResponse> DeleteAsync(string bucketName, Action <DeleteBucketRequest> config = null, CancellationToken token = default)
{
DeleteBucketRequest req = new DeleteBucketRequest(bucketName);
config?.Invoke(req);
return(_requestHandler.SendRequestAsync <DeleteBucketRequest, DeleteBucketResponse>(req, token));
}
private void DeleteFolderInternal(string path, bool recursive)
{
if (string.IsNullOrEmpty(path))
{
return;
}
var bki = new S3BucketKeyInfo(path, terminateWithPathDelimiter: true);
if (recursive)
{
while (true)
{
var objects = ListFolder(bki);
if (!objects.Any())
{
break;
}
var keys = objects.Select(o => new KeyVersion
{
Key = o.Key
})
.ToList();
var deleteObjectsRequest = new DeleteObjectsRequest
{
BucketName = bki.BucketName,
Quiet = true,
Objects = keys
};
S3Client.DeleteObjects(deleteObjectsRequest);
}
}
else if (!bki.IsBucketObject)
{
var deleteObjectRequest = new DeleteObjectRequest
{
BucketName = bki.BucketName,
Key = bki.Key
};
S3Client.DeleteObject(deleteObjectRequest);
}
if (bki.IsBucketObject)
{
var request = new DeleteBucketRequest
{
BucketName = bki.BucketName,
UseClientRegion = true
};
S3Client.DeleteBucket(request);
}
}
/// <summary>
/// Delete a bucket and its content.
/// </summary>
/// <param name="bucketName">The name of the bucket.</param>
public void DeleteBucket(string bucketName)
{
var request = new DeleteBucketRequest
{
BucketName = bucketName
};
_amazonS3.DeleteBucket(request);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
CmdletOutput output;
if (cmdletContext.DeleteObjects)
{
output = null;
#if DESKTOP
AmazonS3Util.DeleteS3BucketWithObjects(Client,
cmdletContext.BucketName,
new S3DeleteBucketWithObjectsOptions
{
ContinueOnError = false
});
#elif CORECLR
AmazonS3Util.DeleteS3BucketWithObjectsAsync(Client,
cmdletContext.BucketName,
new S3DeleteBucketWithObjectsOptions
{
ContinueOnError = false
}).Wait();
#else
#error "Unknown build edition"
#endif
}
else
{
var request = new DeleteBucketRequest {
BucketName = cmdletContext.BucketName
};
using (var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint))
{
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response,
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
}
}
return(output);
}
