Zig

Set Container ACL

See more Azure Cloud Storage Examples

Azure Storage Blob Service REST API: Sample code to set the permissions of a container. Zig

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

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

    // Azure Blob Service Example: Set Container ACL
    // See also: https://msdn.microsoft.com/en-us/library/azure/dd179391.aspx

    // 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.blob.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 call.
    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("Blob");
    // 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.

    // The XML body of the request will look like this:

    // <?xml version="1.0" encoding="utf-8"?>
    // <SignedIdentifiers>
    //   <SignedIdentifier>
    //     <Id>unique-character-value-of-up-to-64-chars</Id>
    //     <AccessPolicy>
    //       <Start>start-time</Start>
    //       <Expiry>expiry-time</Expiry>
    //       <Permission>abbreviated-permission-list</Permission>
    //     </AccessPolicy>
    //   </SignedIdentifier>
    // </SignedIdentifiers>

    // Generate a random 32-character string.
    const prng = try chilkat.Prng.init();
    defer prng.deinit();
    const random_id = try prng.randomString(alloc, 32, true, true, true);

    // Get the current system date/time in ISO 8061 format
    const dt = try chilkat.DateTime.init();
    defer dt.deinit();
    dt.setFromCurrentSystemTime() catch {};
    const b_local = false;
    // Get the current date/time in ISO 8061 UTC format.
    const cur_dt_str = try dt.getAsTimestamp(alloc, b_local);
    // The expire time will be 365 days in the future.
    try dt.addDays(365);
    const expire_dt_str = try dt.getAsTimestamp(alloc, b_local);

    // Build the request:
    const xml = try chilkat.Xml.init();
    defer xml.deinit();
    xml.setTag("SignedIdentifiers");
    const x_signed_id = try xml.newChild("SignedIdentifier", "");
    defer x_signed_id.deinit();
    x_signed_id.newChild2("Id", random_id);
    const x_access_policy = try x_signed_id.newChild("AccessPolicy", "");
    defer x_access_policy.deinit();
    x_access_policy.newChild2("Start", cur_dt_str);
    x_access_policy.newChild2("Expiry", expire_dt_str);
    x_access_policy.newChild2("Permission", "rwd");

    // Show the XML..
    std.debug.print("{s}\n", .{try xml.getXml(alloc)});

    // The expected response is a 200 response status code with no response body.
    const response_str = rest.fullRequestString(alloc, "PUT", "/mycontainer?restype=container&comp=acl", try xml.getXml(alloc)) catch {
        std.debug.print("{s}\n", .{try rest.getLastErrorText(alloc)});
        return;
    };

    // When successful, the Azure Storage service will respond with a 200 response status code,
    // with no response body.

    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 (if any): {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;
    }

    std.debug.print("Success.\n", .{});
}