Example usage for com.amazonaws.services.s3.model DeleteObjectsRequest DeleteObjectsRequest

Introduction

In this page you can find the example usage for com.amazonaws.services.s3.model DeleteObjectsRequest DeleteObjectsRequest.

Prototype

public DeleteObjectsRequest(String bucketName) 

Source Link

Document

Constructs a new DeleteObjectsRequest , specifying the objects' bucket name.

Usage

From source file:aws.example.s3.DeleteObjects.java

License:Open Source License

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);/*  www  .ja  v a  2s .  c o m*/
    }

    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 = new AmazonS3Client();
    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!");
}

---

From source file:awslabs.lab21.SolutionCode.java

License:Open Source License

@Override
public void deleteBucket(AmazonS3 s3Client, String bucketName) {
    // First, try to delete the bucket.
    DeleteBucketRequest deleteBucketRequest = new DeleteBucketRequest(bucketName);

    try {/*  w  w  w . j  a v  a2  s .c o  m*/
        s3Client.deleteBucket(deleteBucketRequest);
        // If we got here, no error was generated so we'll assume the bucket was deleted and return.
        return;
    } catch (AmazonS3Exception ex) {
        if (!ex.getErrorCode().equals("BucketNotEmpty")) {
            // The only other exception we're going to handle is BucketNotEmpty, so rethrow anything else.
            throw ex;
        }
    }

    // If we got here, the bucket isn't empty, so delete the contents and try again.
    List<KeyVersion> keys = new ArrayList<KeyVersion>();
    for (S3ObjectSummary obj : s3Client.listObjects(bucketName).getObjectSummaries()) {
        // Add the keys to our list of object.
        keys.add(new KeyVersion(obj.getKey()));
    }
    // Create the request to delete the objects.
    DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
    deleteObjectsRequest.withKeys(keys);
    // Submit the delete objects request.
    s3Client.deleteObjects(deleteObjectsRequest);

    // The bucket is empty now, so attempt the delete again.
    s3Client.deleteBucket(deleteBucketRequest);
}

---

From source file:ch.admin.isb.hermes5.persistence.s3.S3RemoteAdapter.java

License:Apache License

@Override
public List<String> deletePath(String path) {
    List<String> keys = new ArrayList<String>();
    ObjectListing listObjects = s3.listObjects(this.bucketName.getStringValue(), path);
    List<S3ObjectSummary> objectSummaries = listObjects.getObjectSummaries();
    if (!objectSummaries.isEmpty()) {
        DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName.getStringValue());
        for (S3ObjectSummary s3ObjectSummary : objectSummaries) {
            String key = s3ObjectSummary.getKey();
            keys.add(key);/*from w ww .  j  a  va2s .com*/
            deleteObjectsRequest.getKeys().add(new KeyVersion(key));
        }
        s3.deleteObjects(deleteObjectsRequest);
    }
    return keys;
}

---

From source file:com.android.demo.notepad3.Util.java

License:Open Source License

public static void deleteBucket() {
    String name = Constants.BUCKET_NAME.toLowerCase(Locale.US);
    List<S3ObjectSummary> objData = sS3Client.listObjects(name).getObjectSummaries();
    if (objData.size() > 0) {
        DeleteObjectsRequest emptyBucket = new DeleteObjectsRequest(name);
        List<KeyVersion> keyList = new ArrayList<KeyVersion>();
        for (S3ObjectSummary summary : objData) {
            keyList.add(new KeyVersion(summary.getKey()));
        }/*  w  w w  . ja  va2  s.  c o m*/
        emptyBucket.withKeys(keyList);
        sS3Client.deleteObjects(emptyBucket);
    }
    sS3Client.deleteBucket(name);
}

---

From source file:com.davidsoergel.s3napback.S3ops.java

License:Apache License

public static void delete(TransferManager tx, String bucket, String fileprefix) throws InterruptedException {
    logger.info("Deleting " + fileprefix);

    List<DeleteObjectsRequest.KeyVersion> keys = new ArrayList<DeleteObjectsRequest.KeyVersion>();

    ObjectListing objectListing = tx.getAmazonS3Client()
            .listObjects(new ListObjectsRequest().withBucketName(bucket).withPrefix(fileprefix));
    for (S3ObjectSummary objectSummary : objectListing.getObjectSummaries()) {
        keys.add(new DeleteObjectsRequest.KeyVersion(objectSummary.getKey()));
    }/*from  w  ww.ja v a 2 s.  co  m*/

    DeleteObjectsRequest req = new DeleteObjectsRequest(bucket);
    req.setKeys(keys);
    DeleteObjectsResult result = tx.getAmazonS3Client().deleteObjects(req);
}

---

From source file:com.dss.sframework.tools.amazon.AmazonUtil.java

License:Open Source License

public static void deleteBucket() {
    String name = ConstantAmazon.BUCKET_NAME.toLowerCase(Locale.US);
    List<S3ObjectSummary> objData = sS3Client.listObjects(name).getObjectSummaries();
    if (objData.size() > 0) {
        DeleteObjectsRequest emptyBucket = new DeleteObjectsRequest(name);
        List<KeyVersion> keyList = new ArrayList<>();
        for (S3ObjectSummary summary : objData) {
            keyList.add(new KeyVersion(summary.getKey()));
        }/*from w  ww  .j a  v  a2 s.  c  o m*/
        emptyBucket.withKeys(keyList);
        sS3Client.deleteObjects(emptyBucket);
    }
    sS3Client.deleteBucket(name);
}

---

From source file:com.easarrive.aws.plugins.common.service.impl.S3Service.java

License:Open Source License

/**
 * {@inheritDoc}/*from  www  .ja  v a2 s  .  co m*/
 */
@Override
public DeleteObjectsResult deleteObjects(AmazonS3 client, String bucketName, List<String> keyList) {
    if (client == null) {
        return null;
    } else if (StringUtil.isEmpty(bucketName)) {
        return null;
    } else if (keyList == null || keyList.size() < 1) {
        return null;
    }
    DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
    List<KeyVersion> keys = new ArrayList<KeyVersion>();
    for (String key : keyList) {
        KeyVersion keyVersion = new KeyVersion(key);
        keys.add(keyVersion);
    }
    deleteObjectsRequest.setKeys(keys);
    DeleteObjectsResult result = client.deleteObjects(deleteObjectsRequest);
    return result;
}

---

From source file:com.easarrive.aws.plugins.common.service.impl.S3Service.java

License:Open Source License

/**
 * {@inheritDoc}/*from w w  w  . ja va  2  s . co  m*/
 */
public DeleteObjectsResult deleteObjects2(AmazonS3 client, String bucketName, List<KeyVersion> keyList) {
    if (client == null) {
        return null;
    } else if (StringUtil.isEmpty(bucketName)) {
        return null;
    } else if (keyList == null || keyList.size() < 1) {
        return null;
    }
    DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest(bucketName);
    deleteObjectsRequest.setKeys(keyList);
    DeleteObjectsResult result = client.deleteObjects(deleteObjectsRequest);
    return result;
}

---

From source file:com.emc.ecs.sync.target.S3Target.java

License:Open Source License

@Override
public void filter(SyncObject obj) {
    try {/*from  ww  w .ja v a  2 s.co  m*/
        // skip the root of the bucket since it obviously exists
        if ("".equals(rootKey + obj.getRelativePath())) {
            log.debug("Target is bucket root; skipping");
            return;
        }

        // some sync objects lazy-load their metadata (i.e. AtmosSyncObject)
        // since this may be a timed operation, ensure it loads outside of other timed operations
        if (!(obj instanceof S3ObjectVersion) || !((S3ObjectVersion) obj).isDeleteMarker())
            obj.getMetadata();

        // Compute target key
        String targetKey = getTargetKey(obj);
        obj.setTargetIdentifier(AwsS3Util.fullPath(bucketName, targetKey));

        if (includeVersions) {
            ListIterator<S3ObjectVersion> sourceVersions = s3Source.versionIterator((S3SyncObject) obj);
            ListIterator<S3ObjectVersion> targetVersions = versionIterator(obj);

            boolean newVersions = false, replaceVersions = false;
            if (force) {
                replaceVersions = true;
            } else {

                // special workaround for bug where objects are listed, but they have no versions
                if (sourceVersions.hasNext()) {

                    // check count and etag/delete-marker to compare version chain
                    while (sourceVersions.hasNext()) {
                        S3ObjectVersion sourceVersion = sourceVersions.next();

                        if (targetVersions.hasNext()) {
                            S3ObjectVersion targetVersion = targetVersions.next();

                            if (sourceVersion.isDeleteMarker()) {

                                if (!targetVersion.isDeleteMarker())
                                    replaceVersions = true;
                            } else {

                                if (targetVersion.isDeleteMarker())
                                    replaceVersions = true;

                                else if (!sourceVersion.getETag().equals(targetVersion.getETag()))
                                    replaceVersions = true; // different checksum
                            }

                        } else if (!replaceVersions) { // source has new versions, but existing target versions are ok
                            newVersions = true;
                            sourceVersions.previous(); // back up one
                            putIntermediateVersions(sourceVersions, targetKey); // add any new intermediary versions (current is added below)
                        }
                    }

                    if (targetVersions.hasNext())
                        replaceVersions = true; // target has more versions

                    if (!newVersions && !replaceVersions) {
                        log.info("Source and target versions are the same. Skipping {}", obj.getRelativePath());
                        return;
                    }
                }
            }

            // something's off; must delete all versions of the object
            if (replaceVersions) {
                log.info(
                        "[{}]: version history differs between source and target; re-placing target version history with that from source.",
                        obj.getRelativePath());

                // collect versions in target
                List<DeleteObjectsRequest.KeyVersion> deleteVersions = new ArrayList<>();
                while (targetVersions.hasNext())
                    targetVersions.next(); // move cursor to end
                while (targetVersions.hasPrevious()) { // go in reverse order
                    S3ObjectVersion version = targetVersions.previous();
                    deleteVersions.add(new DeleteObjectsRequest.KeyVersion(targetKey, version.getVersionId()));
                }

                // batch delete all versions in target
                log.debug("[{}]: deleting all versions in target", obj.getRelativePath());
                s3.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(deleteVersions));

                // replay version history in target
                while (sourceVersions.hasPrevious())
                    sourceVersions.previous(); // move cursor to beginning
                putIntermediateVersions(sourceVersions, targetKey);
            }

        } else { // normal sync (no versions)
            Date sourceLastModified = obj.getMetadata().getModificationTime();
            long sourceSize = obj.getMetadata().getContentLength();

            // Get target metadata.
            ObjectMetadata destMeta = null;
            try {
                destMeta = s3.getObjectMetadata(bucketName, targetKey);
            } catch (AmazonS3Exception e) {
                if (e.getStatusCode() != 404)
                    throw new RuntimeException("Failed to check target key '" + targetKey + "' : " + e, e);
            }

            if (!force && obj.getFailureCount() == 0 && destMeta != null) {

                // Check overwrite
                Date destLastModified = destMeta.getLastModified();
                long destSize = destMeta.getContentLength();

                if (destLastModified.equals(sourceLastModified) && sourceSize == destSize) {
                    log.info("Source and target the same.  Skipping {}", obj.getRelativePath());
                    return;
                }
                if (destLastModified.after(sourceLastModified)) {
                    log.info("Target newer than source.  Skipping {}", obj.getRelativePath());
                    return;
                }
            }
        }

        // at this point we know we are going to write the object
        // Put [current object version]
        if (obj instanceof S3ObjectVersion && ((S3ObjectVersion) obj).isDeleteMarker()) {

            // object has version history, but is currently deleted
            log.debug("[{}]: deleting object in target to replicate delete marker in source.",
                    obj.getRelativePath());
            s3.deleteObject(bucketName, targetKey);
        } else {
            putObject(obj, targetKey);

            // if object has new metadata after the stream (i.e. encryption checksum), we must update S3 again
            if (obj.requiresPostStreamMetadataUpdate()) {
                log.debug("[{}]: updating metadata after sync as required", obj.getRelativePath());
                CopyObjectRequest cReq = new CopyObjectRequest(bucketName, targetKey, bucketName, targetKey);
                cReq.setNewObjectMetadata(AwsS3Util.s3MetaFromSyncMeta(obj.getMetadata()));
                s3.copyObject(cReq);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException("Failed to store object: " + e, e);
    }
}

---

From source file:com.github.abhinavmishra14.aws.s3.service.impl.AwsS3IamServiceImpl.java

License:Open Source License

@Override
public DeleteObjectsResult deleteObjects(final String bucketName, final List<KeyVersion> keys)
        throws AmazonClientException, AmazonServiceException {
    LOGGER.info("deleteObjects invoked, bucketName: {}, keys: {}", bucketName, keys);
    final DeleteObjectsRequest deleteObjReq = new DeleteObjectsRequest(bucketName);
    deleteObjReq.setKeys(keys);/*from  www . j a  v a 2s.  co m*/
    return s3client.deleteObjects(deleteObjReq);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »