Zig

Streaming Download Large File to the Local Filesystem

See more Azure Cloud Storage Examples

Downloads a large file in a streaming fashion to the local filesystem. Zig

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

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

    // Azure File Service Example: Downloads a large file to the local filesystem using a Chilkat stream.
    // See:  https://docs.microsoft.com/en-us/rest/api/storageservices/get-file

    // This example requires the Chilkat API to have been previously unlocked.
    // See Global Unlock Sample for sample code.

    const rest = try chilkat.Rest.init();
    defer rest.deinit();

    // Connect to the Azure Storage Blob Service
    const b_tls = true;
    const port = 443;
    const b_auto_reconnect = true;
    // In this example, the storage account name is "chilkat".
    rest.connect("chilkat.file.core.windows.net", port, b_tls, b_auto_reconnect) catch {
        std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
        return;
    };

    // Provide Azure Cloud credentials for the REST calls.
    const az_auth = try chilkat.AuthAzureStorage.init();
    defer az_auth.deinit();
    az_auth.setAccessKey("AZURE_ACCESS_KEY");
    // The account name used here should match the 1st part of the domain passed in the call to Connect (above).
    az_auth.setAccount("chilkat");
    az_auth.setScheme("SharedKey");
    az_auth.setService("File");
    // This causes the "x-ms-version: 2021-08-06" header to be automatically added.
    az_auth.setXMsVersion("2021-08-06");
    try rest.setAuthAzureStorage(az_auth);

    // Note: The application does not need to explicitly set the following
    // headers: x-ms-date, Authorization.  These headers
    // are automatically set by Chilkat.

    // When streaming a download to the local filesystem or directed elsewhere,
    // the complete HTTP GET operation must be broken into parts.
    // For example, an HTTP GET consists of sending the request, followed by reading the response header,
    // and then finally the response body.  We'll want to read the response header, and then based
    // on the information received (such as success or failure), either read the response body
    // as an error message, or as the file data.

    // Send the HTTP GET request to download the file.
    // The share is named "pip".
    rest.sendReqNoBody("GET", "/pip/somethingBig.zip") catch {
        std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
        return;
    };

    // Read the response header.
    const response_status_code = rest.readResponseHeader();
    if (response_status_code < 0) {
        std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
        return;
    }

    std.debug.print("Response status code = {d}\n", .{response_status_code});

    // We expect a 200 response status if the file data is coming.
    // Otherwise, we'll get a string response body with an error message(or no response body).
    if (response_status_code == 200) {
        const body_stream = try chilkat.Stream.init();
        defer body_stream.deinit();

        // The stream's sink will be a file.
        body_stream.setSinkFile("qa_output/somethingBig.zip");

        // Read the response body to the stream.  Given that we've
        // set the stream's sink to a file, it will stream directly
        // to the file.
        rest.readRespBodyStream(body_stream, true) catch {
            std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
            return;
        };

        std.debug.print("Successfully received the large file.\n", .{});
    } else {
        const err_response = rest.readRespBodyString(alloc) catch "";
        if (!rest.getLastMethodSuccess()) {
            std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
        } else {
            std.debug.print("{s}\n", .{err_response});
        }
    }
}