Rust

Azure File Service: Upload Large File

See more Azure Cloud Storage Examples

Sample code to upload a large file to a directory in a share in the Azure File Service. A file is uploaded by first creating the file in the Azure share and then writing ranges of bytes to the file. Azure imposes a 4MB limit for each PUT to write a range. Files larger than 4MB need to be uploaded by making multiple "Put Range" calls. This example uploads a large file requiring multiple "Put Range" calls. Rust

// Azure File Service Example: Upload a large file.  
// See:  https://docs.microsoft.com/en-us/rest/api/storageservices/create-share
// also see: https://docs.microsoft.com/en-us/rest/api/storageservices/put-range

// 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;
}

// This example will upload a larger file.
let local_file_path = "qa_data/zips/somethingBig.zip".to_string();
let fac = chilkat::FileAccess::new();
// Note: The FileSize method returns a signed 32-bit integer.  If the file is potentially larger than 2GB, call FileSizeStr instead to return
// the size of the file as a string, then convert to an integer value.
let sz_local_file = fac.file_size(&local_file_path);
if sz_local_file < 0 {
    println!("{}", fac.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.

// However, a few additional headers are required for the "Create File" operation:
let _ = rest.add_header("x-ms-type", "file");

// This required header specifies the final size of the file (or the maximum size it can be).
let sb_file_size = chilkat::StringBuilder::new();
let _ = sb_file_size.append_int(sz_local_file);
let _ = rest.add_header("x-ms-content-length", &sb_file_size.get_as_string().unwrap_or_default());

// Send a PUT request to create the file (or replace the file if it already exists).
// This will initialize the file in the Azure file storage.  To upload content, we'll need
// to do the "Put Range" operation one or more times.

// The following will create the file "somethingBig.zip" in the share "pip"
let Ok(response_str) = rest.full_request_no_body("PUT", "/pip/somethingBig.zip") else {
    println!("{}", rest.last_error_text());
    return;
};

// When successful, the Azure File Service will respond with a 201 (Created) response status code,
// with no XML response body.  If an error response is returned, there will be an XML response body.

if rest.response_status_code() != 201 {
    // Examine the request/response to see what happened.
    println!("response status code = {}", rest.response_status_code());
    println!("response status text = {}", rest.response_status_text());
    println!("response header: {}", rest.response_header());
    println!("response body (if any): {}", response_str);
    println!("---");
    println!("LastRequestStartLine: {}", rest.last_request_start_line());
    println!("LastRequestHeader: {}", rest.last_request_header());
    return;
}

println!("Successfully created somethingBig.zip");

// --------------------------------------------------------------------------------
// Upload the file data...

// Make sure the headers from the "Create File" operation are removed.
let _ = rest.clear_all_headers();

// The x-ms-write header is required for each "Put Range" request.
let _ = rest.add_header("x-ms-write", "update");

let sb_range = chilkat::StringBuilder::new();
let sb_response_body = chilkat::StringBuilder::new();
let bd_file_data = chilkat::BinData::new();

// Open the file.  We'll be reading and uploading in chunks..
if fac.open_for_read(&local_file_path).is_err() {
    println!("{}", fac.last_error_text());
    return;
}

let mut num_bytes_left = sz_local_file;
let mut cur_index = 0;
while num_bytes_left > 0 {

    let mut chunk_size = num_bytes_left;
    // Azure allows for 4MB max chunks  (4 x 1024 x 1024 = 4194304)
    if chunk_size > 4194304 {
        chunk_size = 4194304;
    }

    // The only tricky part here is to correctly add the x-ms-range header.
    // It will be formatted like this:
    // x-ms-range: bytes=0-759623
    sb_range.clear();
    let _ = sb_range.append("bytes=");
    let _ = sb_range.append_int(cur_index);
    let _ = sb_range.append("-");
    let _ = sb_range.append_int(cur_index + chunk_size - 1);

    // This replaces the header if it already exists..
    let _ = rest.add_header("x-ms-range", &sb_range.get_as_string().unwrap_or_default());

    // Read the next chunk from the local file.
    let _ = bd_file_data.clear();
    let _ = fac.file_read_bd(chunk_size, &bd_file_data).is_ok();

    if rest.full_request_bd("PUT", "/pip/somethingBig.zip?comp=range", &bd_file_data, &sb_response_body).is_err() {
        // This would indicate a failure where no response was received.
        println!("{}", rest.last_error_text());
        return;
    }

    // A 201 response indicates the chunk was uploaded.
    if rest.response_status_code() != 201 {
        // Examine the request/response to see what happened.
        println!("response status code = {}", rest.response_status_code());
        println!("response status text = {}", rest.response_status_text());
        println!("response header: {}", rest.response_header());
        println!("response body (if any): {}", response_str);
        println!("---");
        println!("LastRequestStartLine: {}", rest.last_request_start_line());
        println!("LastRequestHeader: {}", rest.last_request_header());
        return;
    }

    println!("Uploaded chunk from {} to {}", cur_index, cur_index + chunk_size - 1);

    cur_index = cur_index + chunk_size;
    num_bytes_left = num_bytes_left - chunk_size;
}

fac.file_close();

println!("success.");