public static AmazonS3Client SetupBlob(string container, string path) { var request = new ListVersionsRequest { BucketName = container, Prefix = path }; var resp = _client.ListVersions(request); var toDelete = resp.Versions.Where(v => v.Key == path).Select(v => new KeyVersion { Key = v.Key, VersionId = v.VersionId }).ToList(); if (toDelete.Any()) { var delRequest = new DeleteObjectsRequest { BucketName = container, Objects = toDelete, Quiet = true }; _client.DeleteObjects(delRequest); } return _client; }
public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.S3.Model.ListVersionsRequest(); if (cmdletContext.BucketName != null) { request.BucketName = cmdletContext.BucketName; } if (cmdletContext.Delimiter != null) { request.Delimiter = cmdletContext.Delimiter; } if (cmdletContext.KeyMarker != null) { request.KeyMarker = cmdletContext.KeyMarker; } if (cmdletContext.MaxKey != null) { request.MaxKeys = cmdletContext.MaxKey.Value; } if (cmdletContext.Prefix != null) { request.Prefix = cmdletContext.Prefix; } if (cmdletContext.VersionIdMarker != null) { request.VersionIdMarker = cmdletContext.VersionIdMarker; } if (cmdletContext.Encoding != null) { request.Encoding = cmdletContext.Encoding; } CmdletOutput output; // issue call 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); }
/// <summary> /// <para>Returns metadata about all of the versions of objects in a bucket.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions service method on /// AmazonS3.</param> /// /// <returns>The response from the ListVersions service method, as returned by AmazonS3.</returns> public ListVersionsResponse ListVersions(ListVersionsRequest request) { var task = ListVersionsAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
private void DeleteObjectVersions(string key) { try { var versionsRequest = new ListVersionsRequest { BucketName = Utilities.MyConfig.BucketKey, Prefix = key }; var result = _amazons3.ListVersions(versionsRequest); foreach (S3ObjectVersion s3ObjectVersion in result.Versions) { try { var deleteObjectRequest = new Amazon.S3.Model.DeleteObjectRequest { BucketName = Utilities.MyConfig.BucketKey, Key = key, VersionId = s3ObjectVersion.VersionId }; _amazons3.DeleteObject(deleteObjectRequest); } catch (Exception) { // ToDo return; } } } catch (Exception) { // ToDo return; } }
private void SetAcltoObject(string key) { try { var versionsRequest = new ListVersionsRequest { BucketName = Utilities.MyConfig.BucketKey, Prefix = key }; var result = _amazons3.ListVersions(versionsRequest); foreach (S3ObjectVersion s3ObjectVersion in result.Versions) { if (!s3ObjectVersion.IsDeleteMarker) { try { // Get ACL. var getRequest = new GetACLRequest { BucketName = Utilities.MyConfig.BucketKey, Key = key, VersionId = s3ObjectVersion.VersionId }; GetACLResponse getResponse = _amazons3.GetACL(getRequest); if (getResponse.AccessControlList.Grants.Count < 2) { S3AccessControlList acl = getResponse.AccessControlList; getResponse.Dispose(); //acl.Grants.Clear(); //var grantee0 = new S3Grantee(); //grantee0.WithCanonicalUser(acl.Owner.Id, acl.Owner.DisplayName); //acl.AddGrant(grantee0, S3Permission.FULL_CONTROL); var grantee1 = new S3Grantee(); grantee1.WithURI("http://acs.amazonaws.com/groups/global/AllUsers"); acl.AddGrant(grantee1, S3Permission.READ); var request = new SetACLRequest { BucketName = Utilities.MyConfig.BucketKey, ACL = acl, Key = key, VersionId = s3ObjectVersion.VersionId }; SetACLResponse response = _amazons3.SetACL(request); response.Dispose(); } } catch (Exception) { // Todo return; } } } } catch (Exception) { return; } }
protected override void ProcessRecord() { AmazonS3 client = base.GetClient(); Amazon.S3.Model.ListVersionsRequest request = new Amazon.S3.Model.ListVersionsRequest(); request.BucketName = this._BucketName; request.Prefix = this._Prefix; request.KeyMarker = this._KeyMarker; request.VersionIdMarker = this._VersionIdMarker; request.MaxKeys = this._MaxKeys; request.Delimiter = this._Delimiter; Amazon.S3.Model.ListVersionsResponse response = client.ListVersions(request); }
public static bool CheckVersion(bool forceCheck) { // first check the last updated date _notification = new Notification(); _notification.SetMessage("Checking for updates"); try { if (forceCheck) { _notification.Show(); _notification.ShowForm(10); } if (forceCheck) { var amazons3 = AWSClientFactory.CreateAmazonS3Client(Utilities.AwsAccessKey, Utilities.AwsSecretKey, new AmazonS3Config { CommunicationProtocol = Protocol.HTTP }); var listVersionRequest = new ListVersionsRequest { BucketName = Utilities.AppRootBucketName, Prefix = "VersaVaultSyncTool_32Bit.exe" }; foreach (var s3ObjectVersion in amazons3.ListVersions(listVersionRequest).Versions) { if (s3ObjectVersion.IsLatest) { if (!string.IsNullOrEmpty(Utilities.MyConfig.InstallerVersionId) && Utilities.MyConfig.InstallerVersionId != s3ObjectVersion.VersionId) { while (Process.GetProcessesByName("VersaVaultSyncTool_32Bit").Length != 0) { Thread.Sleep(1000); Application.DoEvents(); } if (File.Exists(Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit_old.exe"))) File.Delete(Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit_old.exe")); if (File.Exists(Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit.exe"))) { File.Move(Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit.exe"), Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit_old.exe")); } var service = new S3Service { AccessKeyID = Utilities.AwsAccessKey, SecretAccessKey = Utilities.AwsSecretKey }; _notification.SetMessage("Started downloading update."); service.GetObjectProgress += ServiceGetObjectProgress; service.GetObject(Utilities.AppRootBucketName, s3ObjectVersion.Key, Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit.exe")); _notification.SetMessage("Updating VersaVault"); Utilities.MyConfig.InstallerVersionId = s3ObjectVersion.VersionId; Utilities.MyConfig.Save(); var startInfo = new ProcessStartInfo(Path.Combine(Path.GetTempPath(), "VersaVaultSyncTool_32Bit.exe")) { Verb = "runas" }; Process.Start(startInfo); Application.Exit(); return false; } Utilities.MyConfig.InstallerVersionId = s3ObjectVersion.VersionId; Utilities.MyConfig.Save(); break; } } listVersionRequest = new ListVersionsRequest { BucketName = Utilities.AppRootBucketName, Prefix = "VersaVaultSyncTool.exe" }; foreach (var s3ObjectVersion in amazons3.ListVersions(listVersionRequest).Versions) { if (s3ObjectVersion.IsLatest) { if (s3ObjectVersion.VersionId != null && s3ObjectVersion.VersionId != "null") { if (!string.IsNullOrEmpty(Utilities.MyConfig.VersionId) && Utilities.MyConfig.VersionId != s3ObjectVersion.VersionId) { _notification.Dispose(); Utilities.MyConfig.VersionId = s3ObjectVersion.VersionId; Utilities.MyConfig.Save(); var startInfo = new ProcessStartInfo(Path.Combine(Application.StartupPath, "VersaVaultUpdater.exe"), s3ObjectVersion.VersionId + " " + "update") { Verb = "runas" }; Process.Start(startInfo); Application.Exit(); return false; } Utilities.MyConfig.VersionId = s3ObjectVersion.VersionId; Utilities.MyConfig.Save(); return true; } // enable bucker versioning var setBucketVersioning = new SetBucketVersioningRequest { BucketName = Utilities.AppRootBucketName, VersioningConfig = new S3BucketVersioningConfig { Status = "Enabled" } }; amazons3.SetBucketVersioning(setBucketVersioning); break; } } return true; } } catch (Exception) { } finally { try { _notification.Controls["LblStatus"].Text = @"VersaVault is upto date."; _notification.HideForm(10); _notification.Close(); _notification.Dispose(); } catch (Exception) { } } return true; }
/// <summary> /// <para>Returns metadata about all of the versions of objects in a bucket.</para> /// </summary> /// /// <param name="listVersionsRequest">Container for the necessary parameters to execute the ListVersions service method on /// AmazonS3.</param> /// /// <returns>The response from the ListVersions service method, as returned by AmazonS3.</returns> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public async Task<ListVersionsResponse> ListVersionsAsync(ListVersionsRequest listVersionsRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, ListVersionsRequest, ListVersionsResponse>(listVersionsRequest, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// Paginator for ListVersions operation /// </summary> /// <param name="request"></param> /// <returns></returns> public IListVersionsPaginator ListVersions(ListVersionsRequest request) { return(new ListVersionsPaginator(this._client, request)); }
/// <summary> /// Initiates the asynchronous execution of the ListVersions operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions 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<ListVersionsResponse> ListVersionsAsync(ListVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.Instance; return InvokeAsync<ListVersionsRequest,ListVersionsResponse>(request, marshaller, unmarshaller, cancellationToken); }
IAsyncResult invokeListVersions(ListVersionsRequest listVersionsRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new ListVersionsRequestMarshaller().Marshall(listVersionsRequest); var unmarshaller = ListVersionsResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
/// <summary> /// <para>Returns metadata about all of the versions of objects in a bucket.</para> /// </summary> /// /// <param name="listVersionsRequest">Container for the necessary parameters to execute the ListVersions service method on /// AmazonS3.</param> /// /// <returns>The response from the ListVersions service method, as returned by AmazonS3.</returns> /// public ListVersionsResponse ListVersions(ListVersionsRequest listVersionsRequest) { IAsyncResult asyncResult = invokeListVersions(listVersionsRequest, null, null, true); return EndListVersions(asyncResult); }
/// <summary> /// Initiates the asynchronous execution of the ListVersions operation. /// <seealso cref="Amazon.S3.IAmazonS3.ListVersions"/> /// </summary> /// /// <param name="listVersionsRequest">Container for the necessary parameters to execute the ListVersions 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> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking /// EndListVersions operation.</returns> public IAsyncResult BeginListVersions(ListVersionsRequest listVersionsRequest, AsyncCallback callback, object state) { return invokeListVersions(listVersionsRequest, callback, state, false); }
/// <summary> /// Returns metadata about all of the versions of objects in a bucket. /// </summary> /// <param name="bucketName">A property of ListVersionsRequest used to execute the ListVersions service method.</param> /// <param name="prefix">Limits the response to keys that begin with the specified prefix.</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 ListVersions service method, as returned by S3.</returns> public void ListVersionsAsync(string bucketName, string prefix, AmazonServiceCallback<ListVersionsRequest, ListVersionsResponse> callback, AsyncOptions options = null) { var request = new ListVersionsRequest(); request.BucketName = bucketName; request.Prefix = prefix; ListVersionsAsync(request, callback, options); }
/// <summary> /// Initiates the asynchronous execution of the ListVersions operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions 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 ListVersionsAsync(ListVersionsRequest request, AmazonServiceCallback<ListVersionsRequest, ListVersionsResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<ListVersionsRequest,ListVersionsResponse> responseObject = new AmazonServiceResult<ListVersionsRequest,ListVersionsResponse>((ListVersionsRequest)req, (ListVersionsResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<ListVersionsRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
private Amazon.S3.Model.ListVersionsResponse CallAWSServiceOperation(IAmazonS3 client, Amazon.S3.Model.ListVersionsRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Storage Service (S3)", "ListVersions"); try { #if DESKTOP return(client.ListVersions(request)); #elif CORECLR return(client.ListVersionsAsync(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; } }
internal ListVersionsPaginator(IAmazonS3 client, ListVersionsRequest request) { this._client = client; this._request = request; }
/// <summary> /// Returns metadata about all of the versions of objects in a bucket. /// </summary> /// <param name="bucketName">A property of ListVersionsRequest used to execute the ListVersions service method.</param> /// <param name="prefix">Limits the response to keys that begin with the specified prefix.</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 ListVersions service method, as returned by S3.</returns> public Task<ListVersionsResponse> ListVersionsAsync(string bucketName, string prefix, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new ListVersionsRequest(); request.BucketName = bucketName; request.Prefix = prefix; return ListVersionsAsync(request, cancellationToken); }
/// <summary> /// Deletes an S3 bucket which contains objects. /// An S3 bucket which contains objects cannot be deleted until all the objects /// in it are deleted. The function deletes all the objects in the specified /// bucket and then deletes the bucket itself. /// </summary> /// <param name="bucketName">The bucket to be deleted.</param> /// <param name="s3Client">The Amazon S3 Client to use for S3 specific operations.</param> /// <param name="deleteOptions">Options to control the behavior of the delete operation.</param> /// <param name="updateCallback">The callback which is used to send updates about the delete operation.</param> /// <param name="asyncCancelableResult">An IAsyncCancelableResult that can be used to poll or wait for results, or both; /// this value is also needed when invoking EndDeleteS3BucketWithObjects. IAsyncCancelableResult can also /// be used to cancel the operation while it's in progress.</param> private static void DeleteS3BucketWithObjectsInternal(string bucketName, AmazonS3 s3Client, S3DeleteBucketWithObjectsOptions deleteOptions,Action<S3DeleteBucketWithObjectsUpdate> updateCallback, AsyncCancelableResult asyncCancelableResult) { // Validations. if (s3Client == null) { throw new ArgumentNullException("s3Client", "The s3Client cannot be null!"); } if (string.IsNullOrEmpty(bucketName)) { throw new ArgumentNullException("bucketName", "The bucketName cannot be null or empty string!"); } var listVersionsRequest = new ListVersionsRequest { BucketName=bucketName }; ListVersionsResponse listVersionsResponse; // Iterate through the objects in the bucket and delete them. do { // Check if the operation has been canceled. if (asyncCancelableResult.IsCancelRequested) { // Signal that the operation is canceled. asyncCancelableResult.SignalWaitHandleOnCanceled(); return; } // List all the versions of all the objects in the bucket. listVersionsResponse = s3Client.ListVersions(listVersionsRequest); if (listVersionsResponse.Versions.Count==0) { // If the bucket has no objects break the loop. break; } var keyVersionList = new List<KeyVersion>(listVersionsResponse.Versions.Count); for (int index = 0; index < listVersionsResponse.Versions.Count; index++) { keyVersionList.Add(new KeyVersion( listVersionsResponse.Versions[index].Key, listVersionsResponse.Versions[index].VersionId )); } try { // Delete the current set of objects. var deleteObjectsResponse = s3Client.DeleteObjects(new DeleteObjectsRequest { BucketName=bucketName, Quiet=deleteOptions.QuietMode, Keys=keyVersionList }); if (!deleteOptions.QuietMode) { // If quiet mode is not set, update the client with list of deleted objects. InvokeS3DeleteBucketWithObjectsUpdateCallback( updateCallback, new S3DeleteBucketWithObjectsUpdate { DeletedObjects = deleteObjectsResponse.DeletedObjects } ); } } catch (DeleteObjectsException deleteObjectsException) { if (deleteOptions.ContinueOnError) { // Continue the delete operation if an error was encountered. // Update the client with the list of objects that were deleted and the // list of objects on which the delete failed. InvokeS3DeleteBucketWithObjectsUpdateCallback( updateCallback, new S3DeleteBucketWithObjectsUpdate { DeletedObjects = deleteObjectsException.ErrorResponse.DeletedObjects, DeleteErrors = deleteObjectsException.ErrorResponse.DeleteErrors } ); } else { // Re-throw the exception if an error was encountered. throw; } } // Set the markers to get next set of objects from the bucket. listVersionsRequest.KeyMarker = listVersionsResponse.NextKeyMarker; listVersionsRequest.VersionIdMarker = listVersionsResponse.NextVersionIdMarker; } // Continue listing objects and deleting them until the bucket is empty. while (listVersionsResponse.IsTruncated); for (int attempts = 0; true; attempts++) { try { // Bucket is empty, delete the bucket. s3Client.DeleteBucket( new DeleteBucketRequest { BucketName = bucketName } ); break; } catch (AmazonS3Exception e) { if (!string.Equals(e.ErrorCode, S3Constants.BucketNotEmpty) || attempts >= 3) throw; Thread.Sleep(5 * 1000); } } // Signal that the operation is completed. asyncCancelableResult.SignalWaitHandleOnCompleted(); }
/// <summary> /// Initiates the asynchronous execution of the ListVersions operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions 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 EndListVersions /// operation.</returns> public IAsyncResult BeginListVersions(ListVersionsRequest request, AsyncCallback callback, object state) { var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.Instance; return BeginInvoke<ListVersionsRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Returns metadata about all of the versions of objects in a bucket. /// </summary> /// <param name="bucketName">A property of ListVersionsRequest used to execute the ListVersions service method.</param> /// <param name="prefix">Limits the response to keys that begin with the specified prefix.</param> /// /// <returns>The response from the ListVersions service method, as returned by S3.</returns> public ListVersionsResponse ListVersions(string bucketName, string prefix) { var request = new ListVersionsRequest(); request.BucketName = bucketName; request.Prefix = prefix; return ListVersions(request); }
private IAsyncEnumerable<S3ObjectVersion> ListObjects(string prefix) { return AsyncEnumerableEx.Create<S3ObjectVersion>(async y => { var request = new ListVersionsRequest { BucketName = _bucket, Prefix = prefix, KeyMarker = null, VersionIdMarker = null }; while (request != null && !y.CancellationToken.IsCancellationRequested) { var resp = await _client.ListVersionsAsync(request, y.CancellationToken).ConfigureAwait(false); foreach (var v in resp.Versions) { await y.YieldReturn(v).ConfigureAwait(false); } if (resp.IsTruncated) { request.KeyMarker = resp.NextKeyMarker; request.VersionIdMarker = resp.NextVersionIdMarker; } else { request = null; } } }); }
/// <summary> /// Initiates the asynchronous execution of the ListVersions operation. /// <seealso cref="Amazon.S3.IAmazonS3.ListVersions"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions 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<ListVersionsResponse> ListVersionsAsync(ListVersionsRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.GetInstance(); return Invoke<IRequest, ListVersionsRequest, ListVersionsResponse>(request, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// <para>Returns metadata about all of the versions of objects in a bucket.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListVersions service method on /// AmazonS3.</param> /// /// <returns>The response from the ListVersions service method, as returned by AmazonS3.</returns> public ListVersionsResponse ListVersions(ListVersionsRequest request) { var task = ListVersionsAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
internal ListVersionsResponse ListVersions(ListVersionsRequest request) { var marshaller = new ListVersionsRequestMarshaller(); var unmarshaller = ListVersionsResponseUnmarshaller.Instance; return Invoke<ListVersionsRequest,ListVersionsResponse>(request, marshaller, unmarshaller); }
public static void DeleteBucketWithObjects(IAmazonS3 s3Client, string bucketName) { // Validations. if (s3Client == null) { throw new ArgumentNullException("s3Client", "The s3Client cannot be null!"); } if (string.IsNullOrEmpty(bucketName)) { throw new ArgumentNullException("bucketName", "The bucketName cannot be null or empty string!"); } var listVersionsRequest = new ListVersionsRequest { BucketName = bucketName }; ListVersionsResponse listVersionsResponse = null; string lastRequestId = null; var exception = new Exception(); var mre = new AutoResetEvent(false); // Iterate through the objects in the bucket and delete them. do { // List all the versions of all the objects in the bucket. s3Client.ListVersionsAsync(listVersionsRequest, (result) => { exception = result.Exception; listVersionsResponse = result.Response; mre.Set(); }, new AsyncOptions() { ExecuteCallbackOnMainThread = false }); mre.WaitOne(); Utils.AssertExceptionIsNull(exception); lastRequestId = listVersionsResponse.ResponseMetadata.RequestId; if (listVersionsResponse.Versions.Count == 0) { // If the bucket has no objects break the loop. break; } var keyVersionList = new List<KeyVersion>(listVersionsResponse.Versions.Count); for (int index = 0; index < listVersionsResponse.Versions.Count; index++) { keyVersionList.Add(new KeyVersion { Key = listVersionsResponse.Versions[index].Key, VersionId = listVersionsResponse.Versions[index].VersionId }); } var deleteObjectsResponse = new DeleteObjectsResponse(); // Delete the current set of objects. s3Client.DeleteObjectsAsync(new DeleteObjectsRequest { BucketName = bucketName, Objects = keyVersionList, Quiet = true }, (result) => { deleteObjectsResponse = result.Response; exception = result.Exception; mre.Set(); }, new AsyncOptions() { ExecuteCallbackOnMainThread = false }); mre.WaitOne(); Utils.AssertExceptionIsNull(exception); // Set the markers to get next set of objects from the bucket. listVersionsRequest.KeyMarker = listVersionsResponse.NextKeyMarker; listVersionsRequest.VersionIdMarker = listVersionsResponse.NextVersionIdMarker; } // Continue listing objects and deleting them until the bucket is empty. while (listVersionsResponse.IsTruncated); // Bucket is empty, delete the bucket. s3Client.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName }, (result) => { exception = result.Exception; mre.Set(); }, new AsyncOptions() { ExecuteCallbackOnMainThread = false }); mre.WaitOne(); Utils.AssertExceptionIsNull(exception); }
/// <summary> /// Deletes an S3 bucket which contains objects. /// An S3 bucket which contains objects cannot be deleted until all the objects /// in it are deleted. The function deletes all the objects in the specified /// bucket and then deletes the bucket itself. /// </summary> /// <param name="bucketName">The bucket to be deleted.</param> /// <param name="s3Client">The Amazon S3 Client to use for S3 specific operations.</param> /// <param name="deleteOptions">Options to control the behavior of the delete operation.</param> /// <param name="updateCallback">The callback which is used to send updates about the delete operation.</param> /// <param name="token">token to check if the operation has been request to cancel.</param> private static async Task DeleteS3BucketWithObjectsInternalAsync(IAmazonS3 s3Client, string bucketName, S3DeleteBucketWithObjectsOptions deleteOptions, Action<S3DeleteBucketWithObjectsUpdate> updateCallback, CancellationToken token) { // Validations. if (s3Client == null) { throw new ArgumentNullException("s3Client", "The s3Client cannot be null!"); } if (string.IsNullOrEmpty(bucketName)) { throw new ArgumentNullException("bucketName", "The bucketName cannot be null or empty string!"); } var listVersionsRequest = new ListVersionsRequest { BucketName = bucketName }; ListVersionsResponse listVersionsResponse; // Iterate through the objects in the bucket and delete them. do { // Check if the operation has been canceled. if (token.IsCancellationRequested) { // Signal that the operation is canceled. return; } // List all the versions of all the objects in the bucket. listVersionsResponse = await s3Client.ListVersionsAsync(listVersionsRequest,token).ConfigureAwait(false); if (listVersionsResponse.Versions.Count == 0) { // If the bucket has no objects break the loop. break; } var keyVersionList = new List<KeyVersion>(listVersionsResponse.Versions.Count); for (int index = 0; index < listVersionsResponse.Versions.Count; index++) { keyVersionList.Add(new KeyVersion { Key = listVersionsResponse.Versions[index].Key, VersionId = listVersionsResponse.Versions[index].VersionId }); } try { // Delete the current set of objects. var deleteObjectsResponse = await s3Client.DeleteObjectsAsync(new DeleteObjectsRequest { BucketName = bucketName, Objects = keyVersionList, Quiet = deleteOptions.QuietMode },token).ConfigureAwait(false); if (!deleteOptions.QuietMode) { // If quiet mode is not set, update the client with list of deleted objects. InvokeS3DeleteBucketWithObjectsUpdateCallback( updateCallback, new S3DeleteBucketWithObjectsUpdate { DeletedObjects = deleteObjectsResponse.DeletedObjects } ); } } catch (DeleteObjectsException deleteObjectsException) { if (deleteOptions.ContinueOnError) { // Continue the delete operation if an error was encountered. // Update the client with the list of objects that were deleted and the // list of objects on which the delete failed. InvokeS3DeleteBucketWithObjectsUpdateCallback( updateCallback, new S3DeleteBucketWithObjectsUpdate { DeletedObjects = deleteObjectsException.Response.DeletedObjects, DeleteErrors = deleteObjectsException.Response.DeleteErrors } ); } else { // Re-throw the exception if an error was encountered. throw; } } // Set the markers to get next set of objects from the bucket. listVersionsRequest.KeyMarker = listVersionsResponse.NextKeyMarker; listVersionsRequest.VersionIdMarker = listVersionsResponse.NextVersionIdMarker; } // Continue listing objects and deleting them until the bucket is empty. while (listVersionsResponse.IsTruncated); const int maxRetries = 10; for (int retries = 1; retries <= maxRetries; retries++) { try { // Bucket is empty, delete the bucket. await s3Client.DeleteBucketAsync(new DeleteBucketRequest { BucketName = bucketName },token).ConfigureAwait(false); break; } catch (AmazonS3Exception e) { if (e.StatusCode != HttpStatusCode.Conflict || retries == maxRetries) throw; else DefaultRetryPolicy.WaitBeforeRetry(retries, 5000); } } }
public void ObjectSamples() { { #region ListObjects Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // List 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) { Console.WriteLine("Object - " + obj.Key); Console.WriteLine(" Size - " + obj.Size); Console.WriteLine(" LastModified - " + obj.LastModified); Console.WriteLine(" Storage class - " + obj.StorageClass); } // Set the marker property listRequest.Marker = listResponse.NextMarker; } while (listResponse.IsTruncated); #endregion } { #region GetObject Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a GetObject request GetObjectRequest request = new GetObjectRequest { BucketName = "SampleBucket", Key = "Item1" }; // Issue request and remember to dispose of the response using (GetObjectResponse response = client.GetObject(request)) { using (StreamReader reader = new StreamReader(response.ResponseStream)) { string contents = reader.ReadToEnd(); Console.WriteLine("Object - " + response.Key); Console.WriteLine(" Version Id - " + response.VersionId); Console.WriteLine(" Contents - " + contents); } } #endregion } { #region GetObjectMetadata Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a GetObjectMetadata request GetObjectMetadataRequest request = new GetObjectMetadataRequest { BucketName = "SampleBucket", Key = "Item1" }; // Issue request and view the response GetObjectMetadataResponse response = client.GetObjectMetadata(request); Console.WriteLine("Content Length - " + response.ContentLength); Console.WriteLine("Content Type - " + response.Headers.ContentType); if (response.Expiration != null) { Console.WriteLine("Expiration Date - " + response.Expiration.ExpiryDate); Console.WriteLine("Expiration Rule Id - " + response.Expiration.RuleId); } #endregion } { #region PutObject Sample 1 // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a PutObject request PutObjectRequest request = new PutObjectRequest { BucketName = "SampleBucket", Key = "Item1", ContentBody = "This is sample content..." }; // Put object PutObjectResponse response = client.PutObject(request); #endregion } { #region PutObject Sample 2 // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a PutObject request PutObjectRequest request = new PutObjectRequest { BucketName = "SampleBucket", Key = "Item1", FilePath = "contents.txt" }; // Put object PutObjectResponse response = client.PutObject(request); #endregion } { #region PutObject Sample 3 // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a PutObject request PutObjectRequest request = new PutObjectRequest { BucketName = "SampleBucket", Key = "Item1", }; using (FileStream stream = new FileStream("contents.txt", FileMode.Open)) { request.InputStream = stream; // Put object PutObjectResponse response = client.PutObject(request); } #endregion } { #region DeleteObject Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a DeleteObject request DeleteObjectRequest request = new DeleteObjectRequest { BucketName = "SampleBucket", Key = "Item1" }; // Issue request client.DeleteObject(request); #endregion } { #region DeleteObjects Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a DeleteObject request DeleteObjectsRequest request = new DeleteObjectsRequest { BucketName = "SampleBucket", Objects = new List<KeyVersion> { new KeyVersion() {Key = "Item1"}, // Versioned item new KeyVersion() { Key = "Item2", VersionId = "Rej8CiBxcZKVK81cLr39j27Y5FVXghDK", }, // Item in subdirectory new KeyVersion() { Key = "Logs/error.txt"} } }; try { // Issue request DeleteObjectsResponse response = client.DeleteObjects(request); } catch (DeleteObjectsException doe) { // Catch error and list error details DeleteObjectsResponse errorResponse = doe.Response; foreach (DeletedObject deletedObject in errorResponse.DeletedObjects) { Console.WriteLine("Deleted item " + deletedObject.Key); } foreach (DeleteError deleteError in errorResponse.DeleteErrors) { Console.WriteLine("Error deleting item " + deleteError.Key); Console.WriteLine(" Code - " + deleteError.Code); Console.WriteLine(" Message - " + deleteError.Message); } } #endregion } { #region CopyObject Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a CopyObject request CopyObjectRequest request = new CopyObjectRequest { SourceBucket = "SampleBucket", SourceKey = "Item1", DestinationBucket = "AnotherBucket", DestinationKey = "Copy1", CannedACL = S3CannedACL.PublicRead }; // Issue request client.CopyObject(request); #endregion } { #region CopyObject Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Create a CopyObject request CopyObjectRequest request = new CopyObjectRequest { SourceBucket = "SampleBucket", SourceKey = "Item1", DestinationBucket = "AnotherBucket", DestinationKey = "Copy1", CannedACL = S3CannedACL.PublicRead }; // Issue request client.CopyObject(request); #endregion } { #region ListVersions Sample // Create a client AmazonS3Client client = new AmazonS3Client(); // Turn versioning on for a bucket client.PutBucketVersioning(new PutBucketVersioningRequest { BucketName = "SampleBucket", VersioningConfig = new S3BucketVersioningConfig { Status = "Enable" } }); // Populate bucket with multiple items, each with multiple versions PopulateBucket(client, "SampleBucket"); // Get versions ListVersionsRequest request = new ListVersionsRequest { BucketName = "SampleBucket" }; // Make paged ListVersions calls ListVersionsResponse response; do { response = client.ListVersions(request); // View information about versions foreach (var version in response.Versions) { Console.WriteLine("Key = {0}, Version = {1}, IsLatest = {2}, LastModified = {3}, Size = {4}", version.Key, version.VersionId, version.IsLatest, version.LastModified, version.Size); } request.KeyMarker = response.NextKeyMarker; request.VersionIdMarker = response.NextVersionIdMarker; } while (response.IsTruncated); #endregion } { #region Multipart Upload Sample int MB = (int)Math.Pow(2, 20); // Create a client AmazonS3Client client = new AmazonS3Client(); // Define input stream Stream inputStream = Create13MBDataStream(); // Initiate multipart upload InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest { BucketName = "SampleBucket", Key = "Item1" }; InitiateMultipartUploadResponse initResponse = client.InitiateMultipartUpload(initRequest); // Upload part 1 UploadPartRequest uploadRequest = new UploadPartRequest { BucketName = "SampleBucket", Key = "Item1", UploadId = initResponse.UploadId, PartNumber = 1, PartSize = 5 * MB, InputStream = inputStream }; UploadPartResponse up1Response = client.UploadPart(uploadRequest); // Upload part 2 uploadRequest = new UploadPartRequest { BucketName = "SampleBucket", Key = "Item1", UploadId = initResponse.UploadId, PartNumber = 2, PartSize = 5 * MB, InputStream = inputStream }; UploadPartResponse up2Response = client.UploadPart(uploadRequest); // Upload part 3 uploadRequest = new UploadPartRequest { BucketName = "SampleBucket", Key = "Item1", UploadId = initResponse.UploadId, PartNumber = 3, InputStream = inputStream }; UploadPartResponse up3Response = client.UploadPart(uploadRequest); // List parts for current upload ListPartsRequest listPartRequest = new ListPartsRequest { BucketName = "SampleBucket", Key = "Item1", UploadId = initResponse.UploadId }; ListPartsResponse listPartResponse = client.ListParts(listPartRequest); Debug.Assert(listPartResponse.Parts.Count == 3); // Complete the multipart upload CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest { BucketName = "SampleBucket", Key = "Item1", UploadId = initResponse.UploadId, PartETags = new List<PartETag> { new PartETag { ETag = up1Response.ETag, PartNumber = 1 }, new PartETag { ETag = up2Response.ETag, PartNumber = 2 }, new PartETag { ETag = up3Response.ETag, PartNumber = 3 } } }; CompleteMultipartUploadResponse compResponse = client.CompleteMultipartUpload(compRequest); #endregion } }