Ejemplo n.º 1
0
 /// <summary>
 /// Add a KeyVersion object representing the S3 object to be deleted.
 /// </summary>
 /// <param name="keyVersion">KeyVersion representation of object to be deleted.</param>
 private void AddKey(KeyVersion keyVersion)
 {
     if (this.Objects == null)
     {
         this.Objects = new List <KeyVersion>();
     }
     this.Objects.Add(keyVersion);
 }
 /// <summary>
 /// Add a KeyVersion object representing the S3 object to be deleted.
 /// </summary>
 /// <param name="keyVersion">KeyVersion representation of object to be deleted.</param>
 private void AddKey(KeyVersion keyVersion)
 {
     if (this.Objects == null)
     {
         this.Objects = new List<KeyVersion>();
     }
     this.Objects.Add(keyVersion);
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Add a KeyVersion object representing the S3 object to be deleted.
 /// </summary>
 /// <param name="keyVersion">KeyVersion representation of object to be deleted.</param>
 public void AddKey(KeyVersion keyVersion)
 {
     if (this.keys == null)
     {
         this.keys = new List <KeyVersion>();
     }
     this.keys.Add(keyVersion);
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Add a KeyVersion object representing the S3 object to be deleted.
 /// </summary>
 /// <param name="keyVersion">KeyVersion representation of object to be deleted.</param>
 public void AddKey(KeyVersion keyVersion)
 {
     if (this.keys == null)
     {
         this.keys = new List<KeyVersion>();
     }
     this.keys.Add(keyVersion);
 }
Ejemplo n.º 5
0
        /// <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()
                                        .WithBucketName(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 KeyVersion[listVersionsResponse.Versions.Count];
                for (int index = 0; index < listVersionsResponse.Versions.Count; index++)
                {
                    keyVersionList[index] = new KeyVersion(
                                                listVersionsResponse.Versions[index].Key,
                                                listVersionsResponse.Versions[index].VersionId
                                            );
                }

                try
                {
                    // Delete the current set of objects.
                    var deleteObjectsResponse =
                        s3Client.DeleteObjects(new DeleteObjectsRequest()
                                            .WithBucketName(bucketName)
                                            .WithQuiet(deleteOptions.QuietMode)
                                            .WithKeys(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().WithBucketName(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();
        }
Ejemplo n.º 6
0
        /// <summary>
        /// delete directory
        /// </summary>
        /// <param name="path">path of directory</param>
        public void DeleteDirectory(string path)
        {
            var key = path.TrimStart('/') + "/";

            var listRequest = new ListObjectsRequest
            {
                BucketName = _bucket
            };

            var response = _client.ListObjects(listRequest);

            var objects = from x in response.S3Objects
                          where x.Key.StartsWith(key)
                          select x;

            var list = new List<KeyVersion>();

            foreach (var obj in objects)
            {
                var keyVersion = new KeyVersion(obj.Key);
                list.Add(keyVersion);
            }

            var request = new DeleteObjectsRequest
            {
                BucketName = "rwhitmire",
                Keys = list
            };

            _client.DeleteObjects(request);
        }