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);
}
}
