private boolean deleteObject(String key)
{
    try {
        DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(getBucketName(uri), key);
        if (requesterPaysEnabled) {
            // TODO use deleteObjectRequest.setRequesterPays() when https://github.com/aws/aws-sdk-java/issues/1219 is fixed
            // currently the method exists, but is ineffective (doesn't set the required HTTP header)
            deleteObjectRequest.putCustomRequestHeader(Headers.REQUESTER_PAYS_HEADER, Constants.REQUESTER_PAYS);
        }

        s3.deleteObject(deleteObjectRequest);
        return true;
    }
    catch (AmazonClientException e) {
        return false;
    }
}
 

private void productionFileDeletion (String fileName, String s3Folder){
	String bucketName = this.bucketAWS + s3Folder;
       try {
       	this.amazonS3.deleteObject(new DeleteObjectRequest(bucketName, fileName));
       	System.out.println("S3 DELETION: File " + fileName + " deleted successfully");
       } catch (AmazonServiceException ase) {
           System.out.println("Caught an AmazonServiceException.");
           System.out.println("Error Message:    " + ase.getMessage());
           System.out.println("HTTP Status Code: " + ase.getStatusCode());
           System.out.println("AWS Error Code:   " + ase.getErrorCode());
           System.out.println("Error Type:       " + ase.getErrorType());
           System.out.println("Request ID:       " + ase.getRequestId());
       } catch (AmazonClientException ace) {
           System.out.println("Caught an AmazonClientException.");
           System.out.println("Error Message: " + ace.getMessage());
       }
}
 

private void productionFileDeletion (String fileName, String s3Folder){
	String bucketName = this.bucketAWS + s3Folder;
       try {
       	this.amazonS3.deleteObject(new DeleteObjectRequest(bucketName, fileName));
       	System.out.println("S3 DELETION: File " + fileName + " deleted successfully");
       } catch (AmazonServiceException ase) {
           System.out.println("Caught an AmazonServiceException.");
           System.out.println("Error Message:    " + ase.getMessage());
           System.out.println("HTTP Status Code: " + ase.getStatusCode());
           System.out.println("AWS Error Code:   " + ase.getErrorCode());
           System.out.println("Error Type:       " + ase.getErrorType());
           System.out.println("Request ID:       " + ase.getRequestId());
       } catch (AmazonClientException ace) {
           System.out.println("Caught an AmazonClientException.");
           System.out.println("Error Message: " + ace.getMessage());
       }
}
 

@Override
public boolean delete(String hostName, Path path, boolean recursive) throws IOException {
  String key = pathToKey(path);
  LOG.debug("Object name to delete {}. Path {}", key, path.toString());
  try {
    mClient.deleteObject(new DeleteObjectRequest(mBucket, key));
    memoryCache.removeFileStatus(path.toString());
    return true;
  } catch (AmazonServiceException e) {
    if (e.getStatusCode() != 404) {
      throw new IOException(e);
    }
  }
  LOG.warn("Delete on {} not found. Nothing to delete");
  return false;
}
 

@Test
public void testDeleteObjectSimple() throws IOException {
    runner.setProperty(DeleteS3Object.REGION, "us-west-2");
    runner.setProperty(DeleteS3Object.BUCKET, "test-bucket");
    final Map<String, String> attrs = new HashMap<>();
    attrs.put("filename", "delete-key");
    runner.enqueue(new byte[0], attrs);

    runner.run(1);

    runner.assertAllFlowFilesTransferred(DeleteS3Object.REL_SUCCESS, 1);
    ArgumentCaptor<DeleteObjectRequest> captureRequest = ArgumentCaptor.forClass(DeleteObjectRequest.class);
    Mockito.verify(mockS3Client, Mockito.times(1)).deleteObject(captureRequest.capture());
    DeleteObjectRequest request = captureRequest.getValue();
    assertEquals("test-bucket", request.getBucketName());
    assertEquals("delete-key", request.getKey());
    Mockito.verify(mockS3Client, Mockito.never()).deleteVersion(Mockito.any(DeleteVersionRequest.class));
}
 

@Test
public void testDeleteVersionSimple() {
    runner.setProperty(DeleteS3Object.REGION, "us-west-2");
    runner.setProperty(DeleteS3Object.BUCKET, "test-bucket");
    runner.setProperty(DeleteS3Object.VERSION_ID, "test-version");
    final Map<String, String> attrs = new HashMap<>();
    attrs.put("filename", "test-key");
    runner.enqueue(new byte[0], attrs);

    runner.run(1);

    runner.assertAllFlowFilesTransferred(DeleteS3Object.REL_SUCCESS, 1);
    ArgumentCaptor<DeleteVersionRequest> captureRequest = ArgumentCaptor.forClass(DeleteVersionRequest.class);
    Mockito.verify(mockS3Client, Mockito.times(1)).deleteVersion(captureRequest.capture());
    DeleteVersionRequest request = captureRequest.getValue();
    assertEquals("test-bucket", request.getBucketName());
    assertEquals("test-key", request.getKey());
    assertEquals("test-version", request.getVersionId());
    Mockito.verify(mockS3Client, Mockito.never()).deleteObject(Mockito.any(DeleteObjectRequest.class));
}
 

@Test
public void testDeleteVersionFromExpressions() {
    runner.setProperty(DeleteS3Object.REGION, "us-west-2");
    runner.setProperty(DeleteS3Object.BUCKET, "${s3.bucket}");
    runner.setProperty(DeleteS3Object.VERSION_ID, "${s3.version}");
    final Map<String, String> attrs = new HashMap<>();
    attrs.put("filename", "test-key");
    attrs.put("s3.bucket", "test-bucket");
    attrs.put("s3.version", "test-version");
    runner.enqueue(new byte[0], attrs);

    runner.run(1);

    runner.assertAllFlowFilesTransferred(DeleteS3Object.REL_SUCCESS, 1);
    ArgumentCaptor<DeleteVersionRequest> captureRequest = ArgumentCaptor.forClass(DeleteVersionRequest.class);
    Mockito.verify(mockS3Client, Mockito.times(1)).deleteVersion(captureRequest.capture());
    DeleteVersionRequest request = captureRequest.getValue();
    assertEquals("test-bucket", request.getBucketName());
    assertEquals("test-key", request.getKey());
    assertEquals("test-version", request.getVersionId());
    Mockito.verify(mockS3Client, Mockito.never()).deleteObject(Mockito.any(DeleteObjectRequest.class));
}
 

/**
 * Delete file from Amazon S3 storage.
 * 
 * @param bucket
 *            - S3 Bucket name.
 * @param key
 *            - S3 storage path. Example:
 *            DEMO/TestSuiteName/TestMethodName/file.txt
 */
public void delete(String bucket, String key) {
    if (key == null) {
        throw new RuntimeException("Key is null!");
    }
    if (key.isEmpty()) {
        throw new RuntimeException("Key is empty!");
    }

    try {
        s3client.deleteObject(new DeleteObjectRequest(bucket, key));
    } catch (AmazonServiceException ase) {
        LOGGER.error("Caught an AmazonServiceException, which "
                + "means your request made it "
                + "to Amazon S3, but was rejected with an error response for some reason.\n"
                + "Error Message:    " + ase.getMessage() + "\n"
                + "HTTP Status Code: " + ase.getStatusCode() + "\n"
                + "AWS Error Code:   " + ase.getErrorCode() + "\n"
                + "Error Type:       " + ase.getErrorType() + "\n"
                + "Request ID:       " + ase.getRequestId());
    } catch (AmazonClientException ace) {
        LOGGER.error("Caught an AmazonClientException.\n"
                + "Error Message: " + ace.getMessage());
    }
}
 

@Override
public Parameters handleRequest(Parameters parameters, Context context) {

    context.getLogger().log("Input Function [" + context.getFunctionName() + "], Parameters [" + parameters + "]");

    // The archive location of the snapshot will be decided by the alert
    // flag
    String newFilename;
    if (parameters.getSendAlert()) {
        newFilename =  parameters.getS3Key().replace("upload/", "archive/alerts/");
    } else {
        newFilename = parameters.getS3Key().replace("upload/", "archive/falsepositives/");
    }

    // Ensure that the first two hyphens are used to create sub-directories
    // in the file path
    newFilename = newFilename.replaceFirst("-", "/");
    newFilename = newFilename.replaceFirst("-", "/");

    // Using the S3 client, first copy the file to the archive, and then
    // delete the original
    AmazonS3 client = AmazonS3ClientBuilder.defaultClient();
    CopyObjectRequest copyObjectRequest = new CopyObjectRequest(parameters.getS3Bucket(), parameters.getS3Key(), parameters.getS3Bucket(), newFilename);
    client.copyObject(copyObjectRequest);
    DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(parameters.getS3Bucket(), parameters.getS3Key());
    client.deleteObject(deleteObjectRequest);

    // Place the new location in the parameters
    parameters.setS3ArchivedKey(newFilename);

    context.getLogger().log("Output Function [" + context.getFunctionName() + "], Parameters [" + parameters + "]");

    return parameters;
}
 

@Override
public void delete(String path) throws BusinessException {
    if (!Optional.ofNullable(path).isPresent()) {
        throw new BusinessException(Validations.INVALID_PATH.getCode());
    }
    client.getClient(credentials.getCredentials());
    try {
        s3Client.deleteObject(
                new DeleteObjectRequest(cdnConfig.getName(), path)
        );
    } catch (AmazonServiceException e) {
        throw new BusinessException(e.getMessage());
    }
}
 

@Override
public void deleteBySha1(final String tenant, final String sha1Hash) {
    final String key = objectKey(tenant, sha1Hash);

    LOG.info("Deleting S3 object from bucket {} and key {}", s3Properties.getBucketName(), key);
    amazonS3.deleteObject(new DeleteObjectRequest(s3Properties.getBucketName(), key));
}
 

static void copy(
    AmazonS3 s3Client,
    String srcBucket,
    String sourceKey,
    String destBucket,
    String destKey,
    boolean isMove
) {
  CopyObjectRequest cp = new CopyObjectRequest(srcBucket, sourceKey, destBucket, destKey);
  s3Client.copyObject(cp);
  if (isMove) {
    s3Client.deleteObject(new DeleteObjectRequest(srcBucket, sourceKey));
  }
}
 

public cfData execute( cfSession _session, cfArgStructData argStruct ) throws cfmRunTimeException{
AmazonKey amazonKey	= getAmazonKey(_session, argStruct);
AmazonS3 s3Client		= getAmazonS3(amazonKey);

	String bucket			= getNamedStringParam(argStruct, "bucket", null );
	String srckey			= getNamedStringParam(argStruct, "srckey", null );
	String deskey			= getNamedStringParam(argStruct, "destkey", null );
	String aes256key	= getNamedStringParam(argStruct, "aes256key", null );

if ( srckey != null && srckey.charAt( 0 ) == '/' )
	srckey	= srckey.substring(1);

if ( deskey != null && deskey.charAt( 0 ) == '/' )
	deskey	= deskey.substring(1);

	
	CopyObjectRequest cor = new CopyObjectRequest(bucket, srckey, bucket, deskey);
	
	if ( aes256key != null && !aes256key.isEmpty() ){
		cor.setSourceSSECustomerKey( new SSECustomerKey(aes256key) );
		cor.setDestinationSSECustomerKey( new SSECustomerKey(aes256key) );
	}
	

try {
	s3Client.copyObject(cor);
	s3Client.deleteObject(new DeleteObjectRequest(bucket, srckey));
	return cfBooleanData.TRUE;
} catch (Exception e) {
	throwException(_session, "AmazonS3: " + e.getMessage() );
	return cfBooleanData.FALSE;
}
}
 

@Test
public void testDeleteObjectS3Exception() {
    runner.setProperty(DeleteS3Object.REGION, "us-west-2");
    runner.setProperty(DeleteS3Object.BUCKET, "test-bucket");
    final Map<String, String> attrs = new HashMap<>();
    attrs.put("filename", "delete-key");
    runner.enqueue(new byte[0], attrs);
    Mockito.doThrow(new AmazonS3Exception("NoSuchBucket")).when(mockS3Client).deleteObject(Mockito.any());

    runner.run(1);

    runner.assertAllFlowFilesTransferred(DeleteS3Object.REL_FAILURE, 1);
    ArgumentCaptor<DeleteObjectRequest> captureRequest = ArgumentCaptor.forClass(DeleteObjectRequest.class);
    Mockito.verify(mockS3Client, Mockito.never()).deleteVersion(Mockito.any(DeleteVersionRequest.class));
}
 

@Override
public void deleteProduct(Product product) throws DataTransferException, IOException {
  for (Reference ref : product.getProductReferences()) {
    DeleteObjectRequest request = new DeleteObjectRequest(bucketName, stripProtocol(
        ref.getDataStoreReference(), true));
    try {
      s3Client.deleteObject(request);
    } catch (AmazonClientException e) {
      throw new DataTransferException(String.format(
          "Failed to delete product reference %s from S3", ref.getDataStoreReference()), e);
    }
  }
}
 

@Test
public void testDeleteProduct() throws DataTransferException, IOException {
  dataTransferer.deleteProduct(product);

   ArgumentCaptor<DeleteObjectRequest> argument = ArgumentCaptor
       .forClass(DeleteObjectRequest.class);
  verify(s3Client).deleteObject(argument.capture());

  DeleteObjectRequest request = argument.getValue();
  assertThat(request.getBucketName(), is(S3_BUCKET_NAME));
  assertThat(request.getKey(), is(EXPECTED_DATA_STORE_REF));
}
 

@Override
public void deleteFile(S3Object f) throws FileSystemException {
	try {
		DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(bucketName, f.getKey());
		s3Client.deleteObject(deleteObjectRequest);
	} catch (AmazonServiceException e) {
		throw new FileSystemException(e);
	}
}
 

public void deleteContent(String p_bucket_name, String p_s3_key) throws AmazonClientException {
    if (s3Client.doesBucketExist(p_bucket_name)) {
        DeleteObjectRequest delete_req = new DeleteObjectRequest(p_bucket_name, p_s3_key);
        s3Client.deleteObject(delete_req);
    }
}
 

public DeleteObjectRequest newDeleteRequest() {
  return new DeleteObjectRequest(bucket, key);
}
 

@Test
public void testJobCommitFailure() throws Exception {
  Path jobAttemptPath = jobCommitter.getJobAttemptPath(job);
  FileSystem fs = jobAttemptPath.getFileSystem(conf);

  Set<String> uploads = runTasks(job, 4, 3);

  Assert.assertTrue(fs.exists(jobAttemptPath));

  jobCommitter.errors.failOnCommit(5);

  TestUtil.assertThrows("Should propagate the commit failure",
      AmazonClientException.class, "Fail on commit 5", new Callable<Void>() {
        @Override
        public Void call() throws IOException {
          jobCommitter.commitJob(job);
          return null;
        }
      });

  Assert.assertEquals("Should have succeeded to commit some uploads",
      5, jobCommitter.results.getCommits().size());

  Assert.assertEquals("Should have deleted the files that succeeded",
      5, jobCommitter.results.getDeletes().size());

  Set<String> commits = Sets.newHashSet();
  for (CompleteMultipartUploadRequest commit : jobCommitter.results.getCommits()) {
    commits.add(commit.getBucketName() + commit.getKey());
  }

  Set<String> deletes = Sets.newHashSet();
  for (DeleteObjectRequest delete : jobCommitter.results.getDeletes()) {
    deletes.add(delete.getBucketName() + delete.getKey());
  }

  Assert.assertEquals("Committed and deleted objects should match",
      commits, deletes);

  Assert.assertEquals("Should have aborted the remaining uploads",
      7, jobCommitter.results.getAborts().size());

  Set<String> uploadIds = getCommittedIds(jobCommitter.results.getCommits());
  uploadIds.addAll(getAbortedIds(jobCommitter.results.getAborts()));

  Assert.assertEquals("Should have committed/deleted or aborted all uploads",
      uploads, uploadIds);

  Assert.assertFalse(fs.exists(jobAttemptPath));
}
 

public List<DeleteObjectRequest> getDeletes() {
  return deletes;
}
 

@Override
public void delete() {
	if (delegate.exists()) {
		client.deleteObject(new DeleteObjectRequest(bucket, delegate.getFilename()));
	}
}
 

/** Unsupported Operation. */
@Override public void deleteObject(DeleteObjectRequest delObjReq) throws SdkClientException {
    throw new UnsupportedOperationException("Operation not supported");
}
 

public void deleteObjectsAfterVerificationInTarget(String objectKey) throws Exception {
  s3client.deleteObject(new DeleteObjectRequest(TARGET_BUCKET_NAME, objectKey));
}
 

@Override
public String handleRequest(S3Event s3Event, Context context) {
    byte[] buffer = new byte[1024];
    try {
        for (S3EventNotificationRecord record: s3Event.getRecords()) {
            String srcBucket = record.getS3().getBucket().getName();

            // Object key may have spaces or unicode non-ASCII characters.
            String srcKey = record.getS3().getObject().getKey()
                    .replace('+', ' ');
            srcKey = URLDecoder.decode(srcKey, "UTF-8");

            // Detect file type
            Matcher matcher = Pattern.compile(".*\\.([^\\.]*)").matcher(srcKey);
            if (!matcher.matches()) {
                System.out.println("Unable to detect file type for key " + srcKey);
                return "";
            }
            String extension = matcher.group(1).toLowerCase();
            if (!"zip".equals(extension)) {
                System.out.println("Skipping non-zip file " + srcKey + " with extension " + extension);
                return "";
            }
            System.out.println("Extracting zip file " + srcBucket + "/" + srcKey);
            
            // Download the zip from S3 into a stream
            AmazonS3 s3Client = new AmazonS3Client();
            S3Object s3Object = s3Client.getObject(new GetObjectRequest(srcBucket, srcKey));
            ZipInputStream zis = new ZipInputStream(s3Object.getObjectContent());
            ZipEntry entry = zis.getNextEntry();

            while(entry != null) {
                String fileName = entry.getName();
                String mimeType = FileMimeType.fromExtension(FilenameUtils.getExtension(fileName)).mimeType();
                System.out.println("Extracting " + fileName + ", compressed: " + entry.getCompressedSize() + " bytes, extracted: " + entry.getSize() + " bytes, mimetype: " + mimeType);
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                int len;
                while ((len = zis.read(buffer)) > 0) {
                    outputStream.write(buffer, 0, len);
                }
                InputStream is = new ByteArrayInputStream(outputStream.toByteArray());
                ObjectMetadata meta = new ObjectMetadata();
                meta.setContentLength(outputStream.size());
                meta.setContentType(mimeType);
                s3Client.putObject(srcBucket, FilenameUtils.getFullPath(srcKey) + fileName, is, meta);
                is.close();
                outputStream.close();
                entry = zis.getNextEntry();
            }
            zis.closeEntry();
            zis.close();
            
            //delete zip file when done
            System.out.println("Deleting zip file " + srcBucket + "/" + srcKey + "...");
            s3Client.deleteObject(new DeleteObjectRequest(srcBucket, srcKey));
            System.out.println("Done deleting");
        }
        return "Ok";
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

public void run() {
    AWSCredentials credentials = new BasicAWSCredentials(access_key, secret_key);
    AmazonS3 s3Client = new AmazonS3Client(credentials,
            new ClientConfiguration());
    if (endpoint.contains("amazonaws.com")) {
        String aws_endpoint = s3Client.getBucketLocation(new GetBucketLocationRequest(bucket));
        if (aws_endpoint.contains("US")) {
            s3Client.setEndpoint("https://s3.amazonaws.com");
        } else if (aws_endpoint.contains("us-west")) {
            s3Client.setEndpoint("https://s3-" + aws_endpoint + ".amazonaws.com");
        } else if (aws_endpoint.contains("eu-west")) {
            s3Client.setEndpoint("https://s3-" + aws_endpoint + ".amazonaws.com");
        } else if (aws_endpoint.contains("ap-")) {
            s3Client.setEndpoint("https://s3-" + aws_endpoint + ".amazonaws.com");
        } else if (aws_endpoint.contains("sa-east-1")) {
            s3Client.setEndpoint("https://s3-" + aws_endpoint + ".amazonaws.com");
        } else {
            s3Client.setEndpoint("https://s3." + aws_endpoint + ".amazonaws.com");
        }
    } else {
        s3Client.setS3ClientOptions(S3ClientOptions.builder().setPathStyleAccess(true).build());
        s3Client.setEndpoint(endpoint);
    }

    try {

        if (version != null) {
            s3Client.deleteVersion(new DeleteVersionRequest(bucket, what, version));
        } else {
            s3Client.deleteObject(new DeleteObjectRequest(bucket, what));
        }
        if (!debug) {
            NewJFrame.jTextArea1.append("\nDeleted file: " + what);
        }
        calibrate();
    } catch (AmazonServiceException ase) {
        if (NewJFrame.gui) {
            mainFrame.jTextArea1.append("\n\nError Message:    " + ase.getMessage());
            mainFrame.jTextArea1.append("\nHTTP Status Code: " + ase.getStatusCode());
            mainFrame.jTextArea1.append("\nAWS Error Code:   " + ase.getErrorCode());
            mainFrame.jTextArea1.append("\nError Type:       " + ase.getErrorType());
            mainFrame.jTextArea1.append("\nRequest ID:       " + ase.getRequestId());
            calibrate();
        } else {
            System.out.print("\n\nError Message:    " + ase.getMessage());
            System.out.print("\nHTTP Status Code: " + ase.getStatusCode());
            System.out.print("\nAWS Error Code:   " + ase.getErrorCode());
            System.out.print("\nError Type:       " + ase.getErrorType());
            System.out.print("\nRequest ID:       " + ase.getRequestId());
        }
    } catch (Exception delete) {
    }
}
 

@Override
public void delete( UUID appId, Entity entity ) throws Exception {
    getS3Client().deleteObject(new DeleteObjectRequest(bucketName, AssetUtils.buildAssetKey( appId, entity )));
}
 

@Override
public void deleteObject(DeleteObjectRequest deleteObjectRequest) throws AmazonClientException,
    AmazonServiceException {
  // TODO Auto-generated method stub

}
 

@Override
public void deleteObject(final DeleteObjectRequest request) throws AmazonClientException {
    assertThat(request.getBucketName(), equalTo(bucket));
    blobs.remove(request.getKey());
}
 

/**
 * Deletes the specified object in the specified bucket
 *
 * @param bucketName bucket name
 * @param key        object key
 * @throws AmazonClientException  If any errors are encountered in the client while making the
 *                                request or handling the response.
 * @throws AmazonServiceException If any errors occurred in Amazon S3 while processing the
 *                                request.
 */
protected void startDelete(String bucketName, String key) throws AmazonClientException, AmazonServiceException {
    DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(bucketName, key);
    amazonS3.deleteObject(deleteObjectRequest);
}