public async Task<IHttpActionResult> Delete() { var bucketRequest = new DeleteBucketRequest { BucketName = TestBucketName, BucketRegion = S3Region.EUC1 }; var request = new DeleteObjectsRequest { BucketName = TestBucketName, Objects = new List<KeyVersion> { new KeyVersion { Key = "test1.txt" }, new KeyVersion { Key = "test2.txt" }, new KeyVersion { Key = "test3.txt" }, new KeyVersion { Key = "test4.txt" }, new KeyVersion { Key = "test5.txt" }, new KeyVersion { Key = "test6.txt" }, new KeyVersion { Key = "test7.txt" }, new KeyVersion { Key = "test8.txt" }, new KeyVersion { Key = "test9.txt" }, new KeyVersion { Key = "test10.txt" } } }; await _client.DeleteObjectsAsync(request); await _client.DeleteBucketAsync(bucketRequest); return Ok(); }
public async Task <DeleteBucketResponse> DeleteBucketAsync(string name, CancellationToken cancellationToken = default) { this.Logger.LogDebug($"[{nameof(this.DeleteBucketAsync)}]"); this.Logger.LogTrace(JsonConvert.SerializeObject(new { name })); if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } var request = new Amazon.S3.Model.DeleteBucketRequest { BucketName = name, }; this.Logger.LogTrace(JsonConvert.SerializeObject(value: request)); var response = await this.Repository.DeleteBucketAsync(request : request, cancellationToken : cancellationToken == default?this.CancellationToken.Token : cancellationToken); this.Logger.LogTrace(JsonConvert.SerializeObject(value: response)); return(response); }
protected override void ProcessRecord() { AmazonS3 client = base.GetClient(); Amazon.S3.Model.DeleteBucketRequest request = new Amazon.S3.Model.DeleteBucketRequest(); request.BucketName = this._BucketName; Amazon.S3.Model.DeleteBucketResponse response = client.DeleteBucket(request); }
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); } } } }
/// <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 }; _amazonS3Client.DeleteBucket(request); }
public void DeleteBucket(string name) { try { var request = new DeleteBucketRequest { BucketName = name }; _s3Client.DeleteBucket(request); } catch (Exception e) { Console.WriteLine(e.Message); } }
/// <summary> /// Deletes all keys in a given bucket, then deletes the bucket itself. /// </summary> /// <param name="client">The client to use.</param> /// <param name="bucketName">The bucket to delete.</param> public static void DeleteBucketRecursive(this AmazonS3 client, string bucketName) { while(true) { // attempt to delete the bucket try { var deleteRequest = new DeleteBucketRequest() { BucketName = bucketName }; using (var deleteResponse = client.DeleteBucket(deleteRequest)) { // deletion was successful return; } } catch (AmazonS3Exception ex) { if (ex.ErrorCode != "BucketNotEmpty") throw ex; } var objRequest = new ListObjectsRequest() { BucketName = bucketName }; using (var objResponse = client.ListObjects(objRequest)) { var delRequest = new DeleteObjectsRequest() { BucketName = bucketName, Quiet = true }; // select the objects to delete (up to the supported limit of 1000) var objToDelete = objResponse.S3Objects.Take(1000).Select(o => new KeyVersion(o.Key)); delRequest.AddKeys(objToDelete.ToArray()); using (var delResponse = client.DeleteObjects(delRequest)) { } } } }
public virtual void DeleteBucket(AmazonS3Client s3Client, string bucketName) { // First, try to delete the bucket. var deleteBucketRequest = new DeleteBucketRequest { BucketName = bucketName }; try { s3Client.DeleteBucket(deleteBucketRequest); // If we get here, no error was generated so we'll assume the bucket was deleted and return. return; } catch (AmazonS3Exception ex) { if (!ex.ErrorCode.Equals("BucketNotEmpty")) { // We got an unanticipated error. Just rethrow. throw; } } // If we got here, then our bucket isn't empty so we need to delete the items in it first. DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest {BucketName = bucketName}; foreach (S3Object obj in s3Client.ListObjects(new ListObjectsRequest {BucketName = bucketName}).S3Objects) { // Add keys for the objects to the delete request deleteObjectsRequest.AddKey(obj.Key, null); } // Submit the request s3Client.DeleteObjects(deleteObjectsRequest); // The bucket is empty now, so delete the bucket. s3Client.DeleteBucket(deleteBucketRequest); }
private Amazon.S3.Model.DeleteBucketResponse CallAWSServiceOperation(IAmazonS3 client, Amazon.S3.Model.DeleteBucketRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon S3", "DeleteBucket"); try { #if DESKTOP return(client.DeleteBucket(request)); #elif CORECLR return(client.DeleteBucketAsync(request).GetAwaiter().GetResult()); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } }
/// <summary> /// Deletes the bucket. All objects (including all object versions and Delete Markers) /// in the bucket must be deleted before the bucket itself can be deleted. /// </summary> /// <param name="bucketName">A property of DeleteBucketRequest used to execute the DeleteBucket service method.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// /// <returns>The response from the DeleteBucket service method, as returned by S3.</returns> public Task<DeleteBucketResponse> DeleteBucketAsync(string bucketName, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeleteBucketRequest(); request.BucketName = bucketName; return DeleteBucketAsync(request, cancellationToken); }
/// <summary> /// Deletes the bucket. All objects (including all object versions and Delete Markers) /// in the bucket must be deleted before the bucket itself can be deleted. /// </summary> /// <param name="bucketName">A property of DeleteBucketRequest used to execute the DeleteBucket service method.</param> /// /// <returns>The response from the DeleteBucket service method, as returned by S3.</returns> public DeleteBucketResponse DeleteBucket(string bucketName) { var request = new DeleteBucketRequest(); request.BucketName = bucketName; return DeleteBucket(request); }
public void TearDown() { //A post-requisite for testing S3 objects. Ensure that all the Buckets and objects created are deleted before we exit the test-class. bool hasCallbackArrived = false; //B. Delete the destination object. hasCallbackArrived = false; S3ResponseEventHandler<object, ResponseEventArgs> deleteObjectHandler = null; deleteObjectHandler = delegate(object sender, ResponseEventArgs args) { IS3Response result = args.Response; _client.OnS3Response -= deleteObjectHandler; hasCallbackArrived = true; }; _client.OnS3Response += deleteObjectHandler; DeleteObjectRequest objectrequest = new DeleteObjectRequest { BucketName = _bucketNameDestination, Key = "key_UnitTesting_destination_1" }; _client.DeleteObject(objectrequest); EnqueueConditional(() => hasCallbackArrived); //A. Delete the normal bucket. S3ResponseEventHandler<object, ResponseEventArgs> handler = null; handler = delegate(object sender, ResponseEventArgs args) { IS3Response result = args.Response; if (result is DeleteBucketResponse) { //Unhook from event. _client.OnS3Response -= handler; hasCallbackArrived = true; } }; _client.OnS3Response += handler; DeleteBucketRequest request = new DeleteBucketRequest() { BucketName = _bucketName }; _client.DeleteBucket(request); EnqueueConditional(() => hasCallbackArrived); //Delete the destination Bucket hasCallbackArrived = false; S3ResponseEventHandler<object, ResponseEventArgs> deleteBucketHandler = null; deleteBucketHandler = delegate(object sender, ResponseEventArgs args) { IS3Response bucketResult = args.Response; if (bucketResult is DeleteBucketResponse) { //Unhook from event. _client.OnS3Response -= deleteBucketHandler; hasCallbackArrived = true; //Finally, set the client as null. _client = null; } }; _client.OnS3Response += deleteBucketHandler; DeleteBucketRequest deleteRequest = new DeleteBucketRequest() { BucketName = _bucketNameDestination }; _client.DeleteBucket(deleteRequest); EnqueueConditional(() => hasCallbackArrived); EnqueueTestComplete(); }
/// <summary> /// Deletes the container with the specified name. /// </summary> /// <param name="name">Name of the container to delete.</param> public void Delete(string name) { BlobContainerUtilities.EnsureValidContainerName(name); try { var request = new DeleteBucketRequest() { BucketName = name }; _client.DeleteBucket(request); } catch (AmazonS3Exception ex) { throw WrapException(ex); } }
IAsyncResult invokeDeleteBucket(DeleteBucketRequest deleteBucketRequest, AsyncCallback callback, object state, bool synchronized) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.GetInstance(); var result = Invoke(deleteBucketRequest, callback, state, synchronized, marshaller, unmarshaller, this.signer); return result; }
/// <summary> /// <para>Deletes the bucket. All objects (including all object versions and Delete Markers) in the bucket must be deleted before the bucket /// itself can be deleted.</para> /// </summary> /// /// <param name="deleteBucketRequest">Container for the necessary parameters to execute the DeleteBucket service method on AmazonS3.</param> /// public DeleteBucketResponse DeleteBucket(DeleteBucketRequest deleteBucketRequest) { IAsyncResult asyncResult = invokeDeleteBucket(deleteBucketRequest, null, null, true); return EndDeleteBucket(asyncResult); }
/// <summary> /// <para>Deletes the bucket. All objects (including all object versions and Delete Markers) in the bucket must be deleted before the bucket /// itself can be deleted.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket service method on AmazonS3.</param> public DeleteBucketResponse DeleteBucket(DeleteBucketRequest request) { var task = DeleteBucketAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
/// <summary> /// <para>Deletes the bucket. All objects (including all object versions and Delete Markers) in the bucket must be deleted before the bucket /// itself can be deleted.</para> /// </summary> /// /// <param name="deleteBucketRequest">Container for the necessary parameters to execute the DeleteBucket service method on AmazonS3.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public async Task<DeleteBucketResponse> DeleteBucketAsync(DeleteBucketRequest deleteBucketRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, DeleteBucketRequest, DeleteBucketResponse>(deleteBucketRequest, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// <para>Deletes the bucket. All objects (including all object versions and Delete Markers) in the bucket must be deleted before the bucket /// itself can be deleted.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket service method on AmazonS3.</param> public DeleteBucketResponse DeleteBucket(DeleteBucketRequest request) { var task = DeleteBucketAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
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); } }
public void DeleteAllBuckets() { ListBucketsResponse response = this.amazonS3Client.ListBuckets(); foreach (S3Bucket b in response.Buckets) { Console.WriteLine("{0}\t{1}", b.BucketName, b.CreationDate); ListObjectsRequest r = new ListObjectsRequest(); r.BucketName = b.BucketName; ListObjectsResponse resp = this.amazonS3Client.ListObjects(r); foreach (S3Object o in resp.S3Objects) { DeleteObjectRequest dr = new DeleteObjectRequest(); dr.BucketName = b.BucketName; dr.Key = o.Key; amazonS3Client.DeleteObject(dr); } DeleteBucketRequest request = new DeleteBucketRequest(); request.BucketName = b.BucketName; amazonS3Client.DeleteBucket(request); } }
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; } }
/// <summary> /// Deletes the bucket. All objects (including all object versions and Delete Markers) /// in the bucket must be deleted before the bucket itself can be deleted. /// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value of this configuration option is AWSConfigs.HttpClientOption.UnityWWW /// </summary> /// <param name="bucketName">A property of DeleteBucketRequest used to execute the DeleteBucket service method.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options"> /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// </param> /// /// <returns>The response from the DeleteBucket service method, as returned by S3.</returns> public void DeleteBucketAsync(string bucketName, AmazonServiceCallback<DeleteBucketRequest, DeleteBucketResponse> callback, AsyncOptions options = null) { var request = new DeleteBucketRequest(); request.BucketName = bucketName; DeleteBucketAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the DeleteBucket operation. /// This API is supported only when AWSConfigs.HttpClient is set to AWSConfigs.HttpClientOption.UnityWebRequest, the default value for this configuration option is AWSConfigs.HttpClientOption.UnityWWW /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket operation on AmazonS3Client.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void DeleteBucketAsync(DeleteBucketRequest request, AmazonServiceCallback<DeleteBucketRequest, DeleteBucketResponse> callback, AsyncOptions options = null) { if (AWSConfigs.HttpClient == AWSConfigs.HttpClientOption.UnityWWW) { throw new InvalidOperationException("DeleteBucket is only allowed with AWSConfigs.HttpClientOption.UnityWebRequest API option"); } options = options == null?new AsyncOptions():options; var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<DeleteBucketRequest,DeleteBucketResponse> responseObject = new AmazonServiceResult<DeleteBucketRequest,DeleteBucketResponse>((DeleteBucketRequest)req, (DeleteBucketResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<DeleteBucketRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Initiates the asynchronous execution of the DeleteBucket operation. /// <seealso cref="Amazon.S3.IAmazonS3.DeleteBucket"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<DeleteBucketResponse> DeleteBucketAsync(DeleteBucketRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.GetInstance(); return Invoke<IRequest, DeleteBucketRequest, DeleteBucketResponse>(request, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// Initiates the asynchronous execution of the DeleteBucket operation. /// <seealso cref="Amazon.S3.IAmazonS3.DeleteBucket"/> /// </summary> /// /// <param name="deleteBucketRequest">Container for the necessary parameters to execute the DeleteBucket operation on AmazonS3.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public IAsyncResult BeginDeleteBucket(DeleteBucketRequest deleteBucketRequest, AsyncCallback callback, object state) { return invokeDeleteBucket(deleteBucketRequest, callback, state, false); }
public void BucketSamples() { { #region ListBuckets Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Issue call ListBucketsResponse response = client.ListBuckets(); // View response data Console.WriteLine("Buckets owner - {0}", response.Owner.DisplayName); foreach (S3Bucket bucket in response.Buckets) { Console.WriteLine("Bucket {0}, Created on {1}", bucket.BucketName, bucket.CreationDate); } #endregion } { #region BucketPolicy Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Put sample bucket policy (overwrite an existing policy) string newPolicy = @"{ ""Statement"":[{ ""Sid"":""BasicPerms"", ""Effect"":""Allow"", ""Principal"": ""*"", ""Action"":[""s3:PutObject"",""s3:GetObject""], ""Resource"":[""arn:aws:s3:::samplebucketname/*""] }]}"; PutBucketPolicyRequest putRequest = new PutBucketPolicyRequest { BucketName = "SampleBucket", Policy = newPolicy }; client.PutBucketPolicy(putRequest); // Retrieve current policy GetBucketPolicyRequest getRequest = new GetBucketPolicyRequest { BucketName = "SampleBucket" }; string policy = client.GetBucketPolicy(getRequest).Policy; Console.WriteLine(policy); Debug.Assert(policy.Contains("BasicPerms")); // Delete current policy DeleteBucketPolicyRequest deleteRequest = new DeleteBucketPolicyRequest { BucketName = "SampleBucket" }; client.DeleteBucketPolicy(deleteRequest); // Retrieve current policy and verify that it is null policy = client.GetBucketPolicy(getRequest).Policy; Debug.Assert(policy == null); #endregion } { #region GetBucketLocation Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request GetBucketLocationRequest request = new GetBucketLocationRequest { BucketName = "SampleBucket" }; // Issue call GetBucketLocationResponse response = client.GetBucketLocation(request); // View response data Console.WriteLine("Bucket location - {0}", response.Location); #endregion } { #region PutBucket Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request PutBucketRequest request = new PutBucketRequest { BucketName = "SampleBucket", BucketRegion = S3Region.EU, // set region to EU CannedACL = S3CannedACL.PublicRead // make bucket publicly readable }; // Issue call PutBucketResponse response = client.PutBucket(request); #endregion } { #region DeleteBucket Sample 1 // Create a client AmazonS3Client client = new AmazonS3Client(); // Construct request DeleteBucketRequest request = new DeleteBucketRequest { BucketName = "SampleBucket" }; // Issue call DeleteBucketResponse response = client.DeleteBucket(request); #endregion } { #region DeleteBucket Sample 2 // Create a client AmazonS3Client client = new AmazonS3Client(); // List and delete all objects ListObjectsRequest listRequest = new ListObjectsRequest { BucketName = "SampleBucket" }; ListObjectsResponse listResponse; do { // Get a list of objects listResponse = client.ListObjects(listRequest); foreach (S3Object obj in listResponse.S3Objects) { // Delete each object client.DeleteObject(new DeleteObjectRequest { BucketName = "SampleBucket", Key = obj.Key }); } // Set the marker property listRequest.Marker = listResponse.NextMarker; } while (listResponse.IsTruncated); // Construct DeleteBucket request DeleteBucketRequest request = new DeleteBucketRequest { BucketName = "SampleBucket" }; // Issue call DeleteBucketResponse response = client.DeleteBucket(request); #endregion } { #region LifecycleConfiguration Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Put sample lifecycle configuration (overwrite an existing configuration) LifecycleConfiguration newConfiguration = new LifecycleConfiguration { Rules = new List<LifecycleRule> { // Rule to delete keys with prefix "Test-" after 5 days new LifecycleRule { Prefix = "Test-", Expiration = new LifecycleRuleExpiration { Days = 5 } }, // Rule to delete keys in subdirectory "Logs" after 2 days new LifecycleRule { Prefix = "Logs/", Expiration = new LifecycleRuleExpiration { Days = 2 }, Id = "log-file-removal" } } }; PutLifecycleConfigurationRequest putRequest = new PutLifecycleConfigurationRequest { BucketName = "SampleBucket", Configuration = newConfiguration }; client.PutLifecycleConfiguration(putRequest); // Retrieve current configuration GetLifecycleConfigurationRequest getRequest = new GetLifecycleConfigurationRequest { BucketName = "SampleBucket" }; LifecycleConfiguration configuration = client.GetLifecycleConfiguration(getRequest).Configuration; Console.WriteLine("Configuration contains {0} rules", configuration.Rules.Count); foreach (LifecycleRule rule in configuration.Rules) { Console.WriteLine("Rule"); Console.WriteLine(" Prefix = " + rule.Prefix); Console.WriteLine(" Expiration (days) = " + rule.Expiration.Days); Console.WriteLine(" Id = " + rule.Id); Console.WriteLine(" Status = " + rule.Status); } // Put a new configuration and overwrite the existing configuration configuration.Rules.RemoveAt(0); // remove first rule client.PutLifecycleConfiguration(putRequest); // Delete current configuration DeleteLifecycleConfigurationRequest deleteRequest = new DeleteLifecycleConfigurationRequest { BucketName = "SampleBucket" }; client.DeleteLifecycleConfiguration(deleteRequest); // Retrieve current configuration and verify that it is null configuration = client.GetLifecycleConfiguration(getRequest).Configuration; Debug.Assert(configuration == null); #endregion } }
internal DeleteBucketResponse DeleteBucket(DeleteBucketRequest request) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.Instance; return Invoke<DeleteBucketRequest,DeleteBucketResponse>(request, marshaller, unmarshaller); }
public void BucketK_DeleteBucketTest() { bool expectedValue = true; bool actualValue = false; bool hasCallbackArrived = false; S3ResponseEventHandler<object, ResponseEventArgs> handler = null; handler = delegate(object sender, ResponseEventArgs args) { IS3Response result = args.Response; //Unhook from event. _client.OnS3Response -= handler; DeleteBucketResponse response = result as DeleteBucketResponse; if (null != response) actualValue = response.IsRequestSuccessful; hasCallbackArrived = true; }; _client.OnS3Response += handler; DeleteBucketRequest request = new DeleteBucketRequest() { BucketName = _bucketNameForBucketAPIs }; _client.DeleteBucket(request); EnqueueConditional(() => hasCallbackArrived); EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue, string.Format("Expected Value = {0}, Actual Value = {1}", expectedValue, actualValue))); EnqueueTestComplete(); }
public void rmdir(string bucket) { try { DeleteBucketRequest deletebucketrequest = new DeleteBucketRequest(); deletebucketrequest.BucketName = bucket; s3Client.DeleteBucket(deletebucketrequest); Console.WriteLine("Bucket '" + bucket + "' has been deleted"); } catch ( Exception e ) { Console.WriteLine("Error deleting bucket '" + bucket + "': " + e.Message); } }
public void BucketK_DeleteBucketTest_ForException_EmptyBucketName() { string actualValue = string.Empty; string emptyBucketName = string.Empty; //Create request object. DeleteBucketRequest request = new DeleteBucketRequest { BucketName = emptyBucketName }; _client.DeleteBucket(request); EnqueueTestComplete(); }
/// <summary> /// Initiates the asynchronous execution of the DeleteBucket operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<DeleteBucketResponse> DeleteBucketAsync(DeleteBucketRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.Instance; return InvokeAsync<DeleteBucketRequest,DeleteBucketResponse>(request, marshaller, unmarshaller, cancellationToken); }
/// <summary> /// Initiates the asynchronous execution of the DeleteBucket operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteBucket operation on AmazonS3Client.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteBucket /// operation.</returns> public IAsyncResult BeginDeleteBucket(DeleteBucketRequest request, AsyncCallback callback, object state) { var marshaller = new DeleteBucketRequestMarshaller(); var unmarshaller = DeleteBucketResponseUnmarshaller.Instance; return BeginInvoke<DeleteBucketRequest>(request, marshaller, unmarshaller, callback, state); }