public async Task DeleteFilesAsync(string fullPathName) { var S3ListFiles = await ListFilesAsync(fullPathName); if (S3ListFiles.Count() > 0) { var keysAndVersions = await PutObjectsAsync(S3ListFiles); DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest { BucketName = BucketName, Objects = keysAndVersions // This includes the object keys and null version IDs. }; // You can add specific object key to the delete request using the .AddKey. // multiObjectDeleteRequest.AddKey("TickerReference.csv", null); try { DeleteObjectsResponse response = await _client.DeleteObjectsAsync(multiObjectDeleteRequest); _logger.LogInformation("Successfully deleted all the {0} items", response.DeletedObjects.Count); } catch (DeleteObjectsException e) { PrintDeletionErrorStatus(_logger, e); } } }
public async Task DeleteObjects() { List <S3DeleteInfo> resources = new List <S3DeleteInfo>(2); resources.Add(new S3DeleteInfo(nameof(DeleteObjects) + "1")); resources.Add(new S3DeleteInfo(nameof(DeleteObjects) + "2", "versionnotfound")); await UploadAsync(resources[0].Name).ConfigureAwait(false); await UploadAsync(resources[1].Name).ConfigureAwait(false); DeleteObjectsResponse resp = await ObjectClient.DeleteObjectsAsync(BucketName, resources, req => req.Quiet = false).ConfigureAwait(false); S3DeletedObject?delObj = Assert.Single(resp.Deleted); Assert.Equal(resources[0].Name, delObj.ObjectKey); Assert.True(delObj.IsDeleteMarker); Assert.NotEmpty(delObj.DeleteMarkerVersionId); S3DeleteError?errorObj = Assert.Single(resp.Errors); Assert.Equal(resources[1].Name, errorObj.ObjectKey); Assert.Equal(resources[1].VersionId, errorObj.VersionId); Assert.Equal(ErrorCode.NoSuchVersion, errorObj.Code); Assert.Equal("The specified version does not exist.", errorObj.Message); }
private static void UnmarshallResult(XmlUnmarshallerContext context, DeleteObjectsResponse response) { IWebResponseData responseData = context.get_ResponseData(); if (responseData.IsHeaderPresent(S3Constants.AmzHeaderRequestCharged)) { response.RequestCharged = RequestCharged.FindValue(responseData.GetHeaderValue(S3Constants.AmzHeaderRequestCharged)); } int currentDepth = context.get_CurrentDepth(); int num = currentDepth + 1; if (context.get_IsStartOfDocument()) { num += 2; } while (context.Read()) { if (context.get_IsStartElement() || context.get_IsAttribute()) { if (context.TestExpression("Deleted", num)) { response.DeletedObjects.Add(DeletedObjectUnmarshaller.Instance.Unmarshall(context)); } else if (context.TestExpression("Error", num)) { response.DeleteErrors.Add(ErrorsItemUnmarshaller.Instance.Unmarshall(context)); } } else if (context.get_IsEndElement() && context.get_CurrentDepth() < currentDepth) { break; } } }
/// <summary> /// オブジェクトストレージから、削除対象リストに登録された全てのデータを一括削除する。 /// keysは1件以上、1000件以下であること。 /// </summary> public async Task <bool> DeleteAsync(IEnumerable <string> keys) { var deleteObjectsRequest = new DeleteObjectsRequest() { BucketName = bucket }; foreach (var key in keys) { deleteObjectsRequest.AddKey(key); LogInformation($"deleted file: {key}"); } try { await client.DeleteObjectsAsync(deleteObjectsRequest); } catch (DeleteObjectsException ex) { LogError("failed to delete files", ex); DeleteObjectsResponse errorResponse = ex.Response; foreach (var item in errorResponse.DeletedObjects) { LogInformation($"deleted file: {item.Key}"); } LogWarning("Printing error data..."); foreach (DeleteError deleteError in errorResponse.DeleteErrors) { LogWarning("Object Key: {0}\t{1}\t{2}", deleteError.Key, deleteError.Code, deleteError.Message); } return(false); } return(true); }
static async Task MultiObjectDeleteAsync() { // Create sample objects (for subsequent deletion). var keysAndVersions = await PutObjectsAsync(3); // a. multi-object delete by specifying the key names and version IDs. DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest { BucketName = bucketName, Objects = keysAndVersions // This includes the object keys and null version IDs. }; // You can add specific object key to the delete request using the .AddKey. // multiObjectDeleteRequest.AddKey("TickerReference.csv", null); try { DeleteObjectsResponse response = await s3Client.DeleteObjectsAsync(multiObjectDeleteRequest); Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count); } catch (DeleteObjectsException e) { PrintDeletionErrorStatus(e); } }
/// <summary> /// This method uses the passed S3 client to first create and then /// delete three files from the named bucket. /// </summary> /// <param name="client">The initialized S3 client object used to call /// S3 methods.</param> /// <param name="bucketName">The name of the S3 bucket where objects /// will be created and then deleted.</param> public static async Task MultiObjectDeleteAsync(IAmazonS3 client, string bucketName) { // Create three sample objects which we will then delete. var keysAndVersions = await PutObjectsAsync(client, 3, bucketName); // Now perform the multi-object delete, passing the key names and // version IDs. Since we are working with a non-versioned bucket, // the object keys collection includes null version IDs. DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest { BucketName = bucketName, Objects = keysAndVersions, }; // You can add a specific object key to the delete request using the // AddKey method of the multiObjectDeleteRequest. try { DeleteObjectsResponse response = await client.DeleteObjectsAsync(multiObjectDeleteRequest); Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count); } catch (DeleteObjectsException e) { PrintDeletionErrorStatus(e); } }
public async Task DeleteObjects(S3Provider _, string bucket, ISimpleClient client) { S3DeleteInfo[] resources = new S3DeleteInfo[2]; resources[0] = new S3DeleteInfo(nameof(DeleteObjects) + "1"); resources[1] = new S3DeleteInfo(nameof(DeleteObjects) + "2", "versionnotfound"); PutObjectResponse putResp1 = await client.PutObjectAsync(bucket, resources[0].ObjectKey, null).ConfigureAwait(false); Assert.Equal(200, putResp1.StatusCode); PutObjectResponse putResp2 = await client.PutObjectAsync(bucket, resources[1].ObjectKey, null).ConfigureAwait(false); Assert.Equal(200, putResp2.StatusCode); DeleteObjectsResponse delResp = await client.DeleteObjectsAsync(bucket, resources, r => r.Quiet = false).ConfigureAwait(false); Assert.Equal(200, delResp.StatusCode); S3DeletedObject?delObj = Assert.Single(delResp.Deleted); Assert.Equal(resources[0].ObjectKey, delObj.ObjectKey); Assert.True(delObj.IsDeleteMarker); Assert.NotEmpty(delObj.DeleteMarkerVersionId); S3DeleteError?errorObj = Assert.Single(delResp.Errors); Assert.Equal(resources[1].ObjectKey, errorObj.ObjectKey); Assert.Equal(resources[1].VersionId, errorObj.VersionId); Assert.Equal(ErrorCode.NoSuchVersion, errorObj.Code); Assert.NotEmpty(errorObj.Message); }
private async Task DeleteFile(string bucketName, string folderName, string filename) { try { DeleteObjectsRequest request2 = new DeleteObjectsRequest(); ListObjectsRequest request = new ListObjectsRequest { BucketName = bucketName, Prefix = folderName + "/" + filename }; ListObjectsResponse response = await S3Client.ListObjectsAsync(request); // Process response. foreach (S3Object entry in response.S3Objects) { request2.AddKey(entry.Key); } request2.BucketName = bucketName; DeleteObjectsResponse response2 = await S3Client.DeleteObjectsAsync(request2); } catch (AmazonS3Exception e) { //Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { //Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } }
static void DeleteMultiple() { List <KeyVersion> versions = new List <KeyVersion>(); while (true) { string key = Common.InputString("Key [null to end]:", null, true); if (String.IsNullOrEmpty(key)) { break; } int ver = Common.InputInteger("Version:", 1, true, false); KeyVersion version = new KeyVersion(); version.Key = key; version.VersionId = ver.ToString(); versions.Add(version); } DeleteObjectsRequest request = new DeleteObjectsRequest(); request.BucketName = _Bucket; request.Objects = versions; DeleteObjectsResponse response = _S3Client.DeleteObjectsAsync(request).Result; int statusCode = (int)response.HttpStatusCode; if (response != null) { Console.WriteLine("Deleted objects:"); if (response.DeletedObjects != null && response.DeletedObjects.Count > 0) { foreach (DeletedObject curr in response.DeletedObjects) { Console.WriteLine(" " + curr.Key + " version " + curr.VersionId); } } else { Console.WriteLine(" (none)"); } Console.WriteLine("Errors:"); if (response.DeleteErrors != null && response.DeleteErrors.Count > 0) { foreach (DeleteError curr in response.DeleteErrors) { Console.WriteLine(" " + curr.Key + " version " + curr.VersionId); } } else { Console.WriteLine(" (none)"); } Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } }
public void TestSerializaingObjects() { DeleteObjectsResponse response = new DeleteObjectsResponse { DeletedObjects = new List <DeletedObject> { new DeletedObject { Key = "hello", VersionId = "version" }, new DeletedObject { Key = "world", VersionId = "version" }, new DeletedObject { Key = "!!!", VersionId = "version" } }, DeleteErrors = new List <DeleteError> { new DeleteError { Code = "200", Key = "key", Message = "Some Message!" }, new DeleteError { Code = "500", Key = "key", Message = "Some Message!" } }, RequestCharged = RequestCharged.Requester }; var serializer = new BinaryFormatter(); using (var ms = new MemoryStream()) { serializer.Serialize(ms, response); ms.Seek(0, SeekOrigin.Begin); DeleteObjectsResponse deserialized = serializer.Deserialize(ms) as DeleteObjectsResponse; List <string> deleteObjectKeys = new List <string> { "hello", "world", "!!!" }; // Validate deserialized dataa foreach (var obj in deserialized.DeletedObjects) { Assert.AreEqual(obj.VersionId, "version"); Assert.IsTrue(deleteObjectKeys.Contains(obj.Key)); } List <string> errorCodes = new List <string> { "200", "500" }; foreach (var error in deserialized.DeleteErrors) { Assert.AreEqual(error.Key, "key"); Assert.IsTrue(errorCodes.Contains(error.Code)); } Assert.AreEqual(deserialized.RequestCharged, RequestCharged.Requester); } }
private static string CreateMessage(DeleteObjectsResponse response) { if (response == null) { throw new ArgumentNullException("response"); } return(string.Format(CultureInfo.InvariantCulture, "Error deleting objects. Deleted objects: {0}. Delete errors: {1}", (response.DeletedObjects != null) ? response.DeletedObjects.Count : 0, (response.DeleteErrors != null) ? response.DeleteErrors.Count : 0)); }
/// <summary> /// Constructs a new instance of the DeleteObjectsException class with serialized data. /// </summary> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param> /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> parameter is null. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult" /> is zero (0). </exception> protected DeleteObjectsException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context) { if (info != null) { Response = info.GetValue("Response", typeof(DeleteObjectsResponse)) as DeleteObjectsResponse; } }
/// <summary>Delete all objects within the bucket</summary> public static async IAsyncEnumerable <S3DeleteError> DeleteAllObjectsAsync(this IObjectClient client, string bucketName, string?prefix = null, [EnumeratorCancellation] CancellationToken token = default) { Validator.RequireNotNull(client, nameof(client)); Validator.RequireNotNullOrEmpty(bucketName, nameof(bucketName)); ListObjectsResponse response; Task <ListObjectsResponse> responseTask = client.ListObjectsAsync(bucketName, req => req.Prefix = prefix, token); ObjectPool <S3DeleteInfo> pool = ObjectPool <S3DeleteInfo> .Shared; do { if (token.IsCancellationRequested) { yield break; } response = await responseTask; if (!response.IsSuccess) { throw new S3RequestException(response, $"Unable to list objects in bucket '{bucketName}"); } if (response.Objects.Count == 0) { yield break; } if (response.IsTruncated) { string localToken = response.NextContinuationToken; responseTask = client.ListObjectsAsync(bucketName, req => { req.Prefix = prefix; req.ContinuationToken = localToken; }, token); } IList <S3DeleteInfo> delete = response.Objects.Select(x => pool.Rent(info => info.Initialize(x.ObjectKey))).ToList(); DeleteObjectsResponse multiDelResponse = await client.DeleteObjectsAsync(bucketName, delete, req => req.Quiet = false, token).ConfigureAwait(false); pool.Return(delete); if (!multiDelResponse.IsSuccess) { throw new S3RequestException(response, $"Unable to delete objects in bucket '{bucketName}"); } foreach (S3DeleteError error in multiDelResponse.Errors) { yield return(error); } } while (response.IsTruncated); }
public async Task DeleteObjectsRequestPayer() { PutObjectResponse putResp2 = await ObjectClient.PutObjectAsync(BucketName, nameof(DeleteObjectsRequestPayer), null, req => req.RequestPayer = Payer.Requester).ConfigureAwait(false); Assert.True(putResp2.RequestCharged); DeleteObjectsResponse delResp2 = await ObjectClient.DeleteObjectsAsync(BucketName, new[] { nameof(DeleteObjectsRequestPayer) }, req => req.RequestPayer = Payer.Requester).ConfigureAwait(false); Assert.True(delResp2.RequestCharged); }
public async Task <IActionResult> RejectPhoto(int photoId) { var photo = await _context.Photos .IgnoreQueryFilters() .FirstOrDefaultAsync(p => p.Id == photoId); if (photo.IsMain) { return(BadRequest("You cannot reject the main photo")); } if (photo.PublicId != null) { string fileNameS3 = _context.Photos.FirstOrDefault(x => x.Id == photoId).Url.ToString().Split(@"/").Last(); string key = _context.Photos.FirstOrDefault(x => x.Id == photoId).UserId + @"/" + fileNameS3; ///Remove image from S3 DeleteObjectsRequest deleteObjectRequest = new DeleteObjectsRequest { BucketName = _awsConfig.Value.BucketName //Key = userId + @"/" + newFileNameS3, // This includes the object keys and null version IDs. }; // You can add specific object key to the delete request using the .AddKey. deleteObjectRequest.AddKey(key, null); try { DeleteObjectsResponse response = await client.DeleteObjectsAsync(deleteObjectRequest); // Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count); ///DELETE FROM DB if (response.HttpStatusCode == HttpStatusCode.OK) { _context.Photos.Remove(_context.Photos.FirstOrDefault(x => x.Id == photoId)); } else { return(BadRequest("Error on deleting photo.")); } } catch (DeleteObjectsException e) { return(BadRequest("Error on deleting photo. " + e.Message)); } } if (photo.PublicId == null) { _context.Photos.Remove(photo); } await _context.SaveChangesAsync(); return(Ok()); }
public static async IAsyncEnumerable <S3DeleteError> DeleteAllObjectVersionsAsync(this IObjectClient client, string bucketName, string?prefix = null, [EnumeratorCancellation] CancellationToken token = default) { Validator.RequireNotNull(client, nameof(client)); Validator.RequireNotNullOrEmpty(bucketName, nameof(bucketName)); ListObjectVersionsResponse response; Task <ListObjectVersionsResponse> responseTask = client.ListObjectVersionsAsync(bucketName, req => req.Prefix = prefix, token); do { if (token.IsCancellationRequested) { break; } response = await responseTask; if (!response.IsSuccess) { throw new S3RequestException(response, $"Unable to list objects in bucket '{bucketName}"); } if (response.Versions.Count + response.DeleteMarkers.Count == 0) { yield break; } if (response.IsTruncated) { string keyMarker = response.NextKeyMarker; responseTask = client.ListObjectVersionsAsync(bucketName, req => { req.Prefix = prefix; req.KeyMarker = keyMarker; }, token); } IEnumerable <S3DeleteInfo> delete = response.Versions.Select(x => new S3DeleteInfo(x.ObjectKey, x.VersionId)) .Concat(response.DeleteMarkers.Select(x => new S3DeleteInfo(x.ObjectKey, x.VersionId))); DeleteObjectsResponse multiDelResponse = await client.DeleteObjectsAsync(bucketName, delete, req => req.Quiet = false, token).ConfigureAwait(false); if (!multiDelResponse.IsSuccess) { throw new S3RequestException(response, $"Unable to delete objects in bucket '{bucketName}"); } foreach (S3DeleteError error in multiDelResponse.Errors) { yield return(error); } } while (response.IsTruncated); }
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context) { DeleteObjectsResponse deleteObjectsResponse = new DeleteObjectsResponse(); while (context.Read()) { if (context.get_IsStartElement()) { UnmarshallResult(context, deleteObjectsResponse); } } return(deleteObjectsResponse); }
/// <summary> /// Delete a list of existing entities /// </summary> /// <param name="entities">Entity list</param> /// <returns>Task</returns> public async Task DeleteManyAsync(IEnumerable <BlobInfo> entities) { DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(); multiObjectDeleteRequest.BucketName = bucketName; foreach (var entity in entities) { multiObjectDeleteRequest.AddKey(entity.Id, null); } DeleteObjectsResponse response = await s3client.DeleteObjectsAsync(multiObjectDeleteRequest); }
public async Task DeleteFolder(string folderName, int bucketChoice) { string bucketname = "moonshinephotostest"; string key = "photoAlbums/" + folderName + "/"; //List<KeyVersion> keys = new List<KeyVersion>(); //KeyVersion newKey = new KeyVersion(); //newKey.Key = key; //keys.Add(newKey); //switch (choice) { // case 0: // bucketname = BandImageBucketName; // break; // case 1: // bucketname = GalleryBucketName; // break; //} DeleteObjectsRequest request2 = new DeleteObjectsRequest(); ListObjectsRequest request = new ListObjectsRequest { BucketName = bucketname, Prefix = key }; ListObjectsResponse response = await _client.ListObjectsAsync(request); foreach (S3Object entry in response.S3Objects) { request2.AddKey(entry.Key); } request2.BucketName = bucketname; DeleteObjectsResponse response2 = await _client.DeleteObjectsAsync(request2); /* * try * { * DeleteObjectsResponse resp = await _client.DeleteObjectsAsync(request); * * Console.WriteLine("Deleted " + key + " Successfully!"); * } * catch (Exception e) * { * Console.WriteLine(e); * Console.WriteLine("Delete Failed!"); * } */ }
private static string CreateMessage(DeleteObjectsResponse response) { if (response == null) { throw new ArgumentNullException("response"); } string message = string.Format(CultureInfo.InvariantCulture, "Error deleting objects. Deleted objects: {0}. Delete errors: {1}", response.DeletedObjects == null ? 0 : response.DeletedObjects.Count, response.DeleteErrors == null ? 0 : response.DeleteErrors.Count); return(message); }
/// <summary> /// Prints the list of errors raised by the call to DeleteObjectsAsync. /// </summary> /// <param name="ex">A collection of exceptions returned by the call to /// DeleteObjectsAsync.</param> public static void PrintDeletionErrorStatus(DeleteObjectsException ex) { DeleteObjectsResponse errorResponse = ex.Response; Console.WriteLine("x {0}", errorResponse.DeletedObjects.Count); Console.WriteLine($"Successfully deleted {errorResponse.DeletedObjects.Count}."); Console.WriteLine($"No. of objects failed to delete = {errorResponse.DeleteErrors.Count}"); Console.WriteLine("Printing error data..."); foreach (DeleteError deleteError in errorResponse.DeleteErrors) { Console.WriteLine($"Object Key: {deleteError.Key}\t{deleteError.Code}\t{deleteError.Message}"); } }
private static void PrintDeletionErrorStatus(DeleteObjectsException e) { // var errorResponse = e.ErrorResponse; DeleteObjectsResponse errorResponse = e.Response; Console.WriteLine("x {0}", errorResponse.DeletedObjects.Count); Console.WriteLine("No. of objects successfully deleted = {0}", errorResponse.DeletedObjects.Count); Console.WriteLine("No. of objects failed to delete = {0}", errorResponse.DeleteErrors.Count); Console.WriteLine("Printing error data..."); foreach (DeleteError deleteError in errorResponse.DeleteErrors) { Console.WriteLine("Object Key: {0}\t{1}\t{2}", deleteError.Key, deleteError.Code, deleteError.Message); } }
public void Delete(IEnumerable <string> names) { if (names.Count() > 0) { DeleteObjectsRequest request = new DeleteObjectsRequest(); foreach (var name in names) { request.AddKey(name); } request.BucketName = BucketName; DeleteObjectsResponse response = _client.DeleteObjects(request); } }
/// <summary>Execute the NAnt task</summary> protected override void ExecuteTask() { // Ensure the configured bucket exists if (!BucketExists(BucketName)) { Project.Log(Level.Error, "[ERROR] S3 Bucket: {0}, not found!", BucketName); return; } deleteRequest.BucketName = BucketName; FindKeys(BucketName, deleteRequest, SearchString, Client); // Delete the file from S3 if (numKeys > 0) { if (String.IsNullOrEmpty(SearchString)) { SearchString = "NONE (all files will be deleted!)"; } using (Client) { try { DeleteObjectsResponse response = Client.DeleteObjects(deleteRequest); Project.Log(Level.Info, "Successfully deleted {0} files", response.DeletedObjects.Count); } catch (DeleteObjectsException ex) { ShowError(ex); } catch (AmazonS3Exception ex) { ShowError(ex); } catch (Exception ex) { Project.Log(Level.Error, "ERROR: " + ex.Message); } } } else { Project.Log(Level.Info, "Bucket contains no files with the specified search string: {0}", SearchString); } }
public CloudPlatformResponse DeleteBlobs(CloudPlatformRequest request) { var blobs = (IEnumerable <S3Object>)ListBlobs(request).Data; AmazonWebServiceResponse response = null; const int deleteLimit = 1000; if (blobs.Any()) { using (var client = new AmazonS3Client(new AmazonS3Config())) { try { var keys = blobs.Select(blob => new KeyVersion { Key = blob.Key }).ToList(); int num = keys.Count; do { Console.WriteLine("Deleting Blobs - Remaining: {0}", num); num -= (num < deleteLimit ? num : deleteLimit); var takenKeys = keys.Take(deleteLimit).ToList(); response = client.DeleteObjects(new DeleteObjectsRequest() { BucketName = request.Source, Objects = takenKeys }); keys = keys.Except(takenKeys).ToList(); } while (num > 0); } catch (DeleteObjectsException e) { DeleteObjectsResponse errorResponse = e.Response; foreach (DeleteError deleteError in errorResponse.DeleteErrors) { Console.WriteLine("Error deleting item " + deleteError.Key); Console.WriteLine(" Code - " + deleteError.Code); Console.WriteLine(" Message - " + deleteError.Message); } } } } return(AwsCloudPlatformResponse.PopulateFrom(response)); }
private static void UnmarshallResult(XmlUnmarshallerContext context, DeleteObjectsResponse response) { IWebResponseData responseData = context.ResponseData; if (responseData.IsHeaderPresent(S3Constants.AmzHeaderRequestCharged)) { response.RequestCharged = RequestCharged.FindValue(responseData.GetHeaderValue(S3Constants.AmzHeaderRequestCharged)); } int originalDepth = context.CurrentDepth; int targetDepth = originalDepth + 1; if (context.IsStartOfDocument) { targetDepth += 2; } while (context.Read()) { if (context.IsStartElement || context.IsAttribute) { if (context.TestExpression("Deleted", targetDepth)) { response.DeletedObjects.Add(DeletedObjectUnmarshaller.Instance.Unmarshall(context)); continue; } if (context.TestExpression("Error", targetDepth)) { response.DeleteErrors.Add(ErrorsItemUnmarshaller.Instance.Unmarshall(context)); continue; } } else if (context.IsEndElement && context.CurrentDepth < originalDepth) { return; } } return; }
/// <summary>Delete all objects within the bucket</summary> public static async Task <DeleteAllObjectsStatus> DeleteAllObjectsAsync(this IObjectClient client, string bucketName, CancellationToken token = default) { string continuationToken = null; ListObjectsResponse response; do { if (token.IsCancellationRequested) { break; } string cToken = continuationToken; response = await client.ListObjectsAsync(bucketName, req => req.ContinuationToken = cToken, token).ConfigureAwait(false); if (!response.IsSuccess) { return(DeleteAllObjectsStatus.RequestFailed); } if (response.KeyCount == 0) { break; } DeleteObjectsResponse multiDelResponse = await client.DeleteObjectsAsync(bucketName, response.Objects.Select(x => x.ObjectKey), req => req.Quiet = false, token).ConfigureAwait(false); if (!multiDelResponse.IsSuccess) { return(DeleteAllObjectsStatus.RequestFailed); } if (multiDelResponse.Errors.Count > 0) { return(DeleteAllObjectsStatus.ObjectDeleteFailed); } continuationToken = response.NextContinuationToken; } while (response.IsTruncated); return(DeleteAllObjectsStatus.Ok); }
/// <summary> /// Deletes all of the S3Objects in the provided folder asset. /// </summary> /// <param name="client">The client.</param> /// <param name="assetStorageProvider">The asset storage Provider.</param> /// <param name="asset">The asset.</param> /// <returns></returns> private bool MultipleObjectDelete(AmazonS3Client client, AssetStorageProvider assetStorageProvider, Asset asset) { // The list of keys that will be passed into the multiple delete request List <KeyVersion> keys = new List <KeyVersion>(); // Amazon only accepts 1000 keys per request, use this to keep track of how many already sent int keyIndex = 0; try { // Get a list of objest with prefix var assetDeleteList = ListObjects(assetStorageProvider, asset, true); // Create the list of keys foreach (var assetDelete in assetDeleteList) { keys.Add(new KeyVersion { Key = assetDelete.Key }); } while (keyIndex < keys.Count()) { int range = keys.Count() - keyIndex < 1000 ? keys.Count() - keyIndex : 1000; var deleteObjectsRequest = new DeleteObjectsRequest { BucketName = GetAttributeValue(assetStorageProvider, AttributeKeys.Bucket), Objects = keys.GetRange(keyIndex, range) }; DeleteObjectsResponse response = client.DeleteObjects(deleteObjectsRequest); keyIndex += range; } return(true); } catch (Exception ex) { ExceptionLogService.LogException(ex); throw; } }
private static void MultiObjectDelete(List <KeyVersion> keys) { // a. multi-object delete by specifying the key names and version IDs. DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest { BucketName = "takatanet-test-bucket", Objects = keys // This includes the object keys and null version IDs. }; multiObjectDeleteRequest.AddKey("AWSSDKcopy2.dll", null); try { DeleteObjectsResponse response = s3Client.DeleteObjects(multiObjectDeleteRequest); //Console.WriteLine("Successfully deleted all the {0} items", response.DeletedObjects.Count); } catch (DeleteObjectsException e) { //PrintDeletionReport(e); } }
/// <summary> /// Delete multiple objects from a version-enabled bucket. /// </summary> /// <param name="client">The initialized S3 client object used to call /// DeleteObjectVersionsAsync, DeleteObjectsAsync, and /// RemoveDeleteMarkersAsync.</param> /// <param name="bucketName">The name of the bucket from which to delete /// objects.</param> /// <param name="keys">A list of key names for the objects to delete.</param> static async Task VersionedDeleteAsync(IAmazonS3 client, string bucketName, List <KeyVersion> keys) { var multiObjectDeleteRequest = new DeleteObjectsRequest { BucketName = bucketName, Objects = keys, // This includes the object keys and specific version IDs. }; try { Console.WriteLine("Executing VersionedDelete..."); DeleteObjectsResponse response = await client.DeleteObjectsAsync(multiObjectDeleteRequest); Console.WriteLine($"Successfully deleted all the {response.DeletedObjects.Count} items"); } catch (DeleteObjectsException ex) { DisplayDeletionErrors(ex); } }