下面列出了怎么用com.amazonaws.services.s3.model.DeleteObjectsRequest的API类实例代码及写法，或者点击链接到github查看源代码。
public void delete(String bucketName, String pathPrefix) {
ObjectListing listing = null;
do {
listing = listing == null ? helper.client().listObjects(bucketName, pathPrefix) : helper.client().listNextBatchOfObjects(listing);
DeleteObjectsRequest req = new DeleteObjectsRequest(bucketName);
List<DeleteObjectsRequest.KeyVersion> keys = new ArrayList<>(listing.getObjectSummaries().size());
for (S3ObjectSummary summary : listing.getObjectSummaries()) {
keys.add(new DeleteObjectsRequest.KeyVersion(summary.getKey()));
}
req.withKeys(keys);
helper.client().deleteObjects(req);
} while (listing.isTruncated());
}
private static void deleteS3Objects(String s3BucketName, List<String> keys) {
AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
String[] keysArray = keys.toArray(new String[keys.size()]);
DeleteObjectsRequest request = new DeleteObjectsRequest(s3BucketName).withKeys(keysArray);
System.out.println("Deleting the following Amazon S3 objects created by Amazon Pinpoint:");
for (String key : keys) {
System.out.println("\t- " + key);
}
try {
s3Client.deleteObjects(request);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
System.out.println("Finished deleting objects.");
}
private static void uploadAndDeleteObjectsWithVersions() {
System.out.println("Uploading and deleting objects with versions specified.");
// Upload three sample objects.
ArrayList<KeyVersion> keys = new ArrayList<KeyVersion>();
for (int i = 0; i < 3; i++) {
String keyName = "delete object without version ID example " + i;
PutObjectResult putResult = S3_CLIENT.putObject(VERSIONED_BUCKET_NAME, keyName,
"Object number " + i + " to be deleted.");
// Gather the new object keys with version IDs.
keys.add(new KeyVersion(keyName, putResult.getVersionId()));
}
// Delete the specified versions of the sample objects.
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(VERSIONED_BUCKET_NAME)
.withKeys(keys)
.withQuiet(false);
// Verify that the object versions were successfully deleted.
DeleteObjectsResult delObjRes = S3_CLIENT.deleteObjects(multiObjectDeleteRequest);
int successfulDeletes = delObjRes.getDeletedObjects().size();
System.out.println(successfulDeletes + " objects successfully deleted");
}
private static DeleteObjectsResult uploadAndDeleteObjectsWithoutVersions() {
System.out.println("Uploading and deleting objects with no versions specified.");
// Upload three sample objects.
ArrayList<KeyVersion> keys = new ArrayList<KeyVersion>();
for (int i = 0; i < 3; i++) {
String keyName = "delete object with version ID example " + i;
S3_CLIENT.putObject(VERSIONED_BUCKET_NAME, keyName, "Object number " + i + " to be deleted.");
// Gather the new object keys without version IDs.
keys.add(new KeyVersion(keyName));
}
// Delete the sample objects without specifying versions.
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(VERSIONED_BUCKET_NAME).withKeys(keys)
.withQuiet(false);
// Verify that delete markers were successfully added to the objects.
DeleteObjectsResult delObjRes = S3_CLIENT.deleteObjects(multiObjectDeleteRequest);
int successfulDeletes = delObjRes.getDeletedObjects().size();
System.out.println(successfulDeletes + " objects successfully marked for deletion without versions.");
return delObjRes;
}
@Test
public void deleteThousandsOfObjectsInMultipleBuckets() throws IOException {
S3FileSystem s3FileSystem = buildMockedS3FileSystem(s3Options());
List<String> buckets = ImmutableList.of("bucket1", "bucket2");
List<String> keys = new ArrayList<>();
for (int i = 0; i < 2500; i++) {
keys.add(String.format("key-%d", i));
}
List<S3ResourceId> paths = new ArrayList<>();
for (String bucket : buckets) {
for (String key : keys) {
paths.add(S3ResourceId.fromComponents(bucket, key));
}
}
s3FileSystem.delete(paths);
// Should require 6 calls to delete 2500 objects in each of 2 buckets.
verify(s3FileSystem.getAmazonS3Client(), times(6))
.deleteObjects(any(DeleteObjectsRequest.class));
}
public static void s3DeleteRecursively(AmazonS3 s3, String bucket, String prefix)
throws Exception
{
ListObjectsRequest request = new ListObjectsRequest()
.withBucketName(bucket)
.withPrefix(prefix);
while (true) {
ObjectListing listing = s3.listObjects(request);
String[] keys = listing.getObjectSummaries().stream().map(S3ObjectSummary::getKey).toArray(String[]::new);
for (String key : keys) {
logger.info("delete s3://{}/{}", bucket, key);
}
retryExecutor()
.retryIf(e -> e instanceof AmazonServiceException)
.run(() -> s3.deleteObjects(new DeleteObjectsRequest(bucket).withKeys(keys)));
if (listing.getNextMarker() == null) {
break;
}
}
}
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("WARNING: This will indiscriminately delete every object in a given bucket. This operation cannot be undone.");
final String bucketName = prompt("Bucket");
if (!"yes".equals(prompt("Are you sure you want to delete all objects in bucket " + bucketName + "? (type 'yes' to continue)"))) {
System.out.println("Aborting...");
return;
}
final TruncateBucket truncater = new TruncateBucket(bucketName);
truncater.truncate();
ObjectListing results;
do {
results = s3.listObjects(bucketName);
final List<KeyVersion> keys = results.getObjectSummaries().stream()
.map((k) -> new KeyVersion(k.getKey()))
.collect(toList());
final DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest(bucketName).withKeys(keys);
s3.deleteObjects(deleteRequest);
} while (results.isTruncated());
}
@Test
public void testDeleteMultipleObjects() throws Exception {
String blobName = "foo";
ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentLength(BYTE_SOURCE.size());
DeleteObjectsRequest request = new DeleteObjectsRequest(containerName)
.withKeys(blobName);
// without quiet
client.putObject(containerName, blobName, BYTE_SOURCE.openStream(),
metadata);
DeleteObjectsResult result = client.deleteObjects(request);
assertThat(result.getDeletedObjects()).hasSize(1);
assertThat(result.getDeletedObjects().iterator().next().getKey())
.isEqualTo(blobName);
// with quiet
client.putObject(containerName, blobName, BYTE_SOURCE.openStream(),
metadata);
result = client.deleteObjects(request.withQuiet(true));
assertThat(result.getDeletedObjects()).isEmpty();
}
private void deleteObjects(AmazonS3 service, ObjectListing listing) throws MultiObjectDeleteException, IOException {
do {
if (Thread.currentThread().isInterrupted()) {
throw new IOException(FileOperationMessages.getString("IOperationHandler.interrupted")); //$NON-NLS-1$
}
List<S3ObjectSummary> objectSummaries = listing.getObjectSummaries();
if (!objectSummaries.isEmpty()) {
List<KeyVersion> keys = new ArrayList<KeyVersion>(objectSummaries.size());
for (S3ObjectSummary object: objectSummaries) {
keys.add(new KeyVersion(object.getKey()));
}
DeleteObjectsRequest request = new DeleteObjectsRequest(listing.getBucketName()).withKeys(keys).withQuiet(true);
service.deleteObjects(request); // quiet
}
listing = service.listNextBatchOfObjects(listing);
} while (listing.isTruncated());
}
private static void deleteByFullPathPrefix(ParameterTool params) {
final String bucket = params.getRequired("bucket");
final String s3prefix = params.getRequired("s3prefix");
String[] keys = listByFullPathPrefix(bucket, s3prefix).toArray(new String[] {});
if (keys.length > 0) {
DeleteObjectsRequest request = new DeleteObjectsRequest(bucket).withKeys(keys);
AmazonS3ClientBuilder.defaultClient().deleteObjects(request);
}
}
private static void deleteByFullPathPrefix(ParameterTool params) {
final String bucket = params.getRequired("bucket");
final String s3prefix = params.getRequired("s3prefix");
String[] keys = listByFullPathPrefix(bucket, s3prefix).toArray(new String[] {});
if (keys.length > 0) {
DeleteObjectsRequest request = new DeleteObjectsRequest(bucket).withKeys(keys);
AmazonS3ClientBuilder.defaultClient().deleteObjects(request);
}
}
/**
* Delete files.
*
* @param s3client the s 3 client
* @param s3Bucket the s 3 bucket
* @param folder the folder
*/
private void deleteFiles(AmazonS3 s3client,String s3Bucket,String folder){
String[] keys = listKeys(s3client,s3Bucket,folder);
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(s3Bucket).withKeys((keys));
try{
DeleteObjectsResult result = s3client.deleteObjects(multiObjectDeleteRequest);
log.debug("Files Deleted " +result.getDeletedObjects().stream().map(obj->obj.getKey()).collect(Collectors.toList()));
}catch(Exception e){
log.error("Delete Failed",e);
ErrorManageUtil.uploadError("all", "all", "all", e.getMessage());
}
}
/**
* Delete files.
*
* @param s3client the s 3 client
* @param s3Bucket the s 3 bucket
* @param folder the folder
*/
private void deleteFiles(AmazonS3 s3client,String s3Bucket,String folder){
String[] keys = listKeys(s3client,s3Bucket,folder);
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(s3Bucket).withKeys((keys));
try{
DeleteObjectsResult result = s3client.deleteObjects(multiObjectDeleteRequest);
log.debug("Files Deleted " +result.getDeletedObjects().stream().map(obj->obj.getKey()).collect(Collectors.toList()));
}catch(Exception e){
log.error("Delete Failed",e);
ErrorManageUtil.uploadError("all", "all", "all", e.getMessage());
}
}
@Override
public boolean delete(String path) {
log.info("Deleting all data at location: {}", path);
AmazonS3URI uri = toAmazonS3URI(URI.create(path));
String bucket = uri.getBucket();
List<KeyVersion> keysToDelete = getKeysToDelete(bucket, uri.getKey());
log.debug("Deleting keys: {}", keysToDelete.stream().map(k -> k.getKey()).collect(Collectors.toList()));
DeleteObjectsResult result = s3Client.deleteObjects(new DeleteObjectsRequest(bucket).withKeys(keysToDelete));
return successfulDeletion(result, keysToDelete.size());
}
@NotNull
private Integer deleteChunk(@NotNull final String pathPrefix,
@NotNull final String bucketName,
@NotNull final AmazonS3 client,
@NotNull final List<String> part,
@NotNull final Supplier<String> info) throws Exception {
final List<DeleteObjectsRequest.KeyVersion> objectKeys = part.stream().map(path -> new DeleteObjectsRequest.KeyVersion(pathPrefix + path)).collect(Collectors.toList());
final DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName).withKeys(objectKeys);
return executeWithNewThreadName(info.get(),
() -> doUnderContextClassLoader(S3Util.class.getClassLoader(), () -> client.deleteObjects(deleteObjectsRequest).getDeletedObjects().size()));
}
private static void multiObjectVersionedDeleteRemoveDeleteMarkers(DeleteObjectsResult response) {
List<KeyVersion> keyList = new ArrayList<KeyVersion>();
for (DeletedObject deletedObject : response.getDeletedObjects()) {
// Note that the specified version ID is the version ID for the delete marker.
keyList.add(new KeyVersion(deletedObject.getKey(), deletedObject.getDeleteMarkerVersionId()));
}
// Create a request to delete the delete markers.
DeleteObjectsRequest deleteRequest = new DeleteObjectsRequest(VERSIONED_BUCKET_NAME).withKeys(keyList);
// Delete the delete markers, leaving the objects intact in the bucket.
DeleteObjectsResult delObjRes = S3_CLIENT.deleteObjects(deleteRequest);
int successfulDeletes = delObjRes.getDeletedObjects().size();
System.out.println(successfulDeletes + " delete markers successfully deleted");
}
public static void main(String[] args) {
final String USAGE = "\n" +
"To run this example, supply the name of an S3 bucket and at least\n" +
"one object name (key) to delete.\n" +
"\n" +
"Ex: DeleteObjects <bucketname> <objectname1> [objectname2, ...]\n";
if (args.length < 2) {
System.out.println(USAGE);
System.exit(1);
}
String bucket_name = args[0];
String[] object_keys = Arrays.copyOfRange(args, 1, args.length);
System.out.println("Deleting objects from S3 bucket: " + bucket_name);
for (String k : object_keys) {
System.out.println(" * " + k);
}
final AmazonS3 s3 = AmazonS3ClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
try {
DeleteObjectsRequest dor = new DeleteObjectsRequest(bucket_name)
.withKeys(object_keys);
s3.deleteObjects(dor);
} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
System.out.println("Done!");
}
private void delete(String bucket, Collection<String> keys) throws IOException {
checkArgument(
keys.size() <= MAX_DELETE_OBJECTS_PER_REQUEST,
"only %s keys can be deleted per request, but got %s",
MAX_DELETE_OBJECTS_PER_REQUEST,
keys.size());
List<KeyVersion> deleteKeyVersions =
keys.stream().map(KeyVersion::new).collect(Collectors.toList());
DeleteObjectsRequest request = new DeleteObjectsRequest(bucket).withKeys(deleteKeyVersions);
try {
amazonS3.get().deleteObjects(request);
} catch (AmazonClientException e) {
throw new IOException(e);
}
}
@Override
public void deleteFileList(final S3FileTransferRequestParamsDto params)
{
LOGGER.info("Deleting a list of objects from S3... s3BucketName=\"{}\" s3KeyCount={}", params.getS3BucketName(), params.getFiles().size());
try
{
// In order to avoid a MalformedXML AWS exception, we send delete request only when we have any keys to delete.
if (!params.getFiles().isEmpty())
{
// Create an S3 client.
AmazonS3Client s3Client = getAmazonS3(params);
try
{
// Build a list of keys to be deleted.
List<DeleteObjectsRequest.KeyVersion> keys = new ArrayList<>();
for (File file : params.getFiles())
{
keys.add(new DeleteObjectsRequest.KeyVersion(file.getPath().replaceAll("\\\\", "/")));
}
// Delete the keys.
deleteKeyVersions(s3Client, params.getS3BucketName(), keys);
}
finally
{
s3Client.shutdown();
}
}
}
catch (Exception e)
{
throw new IllegalStateException(
String.format("Failed to delete a list of keys from bucket \"%s\". Reason: %s", params.getS3BucketName(), e.getMessage()), e);
}
}
/**
* Deletes a list of keys/key versions from the specified S3 bucket.
*
* @param s3Client the S3 client
* @param s3BucketName the S3 bucket name
* @param keyVersions the list of S3 keys/key versions
*/
private void deleteKeyVersions(AmazonS3Client s3Client, String s3BucketName, List<DeleteObjectsRequest.KeyVersion> keyVersions)
{
// Create a request to delete multiple objects in the specified bucket.
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(s3BucketName);
// The Multi-Object Delete request can contain a list of up to 1000 keys.
for (int i = 0; i < keyVersions.size() / MAX_KEYS_PER_DELETE_REQUEST + 1; i++)
{
List<DeleteObjectsRequest.KeyVersion> keysSubList =
keyVersions.subList(i * MAX_KEYS_PER_DELETE_REQUEST, Math.min(keyVersions.size(), (i + 1) * MAX_KEYS_PER_DELETE_REQUEST));
multiObjectDeleteRequest.setKeys(keysSubList);
try
{
s3Operations.deleteObjects(multiObjectDeleteRequest, s3Client);
}
catch (MultiObjectDeleteException multiObjectDeleteException)
{
logMultiObjectDeleteException(multiObjectDeleteException);
throw multiObjectDeleteException;
}
LOGGER.info("Successfully requested the deletion of the listed below keys/key versions from the S3 bucket. s3KeyCount={} s3BucketName=\"{}\"",
keysSubList.size(), s3BucketName);
for (DeleteObjectsRequest.KeyVersion keyVersion : keysSubList)
{
LOGGER.info("s3Key=\"{}\" s3VersionId=\"{}\"", keyVersion.getKey(), keyVersion.getVersion());
}
}
}
@Override
public DeleteObjectsResult deleteObjects(DeleteObjectsRequest deleteObjectsRequest, AmazonS3 s3Client)
{
LOGGER.debug("deleteObjects(): deleteObjectRequest.getBucketName() = " + deleteObjectsRequest.getBucketName() + ", deleteObjectRequest.getKeys() = " +
deleteObjectsRequest.getKeys());
List<DeletedObject> deletedObjects = new ArrayList<>();
MockS3Bucket mockS3Bucket = mockS3Buckets.get(deleteObjectsRequest.getBucketName());
for (KeyVersion keyVersion : deleteObjectsRequest.getKeys())
{
String s3ObjectKey = keyVersion.getKey();
String s3ObjectVersion = keyVersion.getVersion();
String s3ObjectKeyVersion = s3ObjectKey + (s3ObjectVersion != null ? s3ObjectVersion : "");
mockS3Bucket.getObjects().remove(s3ObjectKey);
if (mockS3Bucket.getVersions().remove(s3ObjectKeyVersion) != null)
{
DeletedObject deletedObject = new DeletedObject();
deletedObject.setKey(s3ObjectKey);
deletedObject.setVersionId(s3ObjectVersion);
deletedObjects.add(deletedObject);
}
}
return new DeleteObjectsResult(deletedObjects);
}
/**
* Method delete all <i>objects</i> from <i>bucketName</i> in groups by 1000
* elements
*
* @param bucketName
* @param objects
*/
public void delete(String bucketName, List<KeyVersion> objects) {
ReactiveSeq.fromList(objects)
.grouped(1000)
.forEach(l -> {
DeleteObjectsRequest req = new DeleteObjectsRequest(bucketName);
req.setKeys(l.toList());
client.deleteObjects(req);
});
}
@Test
public void testDeleteMultipleObjectsEmpty() throws Exception {
DeleteObjectsRequest request = new DeleteObjectsRequest(containerName)
.withKeys();
try {
client.deleteObjects(request);
Fail.failBecauseExceptionWasNotThrown(AmazonS3Exception.class);
} catch (AmazonS3Exception e) {
assertThat(e.getErrorCode()).isEqualTo("MalformedXML");
}
}
@Test
public void whenVerifyingDeleteObjects_thenCorrect() {
DeleteObjectsRequest request = mock(DeleteObjectsRequest.class);
DeleteObjectsResult result = mock(DeleteObjectsResult.class);
when(s3.deleteObjects((DeleteObjectsRequest)any())).thenReturn(result);
assertThat(service.deleteObjects(request)).isEqualTo(result);
verify(s3).deleteObjects(request);
}
@Override
public DeleteObjectsResult deleteObjects(DeleteObjectsRequest request) throws SdkClientException {
assertThat(request.getBucketName(), equalTo(bucket));
final List<DeleteObjectsResult.DeletedObject> deletions = new ArrayList<>();
for (DeleteObjectsRequest.KeyVersion key : request.getKeys()) {
if (blobs.remove(key.getKey()) != null) {
DeleteObjectsResult.DeletedObject deletion = new DeleteObjectsResult.DeletedObject();
deletion.setKey(key.getKey());
deletions.add(deletion);
}
}
return new DeleteObjectsResult(deletions);
}
/**
* Delete all objects matching given prefix. This method is preferred for efficient deletion of many files
*
* @param folderPrefix empty path is expected for objects in the "root" of the bucket
* @param searchString what pattern to be matched. This pattern will be matched against "short file name", i.e.
* the object's ID after last path separator ("/").<br />
* If null it means all ( string ".*").
* @param recursive if true searches recursively for matching in nested path levels ("/")
*
* @return list of deleted objects
* @throws S3OperationException in case of an error from server
*/
@PublicAtsApi
public void deleteObjects( String folderPrefix, String searchString, boolean recursive ) {
//Alternative but not documented in S3 API: getClient().listObjectsV2(bucket, "prefix")
ListObjectsRequest request = new ListObjectsRequest(bucketName, folderPrefix, null, recursive
? null
: "/",
null);
int totallyDeleted = 0;
try {
ObjectListing objectListing = s3Client.listObjects(request);
int i = 0;
if (searchString == null) {
searchString = ".*"; // any string
}
List<KeyVersion> keysForDelete = new ArrayList<KeyVersion>(100);
Pattern searchStringPattern = Pattern.compile(searchString);
while (true) {
keysForDelete.clear();
for (Iterator<?> iterator = objectListing.getObjectSummaries().iterator(); iterator.hasNext();) {
S3ObjectSummary objectSummary = (S3ObjectSummary) iterator.next();
if (LOG.isTraceEnabled()) {
LOG.trace("listObject[" + (++i) + "]: " + objectSummary.toString());
}
String[] fileTokens = objectSummary.getKey().split("/");
String s3Object = fileTokens[fileTokens.length - 1];
Matcher matcher = searchStringPattern.matcher(s3Object);
if (matcher.find()) {
keysForDelete.add(new KeyVersion(objectSummary.getKey()));
//allListElements.add(new S3ObjectInfo(objectSummary));
}
}
if (keysForDelete.size() > 0) {
// delete current set / batch size
DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(bucketName).withKeys(keysForDelete)
.withQuiet(false);
DeleteObjectsResult delObjRes = s3Client.deleteObjects(multiObjectDeleteRequest);
int currentlyDeletedCount = delObjRes.getDeletedObjects().size();
totallyDeleted = totallyDeleted + currentlyDeletedCount;
// verify size of deleted objects
if (keysForDelete.size() != currentlyDeletedCount) {
LOG.warn("The number of actually deleted objects " + currentlyDeletedCount +
" does not match the expected size of " + keysForDelete.size());
} else {
LOG.debug("Number of deleted S3 objects in current batch is " + currentlyDeletedCount);
}
}
// more objects to retrieve (1K batch size of objects)
if (objectListing.isTruncated()) {
objectListing = s3Client.listNextBatchOfObjects(objectListing);
} else {
break;
}
}
LOG.info("Successfully deleted " + totallyDeleted + " objects");
} catch (AmazonClientException e) {
throw new S3OperationException("Error deleting multiple objects matching pattern " + searchString
+ ". Number of deleted objects is " + totallyDeleted, e);
}
}
@Override
public DeleteObjectsResult deleteObjects(DeleteObjectsRequest deleteObjectsRequest, AmazonS3 s3Client)
{
return s3Client.deleteObjects(deleteObjectsRequest);
}
@Override
public void deleteDirectory(final S3FileTransferRequestParamsDto params)
{
LOGGER.info("Deleting keys/key versions from S3... s3KeyPrefix=\"{}\" s3BucketName=\"{}\"", params.getS3KeyPrefix(), params.getS3BucketName());
Assert.isTrue(!isRootKeyPrefix(params.getS3KeyPrefix()), "Deleting from root directory is not allowed.");
try
{
// List S3 versions.
List<S3VersionSummary> s3VersionSummaries = listVersions(params);
LOGGER.info("Found keys/key versions in S3 for deletion. s3KeyCount={} s3KeyPrefix=\"{}\" s3BucketName=\"{}\"", s3VersionSummaries.size(),
params.getS3KeyPrefix(), params.getS3BucketName());
// In order to avoid a MalformedXML AWS exception, we send delete request only when we have any key versions to delete.
if (CollectionUtils.isNotEmpty(s3VersionSummaries))
{
// Create an S3 client.
AmazonS3Client s3Client = getAmazonS3(params);
// Build a list of objects to be deleted.
List<DeleteObjectsRequest.KeyVersion> keyVersions = new ArrayList<>();
for (S3VersionSummary s3VersionSummary : s3VersionSummaries)
{
keyVersions.add(new DeleteObjectsRequest.KeyVersion(s3VersionSummary.getKey(), s3VersionSummary.getVersionId()));
}
try
{
// Delete the key versions.
deleteKeyVersions(s3Client, params.getS3BucketName(), keyVersions);
}
finally
{
s3Client.shutdown();
}
}
}
catch (AmazonClientException e)
{
throw new IllegalStateException(String
.format("Failed to delete keys/key versions with prefix \"%s\" from bucket \"%s\". Reason: %s", params.getS3KeyPrefix(),
params.getS3BucketName(), e.getMessage()), e);
}
}
@Test
public void testDeleteDirectoryMultiObjectDeleteException()
{
// Create an S3 file transfer request parameters DTO to access S3 objects.
S3FileTransferRequestParamsDto s3FileTransferRequestParamsDto = new S3FileTransferRequestParamsDto();
s3FileTransferRequestParamsDto.setS3BucketName(S3_BUCKET_NAME);
s3FileTransferRequestParamsDto.setS3KeyPrefix(S3_KEY_PREFIX);
// Create a retry policy.
RetryPolicy retryPolicy =
new RetryPolicy(PredefinedRetryPolicies.DEFAULT_RETRY_CONDITION, PredefinedRetryPolicies.DEFAULT_BACKOFF_STRATEGY, INTEGER_VALUE, true);
// Create an S3 version summary.
S3VersionSummary s3VersionSummary = new S3VersionSummary();
s3VersionSummary.setKey(S3_KEY);
s3VersionSummary.setVersionId(S3_VERSION_ID);
// Create a version listing.
VersionListing versionListing = new VersionListing();
versionListing.setVersionSummaries(Collections.singletonList(s3VersionSummary));
// Create a delete error.
MultiObjectDeleteException.DeleteError deleteError = new MultiObjectDeleteException.DeleteError();
deleteError.setKey(S3_KEY);
deleteError.setVersionId(S3_VERSION_ID);
deleteError.setCode(ERROR_CODE);
deleteError.setMessage(ERROR_MESSAGE);
// Create a multi object delete exception.
MultiObjectDeleteException multiObjectDeleteException = new MultiObjectDeleteException(Collections.singletonList(deleteError), new ArrayList<>());
// Mock the external calls.
when(retryPolicyFactory.getRetryPolicy()).thenReturn(retryPolicy);
when(s3Operations.listVersions(any(ListVersionsRequest.class), any(AmazonS3Client.class))).thenReturn(versionListing);
when(s3Operations.deleteObjects(any(DeleteObjectsRequest.class), any(AmazonS3Client.class))).thenThrow(multiObjectDeleteException);
// Try to call the method under test.
try
{
s3DaoImpl.deleteDirectory(s3FileTransferRequestParamsDto);
}
catch (IllegalStateException e)
{
assertEquals(String.format(
"Failed to delete keys/key versions with prefix \"%s\" from bucket \"%s\". Reason: One or more objects could not be deleted " +
"(Service: null; Status Code: 0; Error Code: null; Request ID: null; S3 Extended Request ID: null)", S3_KEY_PREFIX, S3_BUCKET_NAME),
e.getMessage());
}
// Verify the external calls.
verify(retryPolicyFactory, times(2)).getRetryPolicy();
verify(s3Operations).listVersions(any(ListVersionsRequest.class), any(AmazonS3Client.class));
verify(s3Operations).deleteObjects(any(DeleteObjectsRequest.class), any(AmazonS3Client.class));
verifyNoMoreInteractionsHelper();
}
/** Unsupported Operation. */
@Override public DeleteObjectsResult deleteObjects(DeleteObjectsRequest delObjectsReq)
throws SdkClientException {
throw new UnsupportedOperationException("Operation not supported");
}