Rust

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. Rust

// 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.

let rest = chilkat::Rest::new();

// Connect to the Azure Storage Blob Service
let b_tls = true;
let port = 443;
let b_auto_reconnect = true;
// In this example, the storage account name is "chilkat".
if rest.connect("chilkat.file.core.windows.net", port, b_tls, b_auto_reconnect).is_err() {
    println!("{}", rest.last_error_text());
    return;
}

// Provide Azure Cloud credentials for the REST calls.
let az_auth = chilkat::AuthAzureStorage::new();
az_auth.set_access_key("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.set_account("chilkat");
az_auth.set_scheme("SharedKey");
az_auth.set_service("File");
// This causes the "x-ms-version: 2021-08-06" header to be automatically added.
az_auth.set_x_ms_version("2021-08-06");
let _ = rest.set_auth_azure_storage(&az_auth).is_ok();

// 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".
if rest.send_req_no_body("GET", "/pip/somethingBig.zip").is_err() {
    println!("{}", rest.last_error_text());
    return;
}

// Read the response header.
let response_status_code = rest.read_response_header();
if response_status_code < 0 {
    println!("{}", rest.last_error_text());
    return;
}

println!("Response status code = {}", 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 {

    let body_stream = chilkat::Stream::new();

    // The stream's sink will be a file.
    body_stream.set_sink_file("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.
    if rest.read_resp_body_stream(&body_stream, true).is_err() {
        println!("{}", rest.last_error_text());
        return;
    }

    println!("Successfully received the large file.");

} else {
    let err_response = rest.read_resp_body_string().unwrap_or_default();
    if !rest.last_method_success() {
        println!("{}", rest.last_error_text());
    } else {
        println!("{}", err_response);
    }

}