Example usage for com.amazonaws.services.s3 AmazonS3Client putObject

List of usage examples for com.amazonaws.services.s3 AmazonS3Client putObject

Introduction

In this page you can find the example usage for com.amazonaws.services.s3 AmazonS3Client putObject.

Prototype

@Override
    public PutObjectResult putObject(PutObjectRequest putObjectRequest)
            throws SdkClientException, AmazonServiceException 

Source Link

Usage

From source file:S3Console.java

License:Open Source License

void createS3Bucket(AmazonS3Client s3, String mc_no) throws IOException {
    this.s3 = s3;

    //create bucket
    String bucketName = "prachi-amazon-s3-bucket-" + mc_no + Virtualize.no_of_days;
    s3.createBucket(bucketName);//from  www . j  a  va2s .  c  om

    //set key
    String key = "ReadMe.txt";

    //set value
    File file = File.createTempFile("temp", ".txt");
    file.deleteOnExit();
    Writer writer = new OutputStreamWriter(new FileOutputStream(file));
    writer.write("Amazon S3 Bucket Created.\r ........Success !!");
    writer.close();

    //put object - bucket, key, value(file)
    s3.putObject(new PutObjectRequest(bucketName, key, file));

    //get object
    S3Object object = s3.getObject(new GetObjectRequest(bucketName, key));
    BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));
    String data = null;
    while ((data = reader.readLine()) != null) {
        System.out.println(data);
    }
}

From source file:awslabs.lab41.Lab41.java

License:Open Source License

public void testS3Client(AmazonS3Client s3Client, String bucketName) {
    String fileName = "test-image.png";

    System.out.print("    Uploading to bucket " + bucketName + ". ");
    PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, new File(fileName));

    try {//from  w  ww  . j  a  va  2 s.com
        s3Client.putObject(putObjectRequest);
        System.out.println("Succeeded.");
    } catch (AmazonS3Exception ase) {
        System.out.println("Failed. [" + ase.getErrorCode() + "]");

    } catch (Exception ex) {
        System.out.println("Failed.");
    }

}

From source file:com.eucalyptus.objectstorage.providers.s3.S3ProviderClient.java

License:Open Source License

@Override
public PutObjectResponseType putObject(PutObjectType request, InputStream inputData) throws S3Exception {
    User requestUser = getRequestUser(request);
    OsgInternalS3Client internalS3Client = null;
    try {/*  w  w  w  .j  a v a 2 s  . c  o m*/
        internalS3Client = getS3Client(requestUser);
        AmazonS3Client s3Client = internalS3Client.getS3Client();
        PutObjectResult result;
        ObjectMetadata metadata = getS3ObjectMetadata(request);
        //Set the acl to private.
        PutObjectRequest putRequest = new PutObjectRequest(request.getBucket(), request.getKey(), inputData,
                metadata).withCannedAcl(CannedAccessControlList.Private);
        result = s3Client.putObject(putRequest);

        PutObjectResponseType reply = request.getReply();
        if (result == null) {
            throw new InternalErrorException("Null result from backend");
        } else {
            reply.setEtag(result.getETag());
            reply.setVersionId(result.getVersionId());
            reply.setLastModified(new Date());
        }
        return reply;
    } catch (AmazonServiceException e) {
        LOG.debug("Error from backend", e);
        throw S3ExceptionMapper.fromAWSJavaSDK(e);
    }
}

From source file:com.logpig.mweagle.aws.S3FilePutRunnable.java

License:Apache License

@Override
public void run() {
    boolean createBucket = false;
    boolean doExit = false;
    int attempt = 0;
    final AmazonS3Client s3Client = new AmazonS3Client(this.s3Settings.getAWSCredentials());
    while (!doExit && attempt != this.s3Settings.retryCount) {
        try {//from   w  w w . j a  va 2  s .c  om
            if (!s3Settings.mockPut) {
                if (createBucket) {
                    s3Client.createBucket(this.s3Settings.bucketName, this.s3Settings.regionName);
                }
                final File logfile = new File(this.filePath);
                final String keyName = UUID.randomUUID().toString();
                final PutObjectRequest request = new PutObjectRequest(this.s3Settings.bucketName, keyName,
                        logfile);
                s3Client.putObject(request);
            } else {
                logger.warn("Mocking file POST: {}", this.filePath);
            }
            doExit = true;
        } catch (AmazonServiceException ex) {
            createBucket = false;
            if (HttpURLConnection.HTTP_NOT_FOUND == ex.getStatusCode()
                    && ex.getErrorCode().equals("NoSuchBucket")) {
                createBucket = true;
            } else {
                // If the credentials are invalid, don't keep trying...
                doExit = HttpURLConnection.HTTP_FORBIDDEN == ex.getStatusCode();
                if (doExit) {
                    logger.error(String.format("Authentication error posting %s to AWS.  Will not retry.",
                            this.filePath), ex);
                } else {
                    logger.error(String.format("Failed to post %s to AWS", this.filePath), ex);
                }
            }
        } catch (AmazonClientException ex) {
            createBucket = false;
            logger.error(String.format("Failed to post %s to AWS", this.filePath), ex);
        } finally {
            // Create bucket failures don't count
            if (!createBucket) {
                attempt += 1;
            }
        }
    }
}

From source file:com.netflix.exhibitor.core.s3.S3ClientFactoryImpl.java

License:Apache License

@Override
public S3Client makeNewClient(final S3Credential credentials) throws Exception {
    return new S3Client() {
        private final AtomicReference<RefCountedClient> client = new AtomicReference<RefCountedClient>(null);

        {//from  w  w  w. j  a  v a2  s .c  om
            changeCredentials(credentials);
        }

        @Override
        public void changeCredentials(S3Credential credential) throws Exception {
            RefCountedClient newRefCountedClient = (credential != null) ? new RefCountedClient(
                    new AmazonS3Client(new BasicAWSCredentials(credentials.getAccessKeyId(),
                            credentials.getSecretAccessKey())))
                    : null;
            RefCountedClient oldRefCountedClient = client.getAndSet(newRefCountedClient);
            if (oldRefCountedClient != null) {
                oldRefCountedClient.markForDelete();
            }
        }

        @Override
        public void close() throws IOException {
            try {
                changeCredentials(null);
            } catch (Exception e) {
                throw new IOException(e);
            }
        }

        @Override
        public InitiateMultipartUploadResult initiateMultipartUpload(InitiateMultipartUploadRequest request)
                throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.initiateMultipartUpload(request);
            } finally {
                holder.release();
            }
        }

        @Override
        public PutObjectResult putObject(PutObjectRequest request) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.putObject(request);
            } finally {
                holder.release();
            }
        }

        @Override
        public S3Object getObject(String bucket, String key) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.getObject(bucket, key);
            } finally {
                holder.release();
            }
        }

        @Override
        public ObjectListing listObjects(ListObjectsRequest request) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.listObjects(request);
            } finally {
                holder.release();
            }
        }

        @Override
        public ObjectListing listNextBatchOfObjects(ObjectListing previousObjectListing) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.listNextBatchOfObjects(previousObjectListing);
            } finally {
                holder.release();
            }
        }

        @Override
        public void deleteObject(String bucket, String key) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                amazonS3Client.deleteObject(bucket, key);
            } finally {
                holder.release();
            }
        }

        @Override
        public UploadPartResult uploadPart(UploadPartRequest request) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                return amazonS3Client.uploadPart(request);
            } finally {
                holder.release();
            }
        }

        @Override
        public void completeMultipartUpload(CompleteMultipartUploadRequest request) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                amazonS3Client.completeMultipartUpload(request);
            } finally {
                holder.release();
            }
        }

        @Override
        public void abortMultipartUpload(AbortMultipartUploadRequest request) throws Exception {
            RefCountedClient holder = client.get();
            AmazonS3Client amazonS3Client = holder.useClient();
            try {
                amazonS3Client.abortMultipartUpload(request);
            } finally {
                holder.release();
            }
        }
    };
}

From source file:com.netflix.exhibitor.core.s3.S3ClientImpl.java

License:Apache License

@Override
public PutObjectResult putObject(PutObjectRequest request) throws Exception {
    RefCountedClient holder = client.get();
    AmazonS3Client amazonS3Client = holder.useClient();
    try {//w  w w  .  ja  v  a2 s  .  c o  m
        return amazonS3Client.putObject(request);
    } finally {
        holder.release();
    }
}

From source file:com.tvarit.plugin.TvaritTomcatDeployerMojo.java

License:Open Source License

@Override
public void execute() throws MojoExecutionException, MojoFailureException {

    final MavenProject project = (MavenProject) this.getPluginContext().getOrDefault("project", null);
    if (templateUrl == null)
        try {/*from w w  w.ja va  2s.  c  o m*/
            templateUrl = new TemplateUrlMaker().makeUrl(project, "newinstance.template").toString();
        } catch (MalformedURLException e) {
            throw new MojoExecutionException(
                    "Could not create default url for templates. Please open an issue on github.", e);
        }

    final BasicAWSCredentials awsCredentials = new BasicAWSCredentials(accessKey, secretKey);
    AmazonS3Client s3Client = new AmazonS3Client(awsCredentials);
    final File warFile = project.getArtifact().getFile();
    final String key = "deployables/" + project.getGroupId() + "/" + project.getArtifactId() + "/"
            + project.getVersion() + "/" + warFile.getName();
    final PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, warFile);
    final ObjectMetadata metadata = new ObjectMetadata();
    final HashMap<String, String> userMetadata = new HashMap<>();
    userMetadata.put("project_name", projectName);
    userMetadata.put("stack_template_url", templateUrl);
    userMetadata.put("private_key_name", sshKeyName);
    metadata.setUserMetadata(userMetadata);
    putObjectRequest.withMetadata(metadata);
    final PutObjectResult putObjectResult = s3Client.putObject(putObjectRequest);

    /*
            AmazonCloudFormationClient amazonCloudFormationClient = new AmazonCloudFormationClient(awsCredentials);
            final com.amazonaws.services.cloudformation.model.Parameter projectNameParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("projectName").withParameterValue(this.projectName);
            final com.amazonaws.services.cloudformation.model.Parameter publicSubnetsParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("publicSubnets").withParameterValue(commaSeparatedSubnetIds);
            final com.amazonaws.services.cloudformation.model.Parameter tvaritRoleParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("tvaritRole").withParameterValue(tvaritRole);
            final com.amazonaws.services.cloudformation.model.Parameter tvaritInstanceProfileParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("tvaritInstanceProfile").withParameterValue(this.tvaritInstanceProfile);
            final com.amazonaws.services.cloudformation.model.Parameter tvaritBucketNameParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("bucketName").withParameterValue(this.bucketName);
            final com.amazonaws.services.cloudformation.model.Parameter instanceSecurityGroupIdParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("sgId").withParameterValue(this.instanceSecurityGroupId);
            final com.amazonaws.services.cloudformation.model.Parameter sshKeyNameParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("keyName").withParameterValue(this.sshKeyName);
            final String warFileUrl = s3Client.getUrl(bucketName, key).toString();
            final com.amazonaws.services.cloudformation.model.Parameter warFileUrlParameter = new com.amazonaws.services.cloudformation.model.Parameter().withParameterKey("warFileUrl").withParameterValue(warFileUrl);
            final CreateStackRequest createStackRequest = new CreateStackRequest();
            if (templateUrl == null) {
    try {
        templateUrl = new TemplateUrlMaker().makeUrl(project, "newinstance.template").toString();
    } catch (MalformedURLException e) {
        throw new MojoExecutionException("Could not create default url for templates. Please open an issue on github.", e);
    }
            }
            createStackRequest.
        withStackName(projectName + "-instance-" + project.getVersion().replace(".", "-")).
        withParameters(
                projectNameParameter,
                publicSubnetsParameter,
                tvaritInstanceProfileParameter,
                tvaritRoleParameter,
                tvaritBucketNameParameter,
                instanceSecurityGroupIdParameter,
                warFileUrlParameter,
                sshKeyNameParameter
        ).
        withDisableRollback(true).
        withTemplateURL(templateUrl);
            createStackRequest.withDisableRollback(true);
            final Stack stack = new StackMaker().makeStack(createStackRequest, amazonCloudFormationClient, getLog());
            AmazonAutoScalingClient amazonAutoScalingClient = new AmazonAutoScalingClient(awsCredentials);
            final AttachInstancesRequest attachInstancesRequest = new AttachInstancesRequest();
            attachInstancesRequest.withInstanceIds(stack.getOutputs().get(0).getOutputValue(), stack.getOutputs().get(1).getOutputValue()).withAutoScalingGroupName(autoScalingGroupName);
            amazonAutoScalingClient.attachInstances(attachInstancesRequest);
    */

}

From source file:itcr.gitsnes.MainActivity.java

License:Open Source License

/** The method sendGame makes many functions:
 *      - Get all data from text boxes on layout add_game
 *      - Makes a random bucket key for a photo/file and put the object into the bucket
 *      - Wait for the success signal and send the JSON build from BackendHandler
 *        to app-engine (Google)/*from ww w  .  ja  v a2  s.c o m*/
 */
public void sendGame(View view) throws IOException {

    Toast.makeText(this, "Wait, we are uploading your game =) ", Toast.LENGTH_LONG);
    /* GET DATA FROM INTERFACE*/
    EditText name = (EditText) this.findViewById(R.id.txt_name);
    EditText description = (EditText) this.findViewById(R.id.txt_desc);
    EditText category = (EditText) this.findViewById(R.id.txt_cat);

    StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
    StrictMode.setThreadPolicy(policy);

    /* GENERATE RANDOM KEYS FOR PHOTO AND FILE*/
    this.file_key = "" + UUID.randomUUID().toString().replace("-", "");
    this.image_key = "" + UUID.randomUUID().toString().replace("-", "");

    /* SAVING GAME FILE/PHOTO ON AWS BUCKET*/
    AmazonS3Client s3Client = new AmazonS3Client(
            new BasicAWSCredentials(KS.MY_ACCESS_KEY_ID, KS.MY_SECRET_KEY));

    PutObjectRequest putObjectRequestnew = new PutObjectRequest(KS.BUCKET_NAME, this.file_key, this.s3game);
    putObjectRequestnew.setCannedAcl(CannedAccessControlList.PublicRead);
    s3Client.putObject(putObjectRequestnew);

    PutObjectRequest putObjectImagenew = new PutObjectRequest(KS.BUCKET_IMG, this.image_key, this.s3image);
    putObjectImagenew.setCannedAcl(CannedAccessControlList.PublicRead);
    s3Client.putObject(putObjectImagenew);

    String actual_key = "none";
    String actual_image = "none";

    if (this.file_key != "none")
        actual_key = this.file_key;

    if (this.image_key != "none")
        actual_image = this.image_key;

    /* SEND JSON*/
    new BackendHandler().sendJSON(KS.getCurrent_user(), name.getText().toString(),
            category.getText().toString(), description.getText().toString(), actual_image, actual_key);
    Log.i(TAG, "Successful JSON send");
    Toast.makeText(this, "Congratulations your game has been sent", Toast.LENGTH_LONG);

}

From source file:org.apache.nifi.processors.aws.s3.PutS3Object.java

License:Apache License

@Override
public void onTrigger(final ProcessContext context, final ProcessSession session) {
    FlowFile flowFile = session.get();// www.j av a2s  .c o m
    if (flowFile == null) {
        return;
    }

    final long startNanos = System.nanoTime();

    final String bucket = context.getProperty(BUCKET).evaluateAttributeExpressions(flowFile).getValue();
    final String key = context.getProperty(KEY).evaluateAttributeExpressions(flowFile).getValue();
    final String cacheKey = getIdentifier() + "/" + bucket + "/" + key;

    final AmazonS3Client s3 = getClient();
    final FlowFile ff = flowFile;
    final Map<String, String> attributes = new HashMap<>();
    final String ffFilename = ff.getAttributes().get(CoreAttributes.FILENAME.key());
    attributes.put(S3_BUCKET_KEY, bucket);
    attributes.put(S3_OBJECT_KEY, key);

    final Long multipartThreshold = context.getProperty(MULTIPART_THRESHOLD).asDataSize(DataUnit.B).longValue();
    final Long multipartPartSize = context.getProperty(MULTIPART_PART_SIZE).asDataSize(DataUnit.B).longValue();

    final long now = System.currentTimeMillis();

    /*
     * If necessary, run age off for existing uploads in AWS S3 and local state
     */
    ageoffS3Uploads(context, s3, now);

    /*
     * Then
     */
    try {
        session.read(flowFile, new InputStreamCallback() {
            @Override
            public void process(final InputStream rawIn) throws IOException {
                try (final InputStream in = new BufferedInputStream(rawIn)) {
                    final ObjectMetadata objectMetadata = new ObjectMetadata();
                    objectMetadata.setContentDisposition(ff.getAttribute(CoreAttributes.FILENAME.key()));
                    objectMetadata.setContentLength(ff.getSize());

                    final String contentType = context.getProperty(CONTENT_TYPE)
                            .evaluateAttributeExpressions(ff).getValue();
                    if (contentType != null) {
                        objectMetadata.setContentType(contentType);
                        attributes.put(S3_CONTENT_TYPE, contentType);
                    }

                    final String expirationRule = context.getProperty(EXPIRATION_RULE_ID)
                            .evaluateAttributeExpressions(ff).getValue();
                    if (expirationRule != null) {
                        objectMetadata.setExpirationTimeRuleId(expirationRule);
                    }

                    final Map<String, String> userMetadata = new HashMap<>();
                    for (final Map.Entry<PropertyDescriptor, String> entry : context.getProperties()
                            .entrySet()) {
                        if (entry.getKey().isDynamic()) {
                            final String value = context.getProperty(entry.getKey())
                                    .evaluateAttributeExpressions(ff).getValue();
                            userMetadata.put(entry.getKey().getName(), value);
                        }
                    }

                    final String serverSideEncryption = context.getProperty(SERVER_SIDE_ENCRYPTION).getValue();
                    if (!serverSideEncryption.equals(NO_SERVER_SIDE_ENCRYPTION)) {
                        objectMetadata.setSSEAlgorithm(serverSideEncryption);
                        attributes.put(S3_SSE_ALGORITHM, serverSideEncryption);
                    }

                    if (!userMetadata.isEmpty()) {
                        objectMetadata.setUserMetadata(userMetadata);
                    }

                    if (ff.getSize() <= multipartThreshold) {
                        //----------------------------------------
                        // single part upload
                        //----------------------------------------
                        final PutObjectRequest request = new PutObjectRequest(bucket, key, in, objectMetadata);
                        request.setStorageClass(
                                StorageClass.valueOf(context.getProperty(STORAGE_CLASS).getValue()));
                        final AccessControlList acl = createACL(context, ff);
                        if (acl != null) {
                            request.setAccessControlList(acl);
                        }
                        final CannedAccessControlList cannedAcl = createCannedACL(context, ff);
                        if (cannedAcl != null) {
                            request.withCannedAcl(cannedAcl);
                        }

                        try {
                            final PutObjectResult result = s3.putObject(request);
                            if (result.getVersionId() != null) {
                                attributes.put(S3_VERSION_ATTR_KEY, result.getVersionId());
                            }
                            if (result.getETag() != null) {
                                attributes.put(S3_ETAG_ATTR_KEY, result.getETag());
                            }
                            if (result.getExpirationTime() != null) {
                                attributes.put(S3_EXPIRATION_ATTR_KEY, result.getExpirationTime().toString());
                            }
                            if (result.getMetadata().getRawMetadata().keySet()
                                    .contains(S3_STORAGECLASS_META_KEY)) {
                                attributes.put(S3_STORAGECLASS_ATTR_KEY, result.getMetadata()
                                        .getRawMetadataValue(S3_STORAGECLASS_META_KEY).toString());
                            }
                            if (userMetadata.size() > 0) {
                                StringBuilder userMetaBldr = new StringBuilder();
                                for (String userKey : userMetadata.keySet()) {
                                    userMetaBldr.append(userKey).append("=").append(userMetadata.get(userKey));
                                }
                                attributes.put(S3_USERMETA_ATTR_KEY, userMetaBldr.toString());
                            }
                            attributes.put(S3_API_METHOD_ATTR_KEY, S3_API_METHOD_PUTOBJECT);
                        } catch (AmazonClientException e) {
                            getLogger().info("Failure completing upload flowfile={} bucket={} key={} reason={}",
                                    new Object[] { ffFilename, bucket, key, e.getMessage() });
                            throw (e);
                        }
                    } else {
                        //----------------------------------------
                        // multipart upload
                        //----------------------------------------

                        // load or create persistent state
                        //------------------------------------------------------------
                        MultipartState currentState;
                        try {
                            currentState = getLocalStateIfInS3(s3, bucket, cacheKey);
                            if (currentState != null) {
                                if (currentState.getPartETags().size() > 0) {
                                    final PartETag lastETag = currentState.getPartETags()
                                            .get(currentState.getPartETags().size() - 1);
                                    getLogger().info("Resuming upload for flowfile='{}' bucket='{}' key='{}' "
                                            + "uploadID='{}' filePosition='{}' partSize='{}' storageClass='{}' "
                                            + "contentLength='{}' partsLoaded={} lastPart={}/{}",
                                            new Object[] { ffFilename, bucket, key, currentState.getUploadId(),
                                                    currentState.getFilePosition(), currentState.getPartSize(),
                                                    currentState.getStorageClass().toString(),
                                                    currentState.getContentLength(),
                                                    currentState.getPartETags().size(),
                                                    Integer.toString(lastETag.getPartNumber()),
                                                    lastETag.getETag() });
                                } else {
                                    getLogger().info("Resuming upload for flowfile='{}' bucket='{}' key='{}' "
                                            + "uploadID='{}' filePosition='{}' partSize='{}' storageClass='{}' "
                                            + "contentLength='{}' no partsLoaded",
                                            new Object[] { ffFilename, bucket, key, currentState.getUploadId(),
                                                    currentState.getFilePosition(), currentState.getPartSize(),
                                                    currentState.getStorageClass().toString(),
                                                    currentState.getContentLength() });
                                }
                            } else {
                                currentState = new MultipartState();
                                currentState.setPartSize(multipartPartSize);
                                currentState.setStorageClass(
                                        StorageClass.valueOf(context.getProperty(STORAGE_CLASS).getValue()));
                                currentState.setContentLength(ff.getSize());
                                persistLocalState(cacheKey, currentState);
                                getLogger().info("Starting new upload for flowfile='{}' bucket='{}' key='{}'",
                                        new Object[] { ffFilename, bucket, key });
                            }
                        } catch (IOException e) {
                            getLogger().error("IOException initiating cache state while processing flow files: "
                                    + e.getMessage());
                            throw (e);
                        }

                        // initiate multipart upload or find position in file
                        //------------------------------------------------------------
                        if (currentState.getUploadId().isEmpty()) {
                            final InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest(
                                    bucket, key, objectMetadata);
                            initiateRequest.setStorageClass(currentState.getStorageClass());
                            final AccessControlList acl = createACL(context, ff);
                            if (acl != null) {
                                initiateRequest.setAccessControlList(acl);
                            }
                            final CannedAccessControlList cannedAcl = createCannedACL(context, ff);
                            if (cannedAcl != null) {
                                initiateRequest.withCannedACL(cannedAcl);
                            }
                            try {
                                final InitiateMultipartUploadResult initiateResult = s3
                                        .initiateMultipartUpload(initiateRequest);
                                currentState.setUploadId(initiateResult.getUploadId());
                                currentState.getPartETags().clear();
                                try {
                                    persistLocalState(cacheKey, currentState);
                                } catch (Exception e) {
                                    getLogger().info("Exception saving cache state while processing flow file: "
                                            + e.getMessage());
                                    throw (new ProcessException("Exception saving cache state", e));
                                }
                                getLogger().info(
                                        "Success initiating upload flowfile={} available={} position={} "
                                                + "length={} bucket={} key={} uploadId={}",
                                        new Object[] { ffFilename, in.available(),
                                                currentState.getFilePosition(), currentState.getContentLength(),
                                                bucket, key, currentState.getUploadId() });
                                if (initiateResult.getUploadId() != null) {
                                    attributes.put(S3_UPLOAD_ID_ATTR_KEY, initiateResult.getUploadId());
                                }
                            } catch (AmazonClientException e) {
                                getLogger().info(
                                        "Failure initiating upload flowfile={} bucket={} key={} reason={}",
                                        new Object[] { ffFilename, bucket, key, e.getMessage() });
                                throw (e);
                            }
                        } else {
                            if (currentState.getFilePosition() > 0) {
                                try {
                                    final long skipped = in.skip(currentState.getFilePosition());
                                    if (skipped != currentState.getFilePosition()) {
                                        getLogger().info(
                                                "Failure skipping to resume upload flowfile={} "
                                                        + "bucket={} key={} position={} skipped={}",
                                                new Object[] { ffFilename, bucket, key,
                                                        currentState.getFilePosition(), skipped });
                                    }
                                } catch (Exception e) {
                                    getLogger().info(
                                            "Failure skipping to resume upload flowfile={} bucket={} "
                                                    + "key={} position={} reason={}",
                                            new Object[] { ffFilename, bucket, key,
                                                    currentState.getFilePosition(), e.getMessage() });
                                    throw (new ProcessException(e));
                                }
                            }
                        }

                        // upload parts
                        //------------------------------------------------------------
                        long thisPartSize;
                        for (int part = currentState.getPartETags().size() + 1; currentState
                                .getFilePosition() < currentState.getContentLength(); part++) {
                            if (!PutS3Object.this.isScheduled()) {
                                throw new IOException(S3_PROCESS_UNSCHEDULED_MESSAGE + " flowfile=" + ffFilename
                                        + " part=" + part + " uploadId=" + currentState.getUploadId());
                            }
                            thisPartSize = Math.min(currentState.getPartSize(),
                                    (currentState.getContentLength() - currentState.getFilePosition()));
                            UploadPartRequest uploadRequest = new UploadPartRequest().withBucketName(bucket)
                                    .withKey(key).withUploadId(currentState.getUploadId()).withInputStream(in)
                                    .withPartNumber(part).withPartSize(thisPartSize);
                            try {
                                UploadPartResult uploadPartResult = s3.uploadPart(uploadRequest);
                                currentState.addPartETag(uploadPartResult.getPartETag());
                                currentState.setFilePosition(currentState.getFilePosition() + thisPartSize);
                                try {
                                    persistLocalState(cacheKey, currentState);
                                } catch (Exception e) {
                                    getLogger().info("Exception saving cache state processing flow file: "
                                            + e.getMessage());
                                }
                                getLogger().info(
                                        "Success uploading part flowfile={} part={} available={} "
                                                + "etag={} uploadId={}",
                                        new Object[] { ffFilename, part, in.available(),
                                                uploadPartResult.getETag(), currentState.getUploadId() });
                            } catch (AmazonClientException e) {
                                getLogger().info(
                                        "Failure uploading part flowfile={} part={} bucket={} key={} "
                                                + "reason={}",
                                        new Object[] { ffFilename, part, bucket, key, e.getMessage() });
                                throw (e);
                            }
                        }

                        // complete multipart upload
                        //------------------------------------------------------------
                        CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest(
                                bucket, key, currentState.getUploadId(), currentState.getPartETags());
                        try {
                            CompleteMultipartUploadResult completeResult = s3
                                    .completeMultipartUpload(completeRequest);
                            getLogger().info("Success completing upload flowfile={} etag={} uploadId={}",
                                    new Object[] { ffFilename, completeResult.getETag(),
                                            currentState.getUploadId() });
                            if (completeResult.getVersionId() != null) {
                                attributes.put(S3_VERSION_ATTR_KEY, completeResult.getVersionId());
                            }
                            if (completeResult.getETag() != null) {
                                attributes.put(S3_ETAG_ATTR_KEY, completeResult.getETag());
                            }
                            if (completeResult.getExpirationTime() != null) {
                                attributes.put(S3_EXPIRATION_ATTR_KEY,
                                        completeResult.getExpirationTime().toString());
                            }
                            if (currentState.getStorageClass() != null) {
                                attributes.put(S3_STORAGECLASS_ATTR_KEY,
                                        currentState.getStorageClass().toString());
                            }
                            if (userMetadata.size() > 0) {
                                StringBuilder userMetaBldr = new StringBuilder();
                                for (String userKey : userMetadata.keySet()) {
                                    userMetaBldr.append(userKey).append("=").append(userMetadata.get(userKey));
                                }
                                attributes.put(S3_USERMETA_ATTR_KEY, userMetaBldr.toString());
                            }
                            attributes.put(S3_API_METHOD_ATTR_KEY, S3_API_METHOD_MULTIPARTUPLOAD);
                        } catch (AmazonClientException e) {
                            getLogger().info("Failure completing upload flowfile={} bucket={} key={} reason={}",
                                    new Object[] { ffFilename, bucket, key, e.getMessage() });
                            throw (e);
                        }
                    }
                }
            }
        });

        if (!attributes.isEmpty()) {
            flowFile = session.putAllAttributes(flowFile, attributes);
        }
        session.transfer(flowFile, REL_SUCCESS);

        final String url = s3.getResourceUrl(bucket, key);
        final long millis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos);
        session.getProvenanceReporter().send(flowFile, url, millis);

        getLogger().info("Successfully put {} to Amazon S3 in {} milliseconds", new Object[] { ff, millis });
        try {
            removeLocalState(cacheKey);
        } catch (IOException e) {
            getLogger().info("Error trying to delete key {} from cache: {}",
                    new Object[] { cacheKey, e.getMessage() });
        }
    } catch (final ProcessException | AmazonClientException pe) {
        if (pe.getMessage().contains(S3_PROCESS_UNSCHEDULED_MESSAGE)) {
            getLogger().info(pe.getMessage());
            session.rollback();
        } else {
            getLogger().error("Failed to put {} to Amazon S3 due to {}", new Object[] { flowFile, pe });
            flowFile = session.penalize(flowFile);
            session.transfer(flowFile, REL_FAILURE);
        }
    }

}

From source file:org.apache.usergrid.apm.util.CrashLogUploadToS3Simulator.java

License:Apache License

public static boolean uploadSimulatedCrashLogsToS3(String appId, String fileName) {
    DeploymentConfig config = DeploymentConfig.geDeploymentConfig();
    AWSCredentials credentials = new BasicAWSCredentials(config.getAccessKey(), config.getSecretKey());
    AmazonS3Client s3Client = new AmazonS3Client(credentials);
    PutObjectRequest putObjectRequest;// www.ja v  a 2 s.co  m

    String s3FullFileName = config.getEnvironment() + "/crashlog/" + appId + "/" + fileName;

    try {

        ObjectMetadata metaData = new ObjectMetadata();

        metaData.setHeader(Headers.S3_CANNED_ACL, CannedAccessControlList.AuthenticatedRead);

        putObjectRequest = new PutObjectRequest(config.getS3LogBucket(), s3FullFileName,
                new ByteArrayInputStream(fileName.getBytes("UTF-8")), null);
        PutObjectResult result = s3Client.putObject(putObjectRequest);
        return true;

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return false;
}