Zig

S3 Upload the Parts for a Multipart Upload

See more Amazon S3 (new) Examples

This example uploads a large file in parts. The multipart upload needs to have been first initiated prior to uploading the parts.

See http://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html for more information about uploading parts.

Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

    // In the 1st step for uploading a large file, the multipart upload was initiated
    // as shown here: Initiate Multipart Upload

    // Other S3 Multipart Upload Examples:
    // Complete Multipart Upload
    // Abort Multipart Upload
    // List Parts

    // When we initiated the multipart upload, we saved the XML response to a file.  This
    // XML response contains the UploadId.  We'll begin by loading that XML and getting
    // the Upload ID.

    const xml_init = try chilkat.Xml.init();
    defer xml_init.deinit();
    xml_init.loadXmlFile("s3_multipart_uploads/initiate.xml") catch {
        std.debug.print("Did not find the initiate.xml XML file.\n", .{});
        return;
    };

    const upload_id = try xml_init.getChildContent(alloc, "UploadId");
    std.debug.print("UploadId = {s}\n", .{upload_id});

    // When uploading parts, we need to keep an XML record of each part number
    // and its corresponding ETag, which is received in the response for each part.
    // There can be up to 10000 parts, numbered 1 to 10000.
    // After all parts have been uploaded, the final step will be to complete
    // the multipart upload (see Complete Multipart Upload)

    // In this example, the large file we want to upload is somethingBig.zip
    const file_to_upload_path = "s3_multipart_uploads/somethingBig.zip";

    // The minimum allowed part size is 5MB (5242880 bytes).  The last part can be smaller because
    // it will contain the remainder of the file.  (This minimum is enforced by the AWS service.)
    // We'll use the minimum allowed part size for this example.
    const part_size = 5242880;

    // Let's use Chilkat's FileAccess API to examine the file to be uploaded.  We'll get the size
    // of the file and find out how many parts will be needed, including the final "partial" part.
    const fac = try chilkat.FileAccess.init();
    defer fac.deinit();
    fac.openForRead(file_to_upload_path) catch {};

    // How many parts will there be if each part is 5242880 bytes?
    const num_parts = fac.getNumBlocks(part_size);
    std.debug.print("numParts = {d}\n", .{num_parts});
    fac.fileClose();

    // Imagine that we may be running this for the 1st time, or maybe we already
    // attempted to upload parts, and something failed. Maybe there was a network problem
    // the resulted in not all parts getting uploaded.  We'll write this code so that if run again,
    // it will upload whatever parts haven't yet been uploaded.

    // We'll keep a partsList.xml file to record the parts that have already been successfully
    // uploaded.  If this file does not yet exist, we'll create it..
    const parts_list_file = "s3_multipart_uploads/partsList.xml";
    const parts_list_xml = try chilkat.Xml.init();
    defer parts_list_xml.deinit();
    if (fac.fileExists(parts_list_file)) {
        parts_list_xml.loadXmlFile(parts_list_file) catch {};
    }

    // Make sure the top-level tag is "CompleteMultipartUpload"
    parts_list_xml.setTag("CompleteMultipartUpload");

    // --------------------------------------
    // Before entering the loop to upload parts,
    // setup the REST object with AWS authentication,
    // and make the initial connection.
    const rest = try chilkat.Rest.init();
    defer rest.deinit();

    // Connect to the Amazon AWS REST server.
    const b_tls = true;
    const port = 443;
    const b_auto_reconnect = true;
    try rest.connect("s3.amazonaws.com", port, b_tls, b_auto_reconnect);

    // ----------------------------------------------------------------------------
    // 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.
    const auth_aws = try chilkat.AuthAws.init();
    defer auth_aws.deinit();
    auth_aws.setAccessKey("AWS_ACCESS_KEY");
    auth_aws.setSecretKey("AWS_SECRET_KEY");
    auth_aws.setServiceName("s3");
    try rest.setAuthAws(auth_aws);

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

    var part_number: i32 = 1;
    const sb_part_number = try chilkat.StringBuilder.init();
    defer sb_part_number.deinit();

    while (part_number <= num_parts) {
        std.debug.print("---- {d} ----\n", .{part_number});

        // This cumbersome way of converting an integer to a string is because
        // Chilkat examples are written in a script that is converted to many programming languages.
        // At this time, the translator does not have integer-to-string code generation capability..
        sb_part_number.clear();
        sb_part_number.appendInt(part_number) catch {};

        var b_part_already_uploaded: bool = false;

        // If there are no children, then the XML is empty and no parts have yet been uploaded.
        const num_uploaded_parts = parts_list_xml.getNumChildren();
        if (num_uploaded_parts > 0) {
            // If some parts have been uploaded, check to see if this particular part was already upload.
            // If so, then it can be skipped.

            // Position ourselves at the 1st record.
            const x_rec0 = try parts_list_xml.getChild(0);
            defer x_rec0.deinit();
            if (x_rec0.findNextRecord("PartNumber", try sb_part_number.getAsString(alloc))) |found_rec| {
                defer found_rec.deinit();
                b_part_already_uploaded = true;
                std.debug.print("Part {d} was previously uploaded.\n", .{part_number});
                std.debug.print("{s}\n", .{try found_rec.getXml(alloc)});
            } else |_| {}
        }

        // If this part was not already uploaded, we need to upload.
        // Also update the partsListXml and save as each part is successfully uploaded.
        if (!b_part_already_uploaded) {
            std.debug.print("Uploading part {d} ...\n", .{part_number});

            // Setup the stream source for the large file to be uploaded..
            const file_stream = try chilkat.Stream.init();
            defer file_stream.deinit();
            file_stream.setSourceFile(file_to_upload_path);
            // The Chilkat Stream API has features to make uploading a parts
            // of a file easy.  Indicate the part size by setting the SourceFilePartSize
            // property.
            file_stream.setSourceFilePartSize(part_size);

            // Our HTTP start line to upload a part will look like this:
            // PUT /ObjectName?partNumber=PartNumber&uploadId=UploadId HTTP/1.1

            // Set the query params.  We'll need partNumber and uploadId.
            // Make sure the query params from previous iterations are clear.
            rest.clearAllQueryParams() catch {};
            rest.addQueryParam("partNumber", try sb_part_number.getAsString(alloc)) catch {};
            rest.addQueryParam("uploadId", upload_id) catch {};

            // Upload this particular file part.
            // Tell the fileStream which part is being uploaded.
            // Our partNumber is 1-based (the 1st part is at index 1), but the fileStream's SourceFilePart
            // property is 0-based.  Therefore we use partNumber-1.
            file_stream.setSourceFilePart(part_number - 1);

            // Because the SourceFilePart and SourceFilePartSize properties are set, the stream will
            // will provide just that part of the file.
            const response_str = rest.fullRequestStream(alloc, "PUT", "/somethingBig.zip", file_stream) catch {
                std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
                return;
            };

            if (rest.getResponseStatusCode() != 200) {
                // Examine the request/response to see what happened.
                std.debug.print("response status code = {d}\n", .{rest.getResponseStatusCode()});
                std.debug.print("response status text = {s}\n", .{try rest.getResponseStatusText(alloc)});
                std.debug.print("response header: {s}\n", .{try rest.getResponseHeader(alloc)});
                std.debug.print("response body: {s}\n", .{response_str});
                std.debug.print("---\n", .{});
                std.debug.print("LastRequestStartLine: {s}\n", .{try rest.getLastRequestStartLine(alloc)});
                std.debug.print("LastRequestHeader: {s}\n", .{try rest.getLastRequestHeader(alloc)});
                return;
            }

            // OK, this part was uploaded..
            // The response will have a 0-length body.  The only information we need is the
            // ETag response header field.
            // It should be present, but just in case there was no ETag header...
            const etag = rest.responseHdrByName(alloc, "ETag") catch {
                std.debug.print("No ETag response header found!\n", .{});
                std.debug.print("response header: {s}\n", .{try rest.getResponseHeader(alloc)});
                return;
            };

            // We need to add record to the partsListXml.
            // The record will look like this:
            // &lt;Part>
            //   &lt;PartNumber>PartNumber&lt;/PartNumber>
            //   &lt;ETag>ETag&lt;/ETag>
            // &lt;/Part>
            const x_part = try parts_list_xml.newChild("Part", "");
            defer x_part.deinit();
            x_part.newChildInt2("PartNumber", part_number);
            x_part.newChild2("ETag", etag);

            parts_list_xml.saveXml(parts_list_file) catch {
                std.debug.print("{s}\n", .{try parts_list_xml.getLastErrorText(alloc)});
                return;
            };

            std.debug.print("-- Part {d} uploaded. ---------------------\n", .{part_number});
        }

        part_number = part_number + 1;
    }

    std.debug.print("Finished.  All parts uploaded.\n", .{});
}