public async Task <HttpStatusCode> DeleteObjectsAsync(string bucketName, IEnumerable <string> keys)
{
DeleteObjectsRequest request = new DeleteObjectsRequest()
{
BucketName = bucketName,
Quiet = true,
Objects = keys.Select(k => new KeyVersion()
{
Key = k
}).ToList()
};
var objs = await client.DeleteObjectsAsync(request);
return(objs.HttpStatusCode);
}
private async Task <Response <ResponseProperties> > DeleteFiles(RequestProperties properties)
{
LogInfo($"deleting package {properties.SourcePackageKey} from S3 bucket {properties.DestinationBucketName}");
// download package manifest
var entries = new List <string>();
var key = $"{properties.DestinationBucketName}/{properties.SourcePackageKey}";
await ProcessZipFileEntriesAsync(
_manifestBucket,
key,
async entry => {
using (var stream = entry.Open())
using (var reader = new StreamReader(stream)) {
var manifest = await reader.ReadToEndAsync();
entries.AddRange(manifest.Split('\n'));
}
}
);
LogInfo($"found {entries.Count:N0} files to delete");
// delete all files from manifest
while (entries.Any())
{
await _s3Client.DeleteObjectsAsync(new DeleteObjectsRequest {
BucketName = properties.DestinationBucketName,
Objects = entries.Take(MAX_BATCH_DELETE_OBJECTS).Select(entry => new KeyVersion {
Key = Path.Combine(properties.DestinationKeyPrefix, entry).Replace('\\', '/')
}).ToList()
});
entries = entries.Skip(MAX_BATCH_DELETE_OBJECTS).ToList();
}
// delete manifest file
try {
await _s3Client.DeleteObjectAsync(new DeleteObjectRequest {
BucketName = _manifestBucket,
Key = key
});
} catch {
LogWarn($"unable to delete manifest file at s3://{_manifestBucket}/{key}");
}
return(new Response <ResponseProperties>());
}
public async Task <Response <S3WriterResourceAttribute> > Delete(S3WriterResourceProperties properties)
{
if (properties.Enabled == false)
{
// don't do anything if disabled
return(new Response <S3WriterResourceAttribute>());
}
var bucketName = properties.BucketName;
_logger.LogInfo($"emptying bucket: {bucketName}");
// enumerate all S3 objects
var request = new ListObjectsV2Request {
BucketName = bucketName
};
var counter = 0;
var deletions = new List <Task>();
do
{
var response = await _s3Client.ListObjectsV2Async(request);
// delete any objects found
if (response.S3Objects.Any())
{
deletions.Add(_s3Client.DeleteObjectsAsync(new DeleteObjectsRequest {
BucketName = bucketName,
Objects = response.S3Objects.Select(s3 => new KeyVersion {
Key = s3.Key
}).ToList(),
Quiet = true
}));
counter += response.S3Objects.Count;
}
// continue until no more objects can be fetched
request.ContinuationToken = response.NextContinuationToken;
} while(request.ContinuationToken != null);
// wait for all deletions to complete
await Task.WhenAll(deletions);
_logger.LogInfo($"deleted {counter:N0} objects");
return(new Response <S3WriterResourceAttribute>());
}
public async Task DeleteContainerAsync(string containerName)
{
var objectsRequest =
new ListObjectsRequest {
BucketName = _bucket, Prefix = containerName, MaxKeys = 100000
};
var keys = new List <KeyVersion>();
try
{
do
{
var objectsResponse = await _s3Client.ListObjectsAsync(objectsRequest);
keys.AddRange(
objectsResponse.S3Objects.Select(x => new KeyVersion()
{
Key = x.Key, VersionId = null
}));
// If response is truncated, set the marker to get the next set of keys.
if (objectsResponse.IsTruncated)
{
objectsRequest.Marker = objectsResponse.NextMarker;
}
else
{
objectsRequest = null;
}
} while (objectsRequest != null);
if (keys.Count > 0)
{
var objectsDeleteRequest = new DeleteObjectsRequest()
{
BucketName = _bucket, Objects = keys
};
await _s3Client.DeleteObjectsAsync(objectsDeleteRequest);
}
}
catch (AmazonS3Exception asex)
{
throw asex.ToStorageException();
}
}
public async Task <DeleteFileResponse> DeleteFile(string bucketName, string fileName)
{
var multiObjectDeleteRequest = new DeleteObjectsRequest
{
BucketName = bucketName
};
multiObjectDeleteRequest.AddKey(fileName);
var response = await _s3Client.DeleteObjectsAsync(multiObjectDeleteRequest);
return(new DeleteFileResponse
{
NumerOfDeletedObjects = response.DeletedObjects.Count
});
}
private void DeleteImageFromS3Bucket(string key)
{
var keys = new System.Collections.Generic.List <KeyVersion>();
keys.Add(new KeyVersion {
Key = key
});
keys.Add(new KeyVersion {
Key = key + THUMBNAIL_SUFFIX
});
var request = new DeleteObjectsRequest {
BucketName = BUCKET_NAME,
Objects = keys
};
var response = _client.DeleteObjectsAsync(request);
}
private async Task RemoveFiles(string[] files)
{
var request = new DeleteObjectsRequest {
BucketName = _bucketName
};
request.Objects.AddRange(files.Select(f => new KeyVersion {
Key = f
}));
try
{
_ = await _s3Client.DeleteObjectsAsync(request, _cancellationToken).ConfigureAwait(false);
}
catch (DeleteObjectsException)
{
//suppress it, we are not interested at the moment why some files could not be removed (permissions or something else)
}
}
public async Task EmptyContainer(AmazonS3BlobContainer container)
{
var bucket = container?.Id;
if (string.IsNullOrWhiteSpace(bucket))
{
throw new ArgumentNullException(nameof(bucket));
}
try
{
_logger.LogInformation("Trying get objects from {@Bucket}", bucket);
var request = new ListObjectsV2Request {
BucketName = bucket, MaxKeys = int.MaxValue
};
var objectsResponse = await _client.ListObjectsV2Async(request).ConfigureAwait(false);
_logger.LogDebug("Got {@Count} object key(s) in {@Bucket}", objectsResponse?.KeyCount, bucket);
if (objectsResponse is null || objectsResponse.KeyCount == 0)
{
return;
}
var objectsToRemove = objectsResponse.S3Objects.Select(o => new KeyVersion {
Key = o.Key
}).ToList();
_logger.LogInformation("Trying delete {@Count} objects from {@Bucket}", objectsToRemove.Count, bucket);
var deleteRequest = new DeleteObjectsRequest {
BucketName = bucket, Objects = objectsToRemove
};
var deleteResponse = await _client.DeleteObjectsAsync(deleteRequest).ConfigureAwait(false);
_logger.LogInformation("Removed {@Count} objects from {@Bucket}", deleteResponse?.DeletedObjects.Count,
bucket);
}
catch (Exception ex)
{
_logger.LogError(ex, "Could not remove objects from bucket {@Bucket}", bucket);
throw new BlobStorageException($"Could not remove objects from bucket {bucket}", ex);
}
}
/// <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);
}
}
public async Task <ActionResult <MediaLinkModel> > Delete(Guid id)
{
MediaLinkModel model = await _context.MediaLinks.Include(x => x.Group).FirstOrDefaultAsync(x => x.Id == id);
if (model == null)
{
return(NotFound($"Image with Id {id} not found."));
}
string modelKey = $"{model.Group.NormalizedName}/{model.Name}";
string thumbnailKey = $"{Constants.ThumbnailGroup}/{modelKey}";
DeleteObjectsRequest request = new DeleteObjectsRequest
{
BucketName = _config["aws:bucket"],
Objects = new List <KeyVersion>()
{
new KeyVersion()
{
Key = modelKey
}, new KeyVersion()
{
Key = thumbnailKey
}
}
};
try
{
await _s3Client.DeleteObjectsAsync(request);
_context.MediaLinks.Remove(model);
await _context.SaveChangesAsync();
return(Ok(model));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> OnPostDeleteAllAsync()
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToPage("/Cognito", new { message = "You need to be logged in to delete all the images" }));
}
ListObjectsV2Response response;
List <S3Object> result = new List <S3Object>();
var request = new ListObjectsV2Request
{
BucketName = bucketName,
};
do
{
response = await s3.ListObjectsV2Async(request);
request.ContinuationToken = response.ContinuationToken;
result.AddRange(response.S3Objects);
}while (!string.IsNullOrEmpty(response.ContinuationToken));
if (result.Count > 0)
{
await s3.DeleteObjectsAsync(new DeleteObjectsRequest
{
BucketName = bucketName,
Quiet = true,
Objects = result.Select(obj => new KeyVersion
{
Key = obj.Key,
})
.ToList(),
});
}
return(RedirectToPage("./Index"));
}
public override async Task DeleteDeploymentAsync(FinalizerProperties current, CancellationToken cancellationToken)
{
LogInfo($"Deleting Deployment: {current.DeploymentChecksum}");
// enumerate all S3 objects
var request = new ListObjectsV2Request {
BucketName = _bucketName
};
var counter = 0;
var deletions = new List <Task>();
do
{
var response = await _s3Client.ListObjectsV2Async(request);
// delete any objects found
if (response.S3Objects.Any())
{
deletions.Add(_s3Client.DeleteObjectsAsync(new DeleteObjectsRequest {
BucketName = _bucketName,
Objects = response.S3Objects.Select(s3 => new KeyVersion {
Key = s3.Key
}).ToList(),
Quiet = true
}));
counter += response.S3Objects.Count;
}
// continue until no more objects can be fetched
request.ContinuationToken = response.NextContinuationToken;
} while(request.ContinuationToken != null);
// wait for all deletions to complete
await Task.WhenAll(deletions);
LogInfo($"Deleted {counter:N0} objects");
}
public bool Delete(string syncId)
{
try
{
var deleteObjectsRequest = new DeleteObjectsRequest
{
BucketName = _bucketName
};
var listObjectRequest = new ListObjectsRequest
{
BucketName = _bucketName,
Prefix = syncId
};
var listObjectResponse = _client.ListObjectsAsync(listObjectRequest).Result;
foreach (S3Object entry in listObjectResponse.S3Objects)
{
deleteObjectsRequest.AddKey(entry.Key);
}
var deleteObjectResponse = _client.DeleteObjectsAsync(deleteObjectsRequest).Result;
return(true);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when deleting an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when deleting an object", e.Message);
}
return(false);
}
/// <summary>
/// Deletes all the files in this directory as well as this directory. If recursive is set to true then all sub directories will be
/// deleted as well.
/// </summary>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <exception cref="T:Amazon.S3.Model.DeleteObjectsException"></exception>
/// <param name="recursive">If true then sub directories will be deleted as well.</param>
public void Delete(bool recursive)
{
if (String.IsNullOrEmpty(bucket))
{
throw new NotSupportedException();
}
if (recursive)
{
ListObjectsRequest listRequest = new ListObjectsRequest
{
BucketName = bucket,
Prefix = S3Helper.EncodeKey(this.key)
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)listRequest).AddBeforeRequestHandler(S3Helper.FileIORequestEventHandler);
DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest
{
BucketName = bucket
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)deleteRequest).AddBeforeRequestHandler(S3Helper.FileIORequestEventHandler);
ListObjectsResponse listResponse = null;
do
{
Task <ListObjectsResponse> t = s3Client.ListObjectsAsync(listRequest);
t.Wait();
listResponse = t.Result;
// Sort to make sure the Marker for paging is set to the last lexiographical key.
foreach (S3Object s3o in listResponse.S3Objects.OrderBy(x => x.Key))
{
deleteRequest.AddKey(s3o.Key);
if (deleteRequest.Objects.Count == MULTIPLE_OBJECT_DELETE_LIMIT)
{
s3Client.DeleteObjectsAsync(deleteRequest).Wait();
deleteRequest.Objects.Clear();
}
listRequest.Marker = s3o.Key;
}
} while (listResponse.IsTruncated);
if (deleteRequest.Objects.Count > 0)
{
s3Client.DeleteObjectsAsync(deleteRequest).Wait();
}
}
if (String.IsNullOrEmpty(key) && Exists)
{
var request = new DeleteBucketRequest {
BucketName = bucket
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)request).AddBeforeRequestHandler(S3Helper.FileIORequestEventHandler);
s3Client.DeleteBucketAsync(request).Wait();
WaitTillBucketS3StateIsConsistent(false);
}
else
{
if (!EnumerateFileSystemInfos().GetEnumerator().MoveNext() && Exists)
{
var request = new DeleteObjectRequest {
BucketName = bucket, Key = S3Helper.EncodeKey(key)
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)request).AddBeforeRequestHandler(S3Helper.FileIORequestEventHandler);
s3Client.DeleteObjectAsync(request).Wait();
Parent.Create();
}
}
}
public static DeleteObjectsResponse DeleteObjects(this IAmazonS3 client, DeleteObjectsRequest request)
{
return(client.DeleteObjectsAsync(request).GetResult());
}
private async static Task DeleteS3BucketWithObjectsAsync(IAmazonS3 s3Client, string bucketName,
CancellationToken cancellationToken = new CancellationToken())
{
// 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;
string lastRequestId = null;
// Iterate through the objects in the bucket and delete them.
do
{
// Check if the operation has been canceled.
cancellationToken.ThrowIfCancellationRequested();
// List all the versions of all the objects in the bucket.
listVersionsResponse = await s3Client.ListVersionsAsync(listVersionsRequest).ConfigureAwait(false);
// Silverlight uses HTTP caching, so avoid an infinite loop by throwing an exception
if (string.Equals(lastRequestId, listVersionsResponse.ResponseMetadata.RequestId, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException();
}
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
});
}
try
{
// Delete the current set of objects.
var deleteObjectsResponse = await s3Client.DeleteObjectsAsync(new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = keyVersionList,
Quiet = true
}).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;
//}
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
}).ConfigureAwait(false);
break;
}
catch (AmazonS3Exception e)
{
if (e.StatusCode != HttpStatusCode.Conflict || retries == maxRetries)
{
throw;
}
else
{
DefaultRetryPolicy.WaitBeforeRetry(retries, 5000);
}
}
}
//// Signal that the operation is completed.
//asyncCancelableResult.SignalWaitHandleOnCompleted();
}
public async Task <FunctionReturnDTO> DeleteThesis(int id, string professorId)
{
try
{
Thesis thesisToDelete = await _context.Theses
.Include(t => t.Professor)
.Where(t => t.Id == id)
.FirstOrDefaultAsync();
if (thesisToDelete == null)
{
return new FunctionReturnDTO {
Success = false, Result = "Thesis not found"
}
}
;
if (thesisToDelete.DateTaken != null)
{
_logger.LogInformation("Unathorized attempt to delete thesis " + thesisToDelete.Id + " by user " + professorId);
return(new FunctionReturnDTO {
Success = false, Result = "Unauthorised"
});
}
if (thesisToDelete.DateTaken != null)
{
_logger.LogInformation("Cannot delete taken thesis");
return(new FunctionReturnDTO {
Success = false, Result = "Thesis already taken"
});
}
DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest();
ListObjectsRequest listRequest = new ListObjectsRequest
{
BucketName = DependencyInjection.S3Bucket,
Prefix = "thesis/" + thesisToDelete.Id + "/"
};
ListObjectsResponse response = await _awsS3.ListObjectsAsync(listRequest);
if (response != null && response.S3Objects.Count > 0)
{
foreach (S3Object entry in response.S3Objects)
{
deleteRequest.AddKey(entry.Key);
}
deleteRequest.BucketName = DependencyInjection.S3Bucket;
DeleteObjectsResponse deleteResponse = await _awsS3.DeleteObjectsAsync(deleteRequest);
if (deleteResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
return new FunctionReturnDTO {
Success = false, Result = "Failed to delete images"
}
}
;
}
_context.Theses.Remove(thesisToDelete);
await _context.SaveChangesAsync();
return(new FunctionReturnDTO {
Success = true
});
}
catch (Exception ex)
{
_logger.LogInformation("Cannot delete thesis: " + ex.Message);
return(new FunctionReturnDTO {
Success = false, Result = ex.Message
});
}
}
/// <summary>
/// Performs a number of async copy object operations in parallel and then a smaller
/// number of delete operations after the copies complete
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <returns></returns>
private static async Task <BulkCopyResponse> MoveWithBulkDeleteAsync(this IAmazonS3 client, BulkMoveRequest request)
{
List <FailedCopyRequest> failures = new List <FailedCopyRequest>();
// This method checks for same source/destination problems and will throw an exception
BulkCopyResponse responses = await client.CoreBulkCopyAsync(request, false);
// Max keys in a request is 1000
// Make sure that we don't delete objects that
// were moved to that same location, this shouldn't
// happen because of the same logic in the copy operation
// but make sure
foreach (IEnumerable <KeyValuePair <CopyObjectRequest, CopyObjectResponse> > responseSet in
responses.SuccessfulOperations.Where(x => !(x.Key.SourceKey == x.Key.DestinationKey &&
x.Key.SourceBucket != null &&
x.Key.SourceBucket.Equals(x.Key.DestinationBucket, StringComparison.OrdinalIgnoreCase))).Chunk(1000))
{
DeleteObjectsRequest delete = new DeleteObjectsRequest()
{
BucketName = request.Requests.First().SourceBucket,
Objects = responseSet.Select(x => new KeyVersion()
{
Key = x.Key.SourceKey, VersionId = x.Key.SourceVersionId
}).ToList()
};
try
{
DeleteObjectsResponse response = await client.DeleteObjectsAsync(delete);
// Find the delete errors and create a new failed copy request
// object for each one
List <FailedCopyRequest> deleteFailures = response.DeleteErrors
.Select(x => new FailedCopyRequest(
responseSet.First(y => y.Key.SourceKey == x.Key).Key,
new AmazonS3Exception(x.Message)
{
ErrorCode = x.Code
},
FailureMode.DELETE)
).ToList();
// Remove any items that were successful in the copy
// but failed to delete from the successful responses
// list and indicate they failed during delete
foreach (FailedCopyRequest failure in deleteFailures)
{
responses.SuccessfulOperations.Remove(failure.Request);
}
foreach (FailedCopyRequest fail in deleteFailures)
{
responses.FailedRequests.Add(fail);
}
}
catch (Exception e)
{
// Remove all the copy responses from the success
// group and make them failures when an exception occurs
foreach (KeyValuePair <CopyObjectRequest, CopyObjectResponse> item in responseSet)
{
responses.SuccessfulOperations.Remove(item.Key);
responses.FailedRequests.Add(new FailedCopyRequest(item.Key, e, FailureMode.DELETE));
}
}
}
return(responses);
}
/// <summary>
/// Empties all contents of the specified bucket.
/// </summary>
/// <param name="client"></param>
/// <param name="bucketName">The name of the bucket to empty</param>
/// <param name="includeAllVersions">If true, in a bucket with versioning turned on, this will delete all versions of
/// the objects in the bukcet, not just add a delete marker as the most recent version.</param>
/// <returns></returns>
public static async Task <IEnumerable <DeleteError> > EmptyBucketAsync(this IAmazonS3 client, string bucketName, bool includeAllVersions = false)
{
ParameterTests.NotNullOrEmpty(bucketName, "bucketName");
DeleteObjectsRequest delete = new DeleteObjectsRequest()
{
BucketName = bucketName
};
List <DeleteError> errors = new List <DeleteError>();
if (includeAllVersions)
{
ListVersionsResponse response;
ListVersionsRequest request = new ListVersionsRequest()
{
BucketName = bucketName
};
do
{
response = await client.ListVersionsAsync(request);
request.KeyMarker = response.NextKeyMarker;
request.VersionIdMarker = response.VersionIdMarker;
delete.Objects = response.Versions.Select(x => new KeyVersion()
{
Key = x.Key, VersionId = x.VersionId
}).ToList();
DeleteObjectsResponse deleteResponse = await client.DeleteObjectsAsync(delete);
errors.AddRange(deleteResponse.DeleteErrors);
} while (response.IsTruncated);
}
else
{
ListObjectsV2Response response;
ListObjectsV2Request request = new ListObjectsV2Request()
{
BucketName = bucketName
};
do
{
response = await client.ListObjectsV2Async(request);
request.ContinuationToken = response.NextContinuationToken;
delete.Objects = response.S3Objects.Select(x => new KeyVersion()
{
Key = x.Key
}).ToList();
DeleteObjectsResponse deleteResponse = await client.DeleteObjectsAsync(delete);
errors.AddRange(deleteResponse.DeleteErrors);
} while (response.IsTruncated);
}
return(errors);
}
/// <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 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);
}
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);
}
public async Task <IActionResult> DeletePhoto(int userId, int id)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var user = await _repo.GetUser(userId, true);
if (!user.Photos.Any(p => p.Id == id))
{
return(Unauthorized());
}
var photoFromRepo = await _repo.GetPhoto(id);
if (photoFromRepo.IsMain)
{
return(BadRequest("You cannot delete your main photo."));
}
if (photoFromRepo.PublicId != null)
{
string fileNameS3 = photoFromRepo.Url.Split(@"/").Last();
string key = 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)
{
_repo.Delete(photoFromRepo);
}
else
{
return(BadRequest("Error on deleting photo."));
}
}
catch (DeleteObjectsException e)
{
return(BadRequest("Error on deleting photo. " + e.Message));
}
}
if (photoFromRepo.PublicId == null)
{
_repo.Delete(photoFromRepo);
}
if (await _repo.SaveAll())
{
return(Ok());
}
return(BadRequest("Error on deleting photo"));
}
/// <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 static Task RemoveMultipleFilesAsync(
IAmazonS3 client,
string bucketName,
IEnumerable <KeyVersion> objects,
CancellationToken token)
{
var request = new DeleteObjectsRequest
{
BucketName = bucketName,
Objects = objects.ToList(),
};
return(request.Objects.Count == 0
? TaskUtils.CompletedTask
: client.DeleteObjectsAsync(request, token));
}
