Java

AWS S3 File Streaming Upload

See more Amazon S3 (new) Examples

Demonstrates how to do a streaming upload from a file to the AWS S3 storage service. The AWS authorization presents some difficulties when the REST request body is to be streamed from a file (or from some other source). The issue is that the SHA-256 hash of the file data must be calculated. There are only two possible ways to do this: (1) stream the file into memory in its entirety and calculate the SHA-256 hash prior to uploading, or (2) pre-calculate the SHA-256 in a streaming fashion, and then provide it to the AWS authentication object.

If the application does NOT pre-compute the SHA-256, then Chilkat (internally) is forced to stream into memory, calculate the SHA-256, and then upload from the in-memory copy of the file.

Chilkat2 Java

import com.chilkatsoft.chilkat2.AuthAws;
import com.chilkatsoft.chilkat2.ChilkatException;
import com.chilkatsoft.chilkat2.Crypt2;
import com.chilkatsoft.chilkat2.Rest;
import com.chilkatsoft.chilkat2.Stream;

public class ChilkatExample {

    public static void main(String[] args) {
        // This example requires the Chilkat API to have been previously unlocked.
        // See Global Unlock Sample for sample code.

        // This first part is optional.  AWS authentication requires
        // the SHA-256 hash of the request body (i.e. the contents of the file
        // to be uploaded).  We can choose to pre-calculate the SHA-256 in a streaming fashion
        // and then provide it to the authenticator object.  This way, if the file is
        // extremely large, it never needs to completely reside in memory.
        Crypt2 crypt = new Crypt2();
        crypt.setEncodingMode("hex");
        crypt.setHashAlgorithm("sha-256");
        String fileToUploadPath = "qa_data/xml/hamlet.xml";
        String hashStr = crypt.hashFileENC(fileToUploadPath);

        Rest rest = new Rest();

        // Connect to the Amazon AWS REST server.
        boolean bTls = true;
        int port = 443;
        boolean bAutoReconnect = true;
        rest.connect("s3.amazonaws.com", port, bTls, bAutoReconnect);

        // ----------------------------------------------------------------------------
        // Important: For buckets created in regions outside us-east-1,
        // there are three important changes that need to be made.
        // See Working with S3 Buckets in Non-us-east-1 Regions for the details.
        // ----------------------------------------------------------------------------

        // Provide AWS credentials for the REST call.
        AuthAws authAws = new AuthAws();
        authAws.setAccessKey("AWS_ACCESS_KEY");
        authAws.setSecretKey("AWS_SECRET_KEY");
        authAws.setServiceName("s3");
        // Provide the pre-computed SHA-256 here:
        authAws.setPrecomputedSha256(hashStr);

        rest.setAuthAws(authAws);

        // Set the bucket name via the HOST header.
        // In this case, the bucket name is "chilkat100".
        rest.setHost("chilkat100.s3.amazonaws.com");

        Stream fileStream = new Stream();
        fileStream.setSourceFile(fileToUploadPath);

        // Upload to the S3 Storage service.
        // If the application provided the SHA-256 hash of the file contents (as shown above)
        // then file is streamed and never has to completely reside in memory.
        // If the application did NOT provide the SHA-256, then Chilkat will (internally)
        // load the entire file into memory, calculate the SHA-256, and then upload.
        String responseStr;
        try {
            responseStr = rest.fullRequestStream("PUT", "/hamlet.xml", fileStream);
        } catch (ChilkatException e) {
            System.out.println(e.getLastErrorText());
            return;
        }

        // When successful, the S3 Storage service will respond with a 200 response code,
        // with an XML body.
        if (rest.getResponseStatusCode() == 200) {
            System.out.println(responseStr);
            System.out.println("File uploaded.");
        } else {
            // Examine the request/response to see what happened.
            System.out.println("response status code = " + rest.getResponseStatusCode());
            System.out.println("response status text = " + rest.getResponseStatusText());
            System.out.println("response header: " + rest.getResponseHeader());
            System.out.println("response body: " + responseStr);
            System.out.println("---");
            System.out.println("LastRequestStartLine: " + rest.getLastRequestStartLine());
            System.out.println("LastRequestHeader: " + rest.getLastRequestHeader());
        }
    }
}