lobo/aws-sdk-for-zig
1
0
Fork 0
Code Issues Pull requests Projects 1 Releases Packages 1 Wiki Activity Actions

changes for zig 0.16.0
Some checks failed
aws-zig nightly build / build-zig-nightly (push) Failing after 23m34s
Details

Browse source
This commit is contained in:
Emil Lerch 2026-04-16 16:22:48 -07:00
parent a3d0718e7b
commit abd422edb7
Signed by: lobo
GPG key ID: A7B62D657EF764F8
20 changed files with 312 additions and 318 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -12,3 +12,4 @@ src/git_version.zig
zig-out zig-out
core core
.zig-cache .zig-cache
zig-pkg/

63
build.zig
View file

@ -47,7 +47,7 @@ pub fn build(b: *Builder) !void {
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
}); });
configure(mod_exe, dep_mods, true); configure(mod_exe, dep_mods);
const exe = b.addExecutable(.{ const exe = b.addExecutable(.{
.name = "demo", .name = "demo",
@ -72,7 +72,7 @@ pub fn build(b: *Builder) !void {
.target = b.graph.host, .target = b.graph.host,
.optimize = if (b.verbose) .Debug else .ReleaseSafe, .optimize = if (b.verbose) .Debug else .ReleaseSafe,
}); });
configure(cg_mod, dep_mods, false); configure(cg_mod, dep_mods);
const cg_exe = b.addExecutable(.{ const cg_exe = b.addExecutable(.{
.name = "codegen", .name = "codegen",
@ -133,7 +133,7 @@ pub fn build(b: *Builder) !void {
// consuming build.zig files to be able to use the SDK at build time for // consuming build.zig files to be able to use the SDK at build time for
// things like code deployments, e.g. https://git.lerch.org/lobo/lambda-zig // things like code deployments, e.g. https://git.lerch.org/lobo/lambda-zig
const has_pre_generated = const has_pre_generated =
if (b.build_root.handle.access("src/models/service_manifest.zig", .{})) true else |_| false; if (b.build_root.handle.access(b.graph.io, "src/models/service_manifest.zig", .{})) true else |_| false;
// Only depend on codegen if we don't have pre-generated models // Only depend on codegen if we don't have pre-generated models
if (!has_pre_generated) if (!has_pre_generated)
@ -150,7 +150,7 @@ pub fn build(b: *Builder) !void {
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
}); });
configure(service_manifest_module, dep_mods, true); configure(service_manifest_module, dep_mods);
mod_exe.addImport("service_manifest", service_manifest_module); mod_exe.addImport("service_manifest", service_manifest_module);
@ -161,13 +161,13 @@ pub fn build(b: *Builder) !void {
.optimize = optimize, .optimize = optimize,
}); });
mod_aws.addImport("service_manifest", service_manifest_module); mod_aws.addImport("service_manifest", service_manifest_module);
configure(mod_aws, dep_mods, true); configure(mod_aws, dep_mods);
// Expose module to others // Expose module to others
const mod_aws_signing = b.addModule("aws-signing", .{ const mod_aws_signing = b.addModule("aws-signing", .{
.root_source_file = b.path("src/aws_signing.zig"), .root_source_file = b.path("src/aws_signing.zig"),
}); });
configure(mod_aws_signing, dep_mods, false); configure(mod_aws_signing, dep_mods);
// Similar to creating the run step earlier, this exposes a `test` step to // Similar to creating the run step earlier, this exposes a `test` step to
// the `zig build --help` menu, providing a way for the user to request // the `zig build --help` menu, providing a way for the user to request
@ -197,7 +197,7 @@ pub fn build(b: *Builder) !void {
.optimize = optimize, .optimize = optimize,
}); });
mod_unit_tests.addImport("service_manifest", service_manifest_module); mod_unit_tests.addImport("service_manifest", service_manifest_module);
configure(mod_unit_tests, dep_mods, true); configure(mod_unit_tests, dep_mods);
// Creates a step for unit testing. This only builds the test executable // Creates a step for unit testing. This only builds the test executable
// but does not run it. // but does not run it.
@ -250,12 +250,11 @@ pub fn build(b: *Builder) !void {
package.dependOn(&pkg_step.step); package.dependOn(&pkg_step.step);
} }
fn configure(compile: *std.Build.Module, modules: std.StringHashMap(*std.Build.Module), include_time: bool) void { fn configure(compile: *std.Build.Module, modules: std.StringHashMap(*std.Build.Module)) void {
compile.addImport("smithy", modules.get("smithy").?); compile.addImport("smithy", modules.get("smithy").?);
compile.addImport("date", modules.get("date").?); compile.addImport("date", modules.get("date").?);
compile.addImport("json", modules.get("json").?); compile.addImport("json", modules.get("json").?);
compile.addImport("case", modules.get("case").?); compile.addImport("case", modules.get("case").?);
if (include_time) compile.addImport("zeit", modules.get("zeit").?);
} }
fn getDependencyModules(b: *std.Build, args: anytype) !std.StringHashMap(*std.Build.Module) { fn getDependencyModules(b: *std.Build, args: anytype) !std.StringHashMap(*std.Build.Module) {
@ -266,10 +265,6 @@ fn getDependencyModules(b: *std.Build, args: anytype) !std.StringHashMap(*std.Bu
const mod_smithy = dep_smithy.module("smithy"); const mod_smithy = dep_smithy.module("smithy");
try result.putNoClobber("smithy", mod_smithy); try result.putNoClobber("smithy", mod_smithy);
const dep_zeit = b.dependency("zeit", args);
const mod_zeit = dep_zeit.module("zeit");
try result.putNoClobber("zeit", mod_zeit);
const dep_case = b.dependency("case", args); const dep_case = b.dependency("case", args);
const mod_case = dep_case.module("case"); const mod_case = dep_case.module("case");
try result.putNoClobber("case", mod_case); try result.putNoClobber("case", mod_case);
@ -329,6 +324,7 @@ const PackageStep = struct {
_ = options; _ = options;
const self: *PackageStep = @fieldParentPtr("step", step); const self: *PackageStep = @fieldParentPtr("step", step);
const b = step.owner; const b = step.owner;
const io = b.graph.io;
// Get the path to generated models // Get the path to generated models
const models_path = self.cg_output_dir.getPath2(b, &self.step); const models_path = self.cg_output_dir.getPath2(b, &self.step);
@ -336,17 +332,17 @@ const PackageStep = struct {
// Create output directory for packaging // Create output directory for packaging
const package_dir = b.pathJoin(&.{ "zig-out", "package" }); const package_dir = b.pathJoin(&.{ "zig-out", "package" });
const models_dest_dir = b.pathJoin(&.{ package_dir, "src", "models" }); const models_dest_dir = b.pathJoin(&.{ package_dir, "src", "models" });
std.fs.cwd().makePath(models_dest_dir) catch |err| { std.Io.Dir.cwd().createDirPath(io, models_dest_dir) catch |err| {
return step.fail("Failed to create package directory: {}", .{err}); return step.fail("Failed to create package directory: {}", .{err});
}; };
// Copy all source files to package directory // Copy all source files to package directory
for (package_files) |file_name| for (package_files) |file_name|
copyFile(b, b.build_root.handle, file_name, package_dir) catch {}; copyFile(io, b, b.build_root.handle, file_name, package_dir) catch {};
// Copy directories // Copy directories
for (package_dirs) |dir_name| for (package_dirs) |dir_name|
copyDirRecursive(b, b.build_root.handle, dir_name, package_dir) catch |err| { copyDirRecursive(io, b, b.build_root.handle, dir_name, package_dir) catch |err| {
return step.fail("Failed to copy directory '{s}': {}", .{ dir_name, err }); return step.fail("Failed to copy directory '{s}': {}", .{ dir_name, err });
}; };
@ -358,24 +354,24 @@ const PackageStep = struct {
step.result_cached = false; step.result_cached = false;
} }
fn copyFile(b: *std.Build, src_dir: std.fs.Dir, file_path: []const u8, dest_prefix: []const u8) !void { fn copyFile(io: std.Io, b: *std.Build, src_dir: std.Io.Dir, file_path: []const u8, dest_prefix: []const u8) !void {
const dest_path = b.pathJoin(&.{ dest_prefix, file_path }); const dest_path = b.pathJoin(&.{ dest_prefix, file_path });
// Ensure parent directory exists // Ensure parent directory exists
if (std.fs.path.dirname(dest_path)) |parent| if (std.fs.path.dirname(dest_path)) |parent|
std.fs.cwd().makePath(parent) catch {}; std.Io.Dir.cwd().createDirPath(io, parent) catch {};
src_dir.copyFile(file_path, std.fs.cwd(), dest_path, .{}) catch return; src_dir.copyFile(file_path, std.Io.Dir.cwd(), dest_path, io, .{}) catch return;
} }
fn copyDirRecursive(b: *std.Build, src_base: std.fs.Dir, dir_path: []const u8, dest_prefix: []const u8) !void { fn copyDirRecursive(io: std.Io, b: *std.Build, src_base: std.Io.Dir, dir_path: []const u8, dest_prefix: []const u8) !void {
var src_dir = src_base.openDir(dir_path, .{ .iterate = true }) catch return; var src_dir = src_base.openDir(io, dir_path, .{ .iterate = true }) catch return;
defer src_dir.close(); defer src_dir.close(io);
var walker = try src_dir.walk(b.allocator); var walker = try src_dir.walk(b.allocator);
defer walker.deinit(); defer walker.deinit();
while (try walker.next()) |entry| { while (try walker.next(io)) |entry| {
// Skip zig build artifact directories // Skip zig build artifact directories
if (std.mem.indexOf(u8, entry.path, "zig-out") != null or if (std.mem.indexOf(u8, entry.path, "zig-out") != null or
std.mem.indexOf(u8, entry.path, ".zig-cache") != null or std.mem.indexOf(u8, entry.path, ".zig-cache") != null or
@ -386,22 +382,22 @@ const PackageStep = struct {
const dest_path = b.pathJoin(&.{ dest_prefix, dir_path, entry.path }); const dest_path = b.pathJoin(&.{ dest_prefix, dir_path, entry.path });
switch (entry.kind) { switch (entry.kind) {
.directory => std.fs.cwd().makePath(dest_path) catch {}, .directory => std.Io.Dir.cwd().createDirPath(io, dest_path) catch {},
.file => { .file => {
// Ensure parent directory exists // Ensure parent directory exists
if (std.fs.path.dirname(dest_path)) |parent| { if (std.fs.path.dirname(dest_path)) |parent| {
std.fs.cwd().makePath(parent) catch {}; std.Io.Dir.cwd().createDirPath(io, parent) catch {};
} }
src_base.copyFile(src_path, std.fs.cwd(), dest_path, .{}) catch {}; src_base.copyFile(src_path, std.Io.Dir.cwd(), dest_path, io, .{}) catch {};
}, },
.sym_link => { .sym_link => {
var link_buf: [std.fs.max_path_bytes]u8 = undefined; var link_buf: [std.fs.max_path_bytes]u8 = undefined;
const link_target = entry.dir.readLink(entry.basename, &link_buf) catch continue; const link_target = entry.dir.readLink(io, entry.basename, &link_buf) catch continue;
// Ensure parent directory exists // Ensure parent directory exists
if (std.fs.path.dirname(dest_path)) |parent| { if (std.fs.path.dirname(dest_path)) |parent| {
std.fs.cwd().makePath(parent) catch {}; std.Io.Dir.cwd().createDirPath(io, parent) catch {};
} }
std.fs.cwd().symLink(link_target, dest_path, .{}) catch {}; std.Io.Dir.cwd().symLink(io, link_buf[0..link_target], dest_path, .{}) catch {};
}, },
else => {}, else => {},
} }
@ -409,16 +405,17 @@ const PackageStep = struct {
} }
fn copyGeneratedModels(b: *std.Build, models_path: []const u8, models_dest_dir: []const u8) !void { fn copyGeneratedModels(b: *std.Build, models_path: []const u8, models_dest_dir: []const u8) !void {
var models_dir = std.fs.cwd().openDir(models_path, .{ .iterate = true }) catch const io = b.graph.io;
var models_dir = std.Io.Dir.cwd().openDir(io, models_path, .{ .iterate = true }) catch
return error.ModelsNotFound; return error.ModelsNotFound;
defer models_dir.close(); defer models_dir.close(io);
var iter = models_dir.iterate(); var iter = models_dir.iterate();
while (try iter.next()) |entry| { while (try iter.next(io)) |entry| {
if (entry.kind != .file) continue; if (entry.kind != .file) continue;
const dest_path = b.pathJoin(&.{ models_dest_dir, entry.name }); const dest_path = b.pathJoin(&.{ models_dest_dir, entry.name });
models_dir.copyFile(entry.name, std.fs.cwd(), dest_path, .{}) catch continue; models_dir.copyFile(entry.name, std.Io.Dir.cwd(), dest_path, io, .{}) catch continue;
} }
} }
}; };

10
build.zig.zon
View file

@ -11,7 +11,7 @@
"README.md", "README.md",
"LICENSE", "LICENSE",
}, },
.minimum_zig_version = "0.15.1", .minimum_zig_version = "0.16.0",
.dependencies = .{ .dependencies = .{
.smithy = .{ .smithy = .{
@ -29,12 +29,8 @@
.path = "lib/json", .path = "lib/json",
}, },
.case = .{ .case = .{
.url = "git+https://github.com/travisstaloch/case.git#f8003fe5f93b65f673d10d41323e347225e8cb87", .url = "git+https://github.com/elerch/case?ref=zig-0.16.0#82017a92e179031f21896d02262ae1e216459e4f",
.hash = "case-0.0.1-chGYqx_EAADaGJjmoln5M1iMBDTrMdd8to5wdEVpfXm4", .hash = "case-0.0.1-chGYq1fEAAAN4h3YRmkh9OTDvuUyjmoXr6PhYAUzjU0D",
},
.zeit = .{
.url = "git+https://github.com/elerch/zeit#8190461dc1f892f6370fa9d5cd76690aac0e1c71",
.hash = "zeit-0.6.0-5I6bk99-AgDNMIDuw2Zcoe_9QYIpzwZJqeqMpU54egTd",
}, },
}, },
} }

2
codegen/src/GenerationState.zig
View file

@ -39,7 +39,7 @@ pub fn indent(self: @This()) GenerationState {
pub fn deindent(self: @This()) GenerationState { pub fn deindent(self: @This()) GenerationState {
var new_state = self.clone(); var new_state = self.clone();
new_state.indent_level = @max(0, new_state.indent_level - 1); new_state.indent_level = if (new_state.indent_level == 0) 0 else new_state.indent_level - 1;
return new_state; return new_state;
} }

63
codegen/src/Hasher.zig
View file

@ -8,7 +8,7 @@ pub const HashedFile = struct {
hash: [Hash.digest_length]u8, hash: [Hash.digest_length]u8,
failure: Error!void, failure: Error!void,
const Error = std.fs.File.OpenError || std.fs.File.ReadError || std.fs.File.StatError; const Error = std.Io.File.OpenError || std.Io.File.ReadStreamingError || std.Io.File.StatError;
fn lessThan(context: void, lhs: *const HashedFile, rhs: *const HashedFile) bool { fn lessThan(context: void, lhs: *const HashedFile, rhs: *const HashedFile) bool {
_ = context; _ = context;
@ -76,13 +76,13 @@ pub fn hex64(x: u64) [16]u8 {
return result; return result;
} }
pub const walkerFn = *const fn (std.fs.Dir.Walker.Entry) bool; pub const walkerFn = *const fn (std.Io.Dir.Walker.Entry) bool;
fn included(entry: std.fs.Dir.Walker.Entry) bool { fn included(entry: std.Io.Dir.Walker.Entry) bool {
_ = entry; _ = entry;
return true; return true;
} }
fn excluded(entry: std.fs.Dir.Walker.Entry) bool { fn excluded(entry: std.Io.Dir.Walker.Entry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -94,33 +94,33 @@ pub const ComputeDirectoryOptions = struct {
}; };
pub fn computeDirectoryHash( pub fn computeDirectoryHash(
thread_pool: *std.Thread.Pool, allocator: std.mem.Allocator,
dir: std.fs.Dir, io: std.Io,
dir: std.Io.Dir,
options: *ComputeDirectoryOptions, options: *ComputeDirectoryOptions,
) ![Hash.digest_length]u8 { ) ![Hash.digest_length]u8 {
const gpa = thread_pool.allocator;
// We'll use an arena allocator for the path name strings since they all // We'll use an arena allocator for the path name strings since they all
// need to be in memory for sorting. // need to be in memory for sorting.
var arena_instance = std.heap.ArenaAllocator.init(gpa); var arena_instance = std.heap.ArenaAllocator.init(allocator);
defer arena_instance.deinit(); defer arena_instance.deinit();
const arena = arena_instance.allocator(); const arena = arena_instance.allocator();
// Collect all files, recursively, then sort. // Collect all files, recursively, then sort.
// Normally we're looking at around 300 model files // Normally we're looking at around 300 model files
var all_files = try std.ArrayList(*HashedFile).initCapacity(gpa, 300); var all_files = try std.ArrayList(*HashedFile).initCapacity(allocator, 300);
defer all_files.deinit(gpa); defer all_files.deinit(allocator);
var walker = try dir.walk(gpa); var walker = try dir.walk(allocator);
defer walker.deinit(); defer walker.deinit();
{ {
// The final hash will be a hash of each file hashed independently. This // The final hash will be a hash of each file hashed independently. This
// allows hashing in parallel. // allows hashing in parallel.
var wait_group: std.Thread.WaitGroup = .{}; var g: std.Io.Group = .init;
defer wait_group.wait(); errdefer g.cancel(io);
while (try walker.next()) |entry| { while (try walker.next(io)) |entry| {
switch (entry.kind) { switch (entry.kind) {
.directory => continue, .directory => continue,
.file => {}, .file => {},
@ -128,7 +128,7 @@ pub fn computeDirectoryHash(
} }
if (options.isExcluded(entry) or !options.isIncluded(entry)) if (options.isExcluded(entry) or !options.isIncluded(entry))
continue; continue;
const alloc = if (options.needFileHashes) gpa else arena; const alloc = if (options.needFileHashes) allocator else arena;
const hashed_file = try alloc.create(HashedFile); const hashed_file = try alloc.create(HashedFile);
const fs_path = try alloc.dupe(u8, entry.path); const fs_path = try alloc.dupe(u8, entry.path);
hashed_file.* = .{ hashed_file.* = .{
@ -137,11 +137,11 @@ pub fn computeDirectoryHash(
.hash = undefined, // to be populated by the worker .hash = undefined, // to be populated by the worker
.failure = undefined, // to be populated by the worker .failure = undefined, // to be populated by the worker
}; };
wait_group.start(); g.async(io, workerHashFile, .{ io, dir, hashed_file, &g });
try thread_pool.spawn(workerHashFile, .{ dir, hashed_file, &wait_group });
try all_files.append(gpa, hashed_file); try all_files.append(allocator, hashed_file);
} }
try g.await(io);
} }
std.mem.sort(*HashedFile, all_files.items, {}, HashedFile.lessThan); std.mem.sort(*HashedFile, all_files.items, {}, HashedFile.lessThan);
@ -156,23 +156,26 @@ pub fn computeDirectoryHash(
hasher.update(&hashed_file.hash); hasher.update(&hashed_file.hash);
} }
if (any_failures) return error.DirectoryHashUnavailable; if (any_failures) return error.DirectoryHashUnavailable;
if (options.needFileHashes) options.fileHashes = try all_files.toOwnedSlice(gpa); if (options.needFileHashes) options.fileHashes = try all_files.toOwnedSlice(allocator);
return hasher.finalResult(); return hasher.finalResult();
} }
fn workerHashFile(dir: std.fs.Dir, hashed_file: *HashedFile, wg: *std.Thread.WaitGroup) void { fn workerHashFile(io: std.Io, dir: std.Io.Dir, hashed_file: *HashedFile, wg: *std.Io.Group) void {
defer wg.finish(); _ = wg; // assume here that 0.16.0 Io.Group no longer needs to be notified at the time of completion
hashed_file.failure = hashFileFallible(dir, hashed_file); hashed_file.failure = hashFileFallible(io, dir, hashed_file);
} }
fn hashFileFallible(dir: std.fs.Dir, hashed_file: *HashedFile) HashedFile.Error!void { fn hashFileFallible(io: std.Io, dir: std.Io.Dir, hashed_file: *HashedFile) HashedFile.Error!void {
var buf: [8000]u8 = undefined; var buf: [8000]u8 = undefined;
var file = try dir.openFile(hashed_file.fs_path, .{}); var file = try dir.openFile(io, hashed_file.fs_path, .{});
defer file.close(); defer file.close(io);
var hasher = Hash.init(.{}); var hasher = Hash.init(.{});
hasher.update(hashed_file.normalized_path); hasher.update(hashed_file.normalized_path);
hasher.update(&.{ 0, @intFromBool(try isExecutable(file)) }); hasher.update(&.{ 0, @intFromBool(try isExecutable(io, file)) });
while (true) { while (true) {
const bytes_read = try file.read(&buf); const bytes_read = file.readStreaming(io, &.{&buf}) catch |err| switch (err) {
error.EndOfStream => break,
else => return err,
};
if (bytes_read == 0) break; if (bytes_read == 0) break;
hasher.update(buf[0..bytes_read]); hasher.update(buf[0..bytes_read]);
} }
@ -197,7 +200,7 @@ fn normalizePath(arena: std.mem.Allocator, fs_path: []const u8) ![]const u8 {
return normalized; return normalized;
} }
fn isExecutable(file: std.fs.File) !bool { fn isExecutable(io: std.Io, file: std.Io.File) !bool {
if (builtin.os.tag == .windows) { if (builtin.os.tag == .windows) {
// TODO check the ACL on Windows. // TODO check the ACL on Windows.
// Until this is implemented, this could be a false negative on // Until this is implemented, this could be a false negative on
@ -205,7 +208,7 @@ fn isExecutable(file: std.fs.File) !bool {
// when unpacking the tarball. // when unpacking the tarball.
return false; return false;
} else { } else {
const stat = try file.stat(); const stat = try file.stat(io);
return (stat.mode & std.posix.S.IXUSR) != 0; return stat.kind == .file and (stat.permissions.toMode() & std.posix.S.IXUSR != 0);
} }
} }

141
codegen/src/main.zig
View file

@ -25,27 +25,21 @@ const next_version = std.SemanticVersion.parse(next_version_str) catch unreachab
const zig_version = @import("builtin").zig_version; const zig_version = @import("builtin").zig_version;
const is_next = zig_version.order(next_version) == .eq or zig_version.order(next_version) == .gt; const is_next = zig_version.order(next_version) == .eq or zig_version.order(next_version) == .gt;
pub fn main() anyerror!void { pub fn main(init: std.process.Init) anyerror!void {
const root_progress_node = std.Progress.start(.{}); const io = init.io;
const root_progress_node = std.Progress.start(io, .{});
defer root_progress_node.end(); defer root_progress_node.end();
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); const allocator = init.arena.allocator();
defer arena.deinit();
const allocator = arena.allocator();
var threaded: std.Io.Threaded = .init(allocator); const args = try init.minimal.args.toSlice(allocator);
defer threaded.deinit(); var stdout_writer = std.Io.File.stdout().writer(io, &.{});
const io = threaded.io();
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
var stdout_writer = std.fs.File.stdout().writer(&.{});
const stdout = &stdout_writer.interface; const stdout = &stdout_writer.interface;
var output_dir = std.fs.cwd(); var output_dir = std.Io.Dir.cwd();
defer if (output_dir.fd > 0) output_dir.close(); defer if (output_dir.handle > 0) output_dir.close(io);
var models_dir: ?std.fs.Dir = null; var models_dir: ?std.Io.Dir = null;
defer if (models_dir) |*m| m.close(); defer if (models_dir) |*m| m.close(io);
for (args, 0..) |arg, i| { for (args, 0..) |arg, i| {
if (std.mem.eql(u8, "--help", arg) or if (std.mem.eql(u8, "--help", arg) or
std.mem.eql(u8, "-h", arg)) std.mem.eql(u8, "-h", arg))
@ -55,15 +49,17 @@ pub fn main() anyerror!void {
try stdout.print(" --output specifies an output directory, otherwise the current working directory will be used\n", .{}); try stdout.print(" --output specifies an output directory, otherwise the current working directory will be used\n", .{});
std.process.exit(0); std.process.exit(0);
} }
if (std.mem.eql(u8, "--output", arg)) if (std.mem.eql(u8, "--output", arg)) {
output_dir = try output_dir.makeOpenPath(args[i + 1], .{}); try output_dir.createDirPath(io, args[i + 1]);
output_dir = try std.Io.Dir.cwd().openDir(io, args[i + 1], .{ .iterate = true });
}
if (std.mem.eql(u8, "--models", arg)) if (std.mem.eql(u8, "--models", arg))
models_dir = try std.fs.cwd().openDir(args[i + 1], .{ .iterate = true }); models_dir = try std.Io.Dir.cwd().openDir(io, args[i + 1], .{ .iterate = true });
} }
var manifest_file = try output_dir.createFile("service_manifest.zig", .{}); var manifest_file = try output_dir.createFile(io, "service_manifest.zig", .{});
defer manifest_file.close(); defer manifest_file.close(io);
var manifest = manifest_file.writer(&manifest_buf).interface; var manifest = manifest_file.writer(io, &manifest_buf).interface;
defer manifest.flush() catch @panic("Could not flush service manifest"); defer manifest.flush() catch @panic("Could not flush service manifest");
var files_processed: usize = 0; var files_processed: usize = 0;
var skip_next = true; var skip_next = true;
@ -92,20 +88,20 @@ pub fn main() anyerror!void {
// can be made // can be made
if (models_dir) |m| { if (models_dir) |m| {
var cwd = try std.fs.cwd().openDir(".", .{}); var cwd = try std.Io.Dir.cwd().openDir(io, ".", .{});
defer cwd.close(); defer cwd.close(io);
defer cwd.setAsCwd() catch unreachable; defer std.process.setCurrentDir(io, cwd) catch unreachable;
try m.setAsCwd(); try std.process.setCurrentDir(io, m);
try processDirectories(io, m, output_dir, &root_progress_node); try processDirectories(io, m, output_dir, &root_progress_node);
} }
} }
if (args.len == 0) if (args.len == 0)
_ = try generateServices(allocator, io, ";", std.fs.File.stdin(), stdout); _ = try generateServices(allocator, io, ";", std.Io.File.stdin(), stdout);
if (verbose) { if (verbose) {
const output_path = try output_dir.realpathAlloc(allocator, "."); const output_path = try output_dir.realPathFileAlloc(io, ".", allocator);
std.debug.print("Output path: {s}\n", .{output_path}); std.debug.print("Output path: {s}\n", .{output_path});
} }
} }
@ -114,25 +110,23 @@ const OutputManifest = struct {
model_dir_hash_digest: [Hasher.hex_multihash_len]u8, model_dir_hash_digest: [Hasher.hex_multihash_len]u8,
output_dir_hash_digest: [Hasher.hex_multihash_len]u8, output_dir_hash_digest: [Hasher.hex_multihash_len]u8,
}; };
fn processDirectories(io: std.Io, models_dir: std.fs.Dir, output_dir: std.fs.Dir, parent_progress: *const std.Progress.Node) !void { fn processDirectories(io: std.Io, models_dir: std.Io.Dir, output_dir: std.Io.Dir, parent_progress: *const std.Progress.Node) !void {
// Let's get ready to hash!! // Let's get ready to hash!!
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit(); defer arena.deinit();
const allocator = arena.allocator(); const allocator = arena.allocator();
var thread_pool: std.Thread.Pool = undefined;
try thread_pool.init(.{ .allocator = allocator });
defer thread_pool.deinit();
const count, var calculated_manifest = const count, var calculated_manifest =
try calculateDigests( try calculateDigests(
allocator,
io,
models_dir, models_dir,
output_dir, output_dir,
&thread_pool,
); );
const output_stored_manifest = if (is_next) const output_stored_manifest = if (is_next)
output_dir.readFileAlloc("output_manifest.json", allocator, .unlimited) catch null output_dir.readFileAlloc(io, "output_manifest.json", allocator, .unlimited) catch null
else else
output_dir.readFileAlloc(allocator, "output_manifest.json", std.math.maxInt(usize)) catch null; output_dir.readFileAlloc(io, allocator, "output_manifest.json", std.math.maxInt(usize)) catch null;
if (output_stored_manifest) |o| { if (output_stored_manifest) |o| {
// we have a stored manifest. Parse it and compare to our calculations // we have a stored manifest. Parse it and compare to our calculations
// we can leak as we're using an arena allocator // we can leak as we're using an arena allocator
@ -147,16 +141,16 @@ fn processDirectories(io: std.Io, models_dir: std.fs.Dir, output_dir: std.fs.Dir
} }
} }
// Do this in a brain dead fashion from here, no optimization // Do this in a brain dead fashion from here, no optimization
const manifest_file = try output_dir.createFile("service_manifest.zig", .{}); const manifest_file = try output_dir.createFile(io, "service_manifest.zig", .{});
defer manifest_file.close(); defer manifest_file.close(io);
var manifest = manifest_file.writer(&manifest_buf); var manifest = manifest_file.writer(io, &manifest_buf);
defer manifest.interface.flush() catch @panic("Error flushing service_manifest.zig"); defer manifest.interface.flush() catch @panic("Error flushing service_manifest.zig");
var mi = models_dir.iterate(); var mi = models_dir.iterate();
const generating_models_progress = parent_progress.start("generating models", count); const generating_models_progress = parent_progress.start("generating models", count);
defer generating_models_progress.end(); defer generating_models_progress.end();
while (try mi.next()) |e| { while (try mi.next(io)) |e| {
if ((e.kind == .file or e.kind == .sym_link) and std.mem.endsWith(u8, e.name, ".json")) { if ((e.kind == .file or e.kind == .sym_link) and std.mem.endsWith(u8, e.name, ".json")) {
try processFile(io, e.name, output_dir, &manifest.interface); try processFile(io, e.name, output_dir, &manifest.interface);
generating_models_progress.completeOne(); generating_models_progress.completeOne();
@ -164,26 +158,26 @@ fn processDirectories(io: std.Io, models_dir: std.fs.Dir, output_dir: std.fs.Dir
} }
// re-calculate so we can store the manifest // re-calculate so we can store the manifest
model_digest = calculated_manifest.model_dir_hash_digest; model_digest = calculated_manifest.model_dir_hash_digest;
_, calculated_manifest = try calculateDigests(models_dir, output_dir, &thread_pool); _, calculated_manifest = try calculateDigests(allocator, io, models_dir, output_dir);
const data = try std.fmt.allocPrint(allocator, "{f}", .{std.json.fmt(calculated_manifest, .{ .whitespace = .indent_2 })}); const data = try std.fmt.allocPrint(allocator, "{f}", .{std.json.fmt(calculated_manifest, .{ .whitespace = .indent_2 })});
try output_dir.writeFile(.{ .sub_path = "output_manifest.json", .data = data }); try output_dir.writeFile(io, .{ .sub_path = "output_manifest.json", .data = data });
} }
var model_digest: ?[Hasher.hex_multihash_len]u8 = null; var model_digest: ?[Hasher.hex_multihash_len]u8 = null;
fn calculateDigests(models_dir: std.fs.Dir, output_dir: std.fs.Dir, thread_pool: *std.Thread.Pool) !struct { usize, OutputManifest } { fn calculateDigests(allocator: std.mem.Allocator, io: std.Io, models_dir: std.Io.Dir, output_dir: std.Io.Dir) !struct { usize, OutputManifest } {
const Include = struct { const Include = struct {
threadlocal var count: usize = 0; threadlocal var count: usize = 0;
pub fn include(entry: std.fs.Dir.Walker.Entry) bool { pub fn include(entry: std.Io.Dir.Walker.Entry) bool {
const included = std.mem.endsWith(u8, entry.basename, ".json"); const included = std.mem.endsWith(u8, entry.basename, ".json");
if (included) count += 1; if (included) count += 1;
return included; return included;
} }
}; };
const model_hash = if (model_digest) |m| m[0..Hasher.digest_len].* else try Hasher.computeDirectoryHash(thread_pool, models_dir, @constCast(&Hasher.ComputeDirectoryOptions{ const model_hash = if (model_digest) |m| m[0..Hasher.digest_len].* else try Hasher.computeDirectoryHash(allocator, io, models_dir, @constCast(&Hasher.ComputeDirectoryOptions{
.isIncluded = Include.include, .isIncluded = Include.include,
.isExcluded = struct { .isExcluded = struct {
pub fn exclude(entry: std.fs.Dir.Walker.Entry) bool { pub fn exclude(entry: std.Io.Dir.Walker.Entry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -192,14 +186,18 @@ fn calculateDigests(models_dir: std.fs.Dir, output_dir: std.fs.Dir, thread_pool:
})); }));
if (verbose) std.log.info("Model directory hash: {s}", .{model_digest orelse Hasher.hexDigest(model_hash)}); if (verbose) std.log.info("Model directory hash: {s}", .{model_digest orelse Hasher.hexDigest(model_hash)});
const output_hash = try Hasher.computeDirectoryHash(thread_pool, try output_dir.openDir(".", .{ .iterate = true }), @constCast(&Hasher.ComputeDirectoryOptions{ const output_hash = try Hasher.computeDirectoryHash(allocator, io, try output_dir.openDir(
io,
".",
.{ .iterate = true },
), @constCast(&Hasher.ComputeDirectoryOptions{
.isIncluded = struct { .isIncluded = struct {
pub fn include(entry: std.fs.Dir.Walker.Entry) bool { pub fn include(entry: std.Io.Dir.Walker.Entry) bool {
return std.mem.endsWith(u8, entry.basename, ".zig"); return std.mem.endsWith(u8, entry.basename, ".zig");
} }
}.include, }.include,
.isExcluded = struct { .isExcluded = struct {
pub fn exclude(entry: std.fs.Dir.Walker.Entry) bool { pub fn exclude(entry: std.Io.Dir.Walker.Entry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -208,13 +206,14 @@ fn calculateDigests(models_dir: std.fs.Dir, output_dir: std.fs.Dir, thread_pool:
})); }));
if (verbose) std.log.info("Output directory hash: {s}", .{Hasher.hexDigest(output_hash)}); if (verbose) std.log.info("Output directory hash: {s}", .{Hasher.hexDigest(output_hash)});
return .{ return .{
Include.count, .{ Include.count,
.{
.model_dir_hash_digest = model_digest orelse Hasher.hexDigest(model_hash), .model_dir_hash_digest = model_digest orelse Hasher.hexDigest(model_hash),
.output_dir_hash_digest = Hasher.hexDigest(output_hash), .output_dir_hash_digest = Hasher.hexDigest(output_hash),
}, },
}; };
} }
fn processFile(io: std.Io, file_name: []const u8, output_dir: std.fs.Dir, manifest: *std.Io.Writer) !void { fn processFile(io: std.Io, file_name: []const u8, output_dir: std.Io.Dir, manifest: *std.Io.Writer) !void {
// It's probably best to create our own allocator here so we can deint at the end and // It's probably best to create our own allocator here so we can deint at the end and
// toss all allocations related to the services in this file // toss all allocations related to the services in this file
// I can't guarantee we're not leaking something, and at the end of the // I can't guarantee we're not leaking something, and at the end of the
@ -232,7 +231,6 @@ fn processFile(io: std.Io, file_name: []const u8, output_dir: std.fs.Dir, manife
_ = try writer.write("const smithy = @import(\"smithy\");\n"); _ = try writer.write("const smithy = @import(\"smithy\");\n");
_ = try writer.write("const json = @import(\"json\");\n"); _ = try writer.write("const json = @import(\"json\");\n");
_ = try writer.write("const date = @import(\"date\");\n"); _ = try writer.write("const date = @import(\"date\");\n");
_ = try writer.write("const zeit = @import(\"zeit\");\n");
_ = try writer.write("\n"); _ = try writer.write("\n");
_ = try writer.write("const serializeMap = json.serializeMap;\n"); _ = try writer.write("const serializeMap = json.serializeMap;\n");
_ = try writer.write("\n"); _ = try writer.write("\n");
@ -272,9 +270,9 @@ fn processFile(io: std.Io, file_name: []const u8, output_dir: std.fs.Dir, manife
const formatted = try zigFmt(allocator, unformatted); const formatted = try zigFmt(allocator, unformatted);
// Dump our buffer out to disk // Dump our buffer out to disk
var file = try output_dir.createFile(output_file_name, .{ .truncate = true }); var file = try output_dir.createFile(io, output_file_name, .{ .truncate = true });
defer file.close(); defer file.close(io);
try file.writeAll(formatted); try file.writeStreamingAll(io, formatted);
for (service_names) |name| { for (service_names) |name| {
try manifest.print("pub const {s} = @import(\"{s}\");\n", .{ name, std.fs.path.basename(output_file_name) }); try manifest.print("pub const {s} = @import(\"{s}\");\n", .{ name, std.fs.path.basename(output_file_name) });
@ -298,8 +296,8 @@ fn generateServicesForFilePath(
path: []const u8, path: []const u8,
writer: *std.Io.Writer, writer: *std.Io.Writer,
) ![][]const u8 { ) ![][]const u8 {
const file = try std.fs.cwd().openFile(path, .{}); const file = try std.Io.Dir.cwd().openFile(io, path, .{});
defer file.close(); defer file.close(io);
return try generateServices(allocator, io, terminator, file, writer); return try generateServices(allocator, io, terminator, file, writer);
} }
@ -404,7 +402,7 @@ fn generateServices(
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
io: std.Io, io: std.Io,
comptime _: []const u8, comptime _: []const u8,
file: std.fs.File, file: std.Io.File,
writer: *std.Io.Writer, writer: *std.Io.Writer,
) ![][]const u8 { ) ![][]const u8 {
var fbuf: [1024]u8 = undefined; var fbuf: [1024]u8 = undefined;
@ -429,14 +427,14 @@ fn generateServices(
// a reference count in case there are recursive data structures // a reference count in case there are recursive data structures
var shape_references = std.StringHashMap(u64).init(allocator); var shape_references = std.StringHashMap(u64).init(allocator);
defer shape_references.deinit(); defer shape_references.deinit();
var stack: std.ArrayList([]const u8) = .{}; var stack: std.ArrayList([]const u8) = .empty;
defer stack.deinit(allocator); defer stack.deinit(allocator);
for (services.items) |service| for (services.items) |service|
try countReferences(allocator, service, shapes, &shape_references, &stack); try countReferences(allocator, service, shapes, &shape_references, &stack);
var constant_names = try std.ArrayList([]const u8).initCapacity(allocator, services.items.len); var constant_names = try std.ArrayList([]const u8).initCapacity(allocator, services.items.len);
defer constant_names.deinit(allocator); defer constant_names.deinit(allocator);
var unresolved: std.ArrayList(smithy.ShapeInfo) = .{}; var unresolved: std.ArrayList(smithy.ShapeInfo) = .empty;
defer unresolved.deinit(allocator); defer unresolved.deinit(allocator);
var generated = std.StringHashMap(void).init(allocator); var generated = std.StringHashMap(void).init(allocator);
defer generated.deinit(); defer generated.deinit();
@ -526,7 +524,7 @@ fn generateAdditionalTypes(allocator: std.mem.Allocator, file_state: FileGenerat
while (file_state.additional_types_to_generate.pop()) |t| { while (file_state.additional_types_to_generate.pop()) |t| {
if (file_state.additional_types_generated.getEntry(t.name) != null) continue; if (file_state.additional_types_generated.getEntry(t.name) != null) continue;
// std.log.info("\t\t{s}", .{t.name}); // std.log.info("\t\t{s}", .{t.name});
var type_stack: std.ArrayList(*const smithy.ShapeInfo) = .{}; var type_stack: std.ArrayList(*const smithy.ShapeInfo) = .empty;
defer type_stack.deinit(allocator); defer type_stack.deinit(allocator);
const state = GenerationState{ const state = GenerationState{
.type_stack = &type_stack, .type_stack = &type_stack,
@ -577,7 +575,7 @@ fn generateOperation(allocator: std.mem.Allocator, operation: smithy.ShapeInfo,
const snake_case_name = try support.constantName(allocator, operation.name, .snake); const snake_case_name = try support.constantName(allocator, operation.name, .snake);
defer allocator.free(snake_case_name); defer allocator.free(snake_case_name);
var type_stack: std.ArrayList(*const smithy.ShapeInfo) = .{}; var type_stack: std.ArrayList(*const smithy.ShapeInfo) = .empty;
defer type_stack.deinit(allocator); defer type_stack.deinit(allocator);
const state = GenerationState{ const state = GenerationState{
.type_stack = &type_stack, .type_stack = &type_stack,
@ -585,8 +583,7 @@ fn generateOperation(allocator: std.mem.Allocator, operation: smithy.ShapeInfo,
.allocator = allocator, .allocator = allocator,
.indent_level = 1, .indent_level = 1,
}; };
var child_state = state; const child_state = state.indent();
child_state.indent_level += 1;
// indent should start at 4 spaces here // indent should start at 4 spaces here
const operation_name = avoidReserved(snake_case_name); const operation_name = avoidReserved(snake_case_name);
@ -687,17 +684,17 @@ fn generateMetadataFunction(operation_name: []const u8, state: GenerationState,
// } // }
// We want to add a short "get my parents" function into the response // We want to add a short "get my parents" function into the response
var child_state = state; var child_state = state;
child_state.indent_level += 1; child_state = child_state.indent();
try outputIndent(child_state, writer); try outputIndent(child_state, writer);
_ = try writer.write("pub fn metaInfo() struct { "); _ = try writer.write("pub fn metaInfo() struct { ");
try writer.print("service_metadata: @TypeOf(service_metadata), action: @TypeOf({s})", .{operation_name}); try writer.print("service_metadata: @TypeOf(service_metadata), action: @TypeOf({s})", .{operation_name});
_ = try writer.write(" } {\n"); _ = try writer.write(" } {\n");
child_state.indent_level += 1; child_state = child_state.indent();
try outputIndent(child_state, writer); try outputIndent(child_state, writer);
_ = try writer.write("return .{ .service_metadata = service_metadata, "); _ = try writer.write("return .{ .service_metadata = service_metadata, ");
try writer.print(".action = {s}", .{operation_name}); try writer.print(".action = {s}", .{operation_name});
_ = try writer.write(" };\n"); _ = try writer.write(" };\n");
child_state.indent_level -= 1; child_state = child_state.deindent();
try outputIndent(child_state, writer); try outputIndent(child_state, writer);
_ = try writer.write("}\n"); _ = try writer.write("}\n");
try outputIndent(state, writer); try outputIndent(state, writer);
@ -873,8 +870,7 @@ fn generateMapTypeFor(map: anytype, writer: *std.Io.Writer, state: GenerationSta
try writer.writeAll("pub const is_map_type = true;\n\n"); try writer.writeAll("pub const is_map_type = true;\n\n");
var child_state = state; const child_state = state.indent();
child_state.indent_level += 1;
_ = try writer.write("key: "); _ = try writer.write("key: ");
_ = try generateTypeFor(map.key, writer, child_state, options.endStructure(true)); _ = try generateTypeFor(map.key, writer, child_state, options.endStructure(true));
@ -923,8 +919,7 @@ fn generateComplexTypeFor(shape_id: []const u8, members: []smithy.TypeMember, ty
// prolog. We'll rely on caller to get the spacing correct here // prolog. We'll rely on caller to get the spacing correct here
_ = try writer.write(type_type_name); _ = try writer.write(type_type_name);
_ = try writer.write(" {\n"); _ = try writer.write(" {\n");
var child_state = state; const child_state = state.indent();
child_state.indent_level += 1;
var payload: ?[]const u8 = null; var payload: ?[]const u8 = null;
for (members) |member| { for (members) |member| {
// This is our mapping // This is our mapping
@ -1011,8 +1006,7 @@ fn generateComplexTypeFor(shape_id: []const u8, members: []smithy.TypeMember, ty
try writer.writeByte('\n'); try writer.writeByte('\n');
try outputIndent(child_state, writer); try outputIndent(child_state, writer);
_ = try writer.write("pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {\n"); _ = try writer.write("pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {\n");
var grandchild_state = child_state; const grandchild_state = child_state.indent();
grandchild_state.indent_level += 1;
// We need to force output here becaseu we're referencing the field in the return statement below // We need to force output here becaseu we're referencing the field in the return statement below
try writeMappings(grandchild_state, "", "mappings", field_name_mappings, true, writer); try writeMappings(grandchild_state, "", "mappings", field_name_mappings, true, writer);
try outputIndent(grandchild_state, writer); try outputIndent(grandchild_state, writer);
@ -1038,8 +1032,7 @@ fn writeMappings(
} }
try writer.print("{s}const {s} = .", .{ @"pub", mapping_name }); try writer.print("{s}const {s} = .", .{ @"pub", mapping_name });
_ = try writer.write("{\n"); _ = try writer.write("{\n");
var child_state = state; const child_state = state.indent();
child_state.indent_level += 1;
for (mappings.items) |mapping| { for (mappings.items) |mapping| {
try outputIndent(child_state, writer); try outputIndent(child_state, writer);
try writer.print(".{s} = \"{s}\",\n", .{ avoidReserved(mapping.snake), mapping.original }); try writer.print(".{s} = \"{s}\",\n", .{ avoidReserved(mapping.snake), mapping.original });

2
codegen/src/serialization/json.zig
View file

@ -87,7 +87,7 @@ fn getJsonMembers(allocator: Allocator, shape: Shape, state: GenerationState) !?
return null; return null;
} }
var json_members = std.ArrayListUnmanaged(JsonMember){}; var json_members: std.ArrayListUnmanaged(JsonMember) = .empty;
var iter = hash_map.iterator(); var iter = hash_map.iterator();
while (iter.next()) |kvp| { while (iter.next()) |kvp| {

4
lib/date/build.zig.zon
View file

@ -5,8 +5,8 @@
.minimum_zig_version = "0.14.0", .minimum_zig_version = "0.14.0",
.dependencies = .{ .dependencies = .{
.zeit = .{ .zeit = .{
.url = "git+https://github.com/elerch/zeit#8190461dc1f892f6370fa9d5cd76690aac0e1c71", .url = "git+https://github.com/rockorager/zeit#2a79678e05e4e82cd4efd4fd6b754dcf029c3a64",
.hash = "zeit-0.6.0-5I6bk99-AgDNMIDuw2Zcoe_9QYIpzwZJqeqMpU54egTd", .hash = "zeit-0.6.0-5I6bk7q6AgBdMJxze3D4l9ylQhkviQ_BX9FigDt13MFn",
}, },
.json = .{ .json = .{
.path = "../json", .path = "../json",

14
lib/date/src/parsing.zig
View file

@ -1,6 +1,7 @@
const std = @import("std"); const std = @import("std");
const log = std.log.scoped(.date); const log = std.log.scoped(.date);
const zeit = @import("zeit"); const zeit = @import("zeit");
const instantWithoutIo = @import("timestamp.zig").instantWithoutIo;
pub const DateTime = struct { pub const DateTime = struct {
day: u8, day: u8,
@ -37,12 +38,13 @@ pub const DateTime = struct {
} }
pub fn instant(self: DateTime) !zeit.Instant { pub fn instant(self: DateTime) !zeit.Instant {
return try zeit.instant(.{ .source = .{ .time = self.time() } }); return try instantWithoutIo(.{ .source = .{ .time = self.time() } });
} }
}; };
pub fn timestampToDateTime(timestamp: zeit.Seconds) DateTime { pub fn timestampToDateTime(timestamp: i64) DateTime {
const ins = zeit.instant(.{ .source = .{ .unix_timestamp = timestamp } }) catch @panic("Failed to create instant from timestamp"); // zeit.Seconds is i64, so this should be identical
const ins = instantWithoutIo(.{ .source = .{ .unix_timestamp = timestamp } }) catch @panic("Failed to create instant from timestamp");
return DateTime.fromInstant(ins); return DateTime.fromInstant(ins);
} }
@ -53,7 +55,7 @@ pub fn parseEnglishToTimestamp(data: []const u8) !i64 {
/// Converts a string to a timestamp value. May not handle dates before the /// Converts a string to a timestamp value. May not handle dates before the
/// epoch. Dates should look like "Fri, 03 Jun 2022 18:12:36 GMT" /// epoch. Dates should look like "Fri, 03 Jun 2022 18:12:36 GMT"
pub fn parseEnglishToDateTime(data: []const u8) !DateTime { pub fn parseEnglishToDateTime(data: []const u8) !DateTime {
const ins = try zeit.instant(.{ .source = .{ .rfc1123 = data } }); const ins = try instantWithoutIo(.{ .source = .{ .rfc1123 = data } });
return DateTime.fromInstant(ins); return DateTime.fromInstant(ins);
} }
@ -64,7 +66,7 @@ pub fn parseIso8601ToTimestamp(data: []const u8) !i64 {
/// Converts a string to a timestamp value. May not handle dates before the /// Converts a string to a timestamp value. May not handle dates before the
/// epoch /// epoch
pub fn parseIso8601ToDateTime(data: []const u8) !DateTime { pub fn parseIso8601ToDateTime(data: []const u8) !DateTime {
const ins = try zeit.instant(.{ .source = .{ .iso8601 = data } }); const ins = try instantWithoutIo(.{ .source = .{ .iso8601 = data } });
return DateTime.fromInstant(ins); return DateTime.fromInstant(ins);
} }
@ -84,7 +86,7 @@ fn printDateTime(dt: DateTime) void {
} }
pub fn printNowUtc(io: std.Io) void { pub fn printNowUtc(io: std.Io) void {
const now = std.Io.Clock.Timestamp.now(io, .awake) catch return; const now = std.Io.Clock.Timestamp.now(io, .awake);
const timestamp = @as(i64, @intCast(@divFloor(now.raw.nanoseconds, std.time.ns_per_s))); const timestamp = @as(i64, @intCast(@divFloor(now.raw.nanoseconds, std.time.ns_per_s)));
printDateTime(timestampToDateTime(timestamp)); printDateTime(timestampToDateTime(timestamp));
} }

34
lib/date/src/timestamp.zig
View file

@ -10,7 +10,7 @@ pub const Timestamp = enum(zeit.Nanoseconds) {
_, _,
pub fn jsonStringify(value: Timestamp, jw: anytype) !void { pub fn jsonStringify(value: Timestamp, jw: anytype) !void {
const instant = zeit.instant(.{ const instant = instantWithoutIo(.{
.source = .{ .source = .{
.unix_nano = @intFromEnum(value), .unix_nano = @intFromEnum(value),
}, },
@ -34,7 +34,7 @@ pub const Timestamp = enum(zeit.Nanoseconds) {
} }
}; };
const ins = try zeit.instant(.{ const ins = try instantWithoutIo(.{
.source = switch (date_format) { .source = switch (date_format) {
DateFormat.iso8601 => .{ DateFormat.iso8601 => .{
.iso8601 = val, .iso8601 = val,
@ -49,6 +49,36 @@ pub const Timestamp = enum(zeit.Nanoseconds) {
} }
}; };
/// create a new Instant
pub fn instantWithoutIo(cfg: zeit.Instant.Config) !zeit.Instant {
const ts: zeit.Nanoseconds = switch (cfg.source) {
.now => return error.UseZeitInstantWithIoForNowInstants,
.unix_timestamp => |unix| @as(i128, unix) * std.time.ns_per_s,
.unix_nano => |nano| nano,
.time => |time| time.instant().timestamp,
.iso8601,
.rfc3339,
=> |iso| blk: {
const t = try zeit.Time.fromISO8601(iso);
break :blk t.instant().timestamp;
},
.rfc2822,
.rfc5322,
=> |eml| blk: {
const t = try zeit.Time.fromRFC5322(eml);
break :blk t.instant().timestamp;
},
.rfc1123 => |http_date| blk: {
const t = try zeit.Time.fromRFC1123(http_date);
break :blk t.instant().timestamp;
},
};
return .{
.timestamp = ts,
.timezone = cfg.timezone,
};
}
test Timestamp { test Timestamp {
const in_date = "Wed, 23 Apr 2025 11:23:45 GMT"; const in_date = "Wed, 23 Apr 2025 11:23:45 GMT";

10
lib/json/src/json.zig
View file

@ -1346,7 +1346,7 @@ test "json.validate" {
const Allocator = std.mem.Allocator; const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator; const ArenaAllocator = std.heap.ArenaAllocator;
const ArrayList = std.ArrayList; const ArrayList = std.ArrayList;
const StringArrayHashMap = std.StringArrayHashMap; const StringArrayHashMap = std.array_hash_map.String;
pub const ValueTree = struct { pub const ValueTree = struct {
arena: ArenaAllocator, arena: ArenaAllocator,
@ -1580,11 +1580,11 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options:
if (!numberToken.is_integer) { if (!numberToken.is_integer) {
// probably is in scientific notation // probably is in scientific notation
const n = try std.fmt.parseFloat(f128, numberToken.slice(tokens.slice, tokens.i - 1)); const n = try std.fmt.parseFloat(f128, numberToken.slice(tokens.slice, tokens.i - 1));
return try std.meta.intToEnum(T, @as(i128, @intFromFloat(n))); return std.enums.fromInt(T, @as(i128, @intFromFloat(n))) orelse error.InvalidEnumTag;
} }
const n = try std.fmt.parseInt(enumInfo.tag_type, numberToken.slice(tokens.slice, tokens.i - 1), 10); const n = try std.fmt.parseInt(enumInfo.tag_type, numberToken.slice(tokens.slice, tokens.i - 1), 10);
return try std.meta.intToEnum(T, n); return std.enums.fromInt(T, n) orelse error.InvalidEnumTag;
}, },
.String => |stringToken| { .String => |stringToken| {
const source_slice = stringToken.slice(tokens.slice, tokens.i - 1); const source_slice = stringToken.slice(tokens.slice, tokens.i - 1);
@ -1772,7 +1772,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options:
.slice => { .slice => {
switch (token) { switch (token) {
.ArrayBegin => { .ArrayBegin => {
var arraylist = std.ArrayList(ptrInfo.child){}; var arraylist = std.ArrayList(ptrInfo.child).empty;
errdefer { errdefer {
while (arraylist.pop()) |v| { while (arraylist.pop()) |v| {
parseFree(ptrInfo.child, v, options); parseFree(ptrInfo.child, v, options);
@ -1817,7 +1817,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options:
if (key_type == null) return error.UnexpectedToken; if (key_type == null) return error.UnexpectedToken;
const value_type = typeForField(ptrInfo.child, "value"); const value_type = typeForField(ptrInfo.child, "value");
if (value_type == null) return error.UnexpectedToken; if (value_type == null) return error.UnexpectedToken;
var arraylist = std.ArrayList(ptrInfo.child){}; var arraylist = std.ArrayList(ptrInfo.child).empty;
errdefer { errdefer {
while (arraylist.pop()) |v| { while (arraylist.pop()) |v| {
parseFree(ptrInfo.child, v, options); parseFree(ptrInfo.child, v, options);

14
src/aws.zig
View file

@ -4,7 +4,6 @@ const std = @import("std");
const case = @import("case"); const case = @import("case");
const date = @import("date"); const date = @import("date");
const json = @import("json"); const json = @import("json");
const zeit = @import("zeit");
const credentials = @import("aws_credentials.zig"); const credentials = @import("aws_credentials.zig");
const awshttp = @import("aws_http.zig"); const awshttp = @import("aws_http.zig");
@ -115,6 +114,7 @@ pub const Services = servicemodel.Services;
pub const ClientOptions = struct { pub const ClientOptions = struct {
proxy: ?std.http.Client.Proxy = null, proxy: ?std.http.Client.Proxy = null,
io: std.Io, io: std.Io,
map: *const std.process.Environ.Map,
}; };
pub const Client = struct { pub const Client = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
@ -125,7 +125,7 @@ pub const Client = struct {
pub fn init(allocator: std.mem.Allocator, options: ClientOptions) Self { pub fn init(allocator: std.mem.Allocator, options: ClientOptions) Self {
return Self{ return Self{
.allocator = allocator, .allocator = allocator,
.aws_http = awshttp.AwsHttp.init(allocator, options.io, options.proxy), .aws_http = awshttp.AwsHttp.init(allocator, options.io, options.map, options.proxy),
}; };
} }
pub fn deinit(self: *Client) void { pub fn deinit(self: *Client) void {
@ -196,7 +196,7 @@ pub fn Request(comptime request_action: anytype) type {
log.debug("Rest method: '{s}'", .{aws_request.method}); log.debug("Rest method: '{s}'", .{aws_request.method});
log.debug("Rest success code: '{d}'", .{Action.http_config.success_code}); log.debug("Rest success code: '{d}'", .{Action.http_config.success_code});
log.debug("Rest raw uri: '{s}'", .{Action.http_config.uri}); log.debug("Rest raw uri: '{s}'", .{Action.http_config.uri});
var al = std.ArrayList([]const u8){}; var al = std.ArrayList([]const u8).empty;
defer al.deinit(options.client.allocator); defer al.deinit(options.client.allocator);
aws_request.path = try buildPath( aws_request.path = try buildPath(
options.client.allocator, options.client.allocator,
@ -481,9 +481,7 @@ pub fn Request(comptime request_action: anytype) type {
) catch |e| { ) catch |e| {
log.err("Could not set header value: Response header {s}. Field {s}. Value {s}", .{ header.name, f.?.name, header.value }); log.err("Could not set header value: Response header {s}. Field {s}. Value {s}", .{ header.name, f.?.name, header.value });
log.err("Error: {}", .{e}); log.err("Error: {}", .{e});
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
}; };
break; break;
@ -1474,7 +1472,7 @@ test "REST Json v1 serializes lists in queries" {
} }
test "REST Json v1 buildpath substitutes" { test "REST Json v1 buildpath substitutes" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var al = std.ArrayList([]const u8){}; var al = std.ArrayList([]const u8).empty;
defer al.deinit(allocator); defer al.deinit(allocator);
const svs = Services(.{.lambda}){}; const svs = Services(.{.lambda}){};
const request = svs.lambda.list_functions.Request{ const request = svs.lambda.list_functions.Request{
@ -1487,7 +1485,7 @@ test "REST Json v1 buildpath substitutes" {
} }
test "REST Json v1 buildpath handles restricted characters" { test "REST Json v1 buildpath handles restricted characters" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var al = std.ArrayList([]const u8){}; var al = std.ArrayList([]const u8).empty;
defer al.deinit(allocator); defer al.deinit(allocator);
const svs = Services(.{.lambda}){}; const svs = Services(.{.lambda}){};
const request = svs.lambda.list_functions.Request{ const request = svs.lambda.list_functions.Request{

110
src/aws_credentials.zig
View file

@ -82,18 +82,18 @@ pub const Options = struct {
pub var static_credentials: ?auth.Credentials = null; pub var static_credentials: ?auth.Credentials = null;
pub fn getCredentials(allocator: std.mem.Allocator, io: std.Io, options: Options) !auth.Credentials { pub fn getCredentials(allocator: std.mem.Allocator, map: *const std.process.Environ.Map, io: std.Io, options: Options) !auth.Credentials {
if (static_credentials) |c| return c; if (static_credentials) |c| return c;
if (options.profile.prefer_profile_from_file) { if (options.profile.prefer_profile_from_file) {
log.debug( log.debug(
"Command line profile specified. Checking credentials file first. Profile name {s}", "Command line profile specified. Checking credentials file first. Profile name {s}",
.{options.profile.profile_name orelse "default"}, .{options.profile.profile_name orelse "default"},
); );
if (try getProfileCredentials(allocator, io, options.profile)) |cred| return cred; if (try getProfileCredentials(allocator, io, map, options.profile)) |cred| return cred;
// Profile not found. We'll mirror the cli here and bail early // Profile not found. We'll mirror the cli here and bail early
return error.CredentialsNotFound; return error.CredentialsNotFound;
} }
if (try getEnvironmentCredentials(allocator)) |cred| { if (try getEnvironmentCredentials(allocator, map)) |cred| {
log.debug("Found credentials in environment. Access key: {s}", .{cred.access_key}); log.debug("Found credentials in environment. Access key: {s}", .{cred.access_key});
return cred; return cred;
} }
@ -101,32 +101,31 @@ pub fn getCredentials(allocator: std.mem.Allocator, io: std.Io, options: Options
// GetWebIdentity is not currently implemented. The rest are tested and gtg // GetWebIdentity is not currently implemented. The rest are tested and gtg
// Note: Lambda just sets environment variables // Note: Lambda just sets environment variables
if (try getWebIdentityToken(allocator)) |cred| return cred; if (try getWebIdentityToken(allocator)) |cred| return cred;
if (try getProfileCredentials(allocator, io, options.profile)) |cred| return cred; if (try getProfileCredentials(allocator, io, map, options.profile)) |cred| return cred;
if (try getContainerCredentials(allocator, io)) |cred| return cred; if (try getContainerCredentials(allocator, io, map)) |cred| return cred;
// I don't think we need v1 at all? // I don't think we need v1 at all?
if (try getImdsv2Credentials(allocator, io)) |cred| return cred; if (try getImdsv2Credentials(allocator, io)) |cred| return cred;
return error.CredentialsNotFound; return error.CredentialsNotFound;
} }
fn getEnvironmentCredentials(allocator: std.mem.Allocator) !?auth.Credentials { fn getEnvironmentCredentials(allocator: std.mem.Allocator, map: *const std.process.Environ.Map) !?auth.Credentials {
const secret_key = (try getEnvironmentVariable(allocator, "AWS_SECRET_ACCESS_KEY")) orelse return null; const secret_key = getEnvironmentVariable(map, "AWS_SECRET_ACCESS_KEY") orelse return null;
defer allocator.free(secret_key); //yes, we're not zeroing. But then, the secret key is in an environment var anyway const access_key = getEnvironmentVariable(map, "AWS_ACCESS_KEY_ID") orelse return null;
const token = getEnvironmentVariable(map, "AWS_SESSION_TOKEN") orelse
getEnvironmentVariable(map, "AWS_SECURITY_TOKEN"); // Security token is backward compat only
// Use cross-platform API (requires allocation) // Use cross-platform API (requires allocation)
return auth.Credentials.init( return auth.Credentials.init(
allocator, allocator,
(try getEnvironmentVariable(allocator, "AWS_ACCESS_KEY_ID")) orelse return null, try allocator.dupe(u8, access_key),
try allocator.dupe(u8, secret_key), try allocator.dupe(u8, secret_key),
(try getEnvironmentVariable(allocator, "AWS_SESSION_TOKEN")) orelse if (token) |t| try allocator.dupe(u8, t) else null,
try getEnvironmentVariable(allocator, "AWS_SECURITY_TOKEN"), // Security token is backward compat only
); );
} }
fn getEnvironmentVariable(allocator: std.mem.Allocator, key: []const u8) !?[]const u8 { fn getEnvironmentVariable(map: *const std.process.Environ.Map, key: []const u8) ?[]const u8 {
return std.process.getEnvVarOwned(allocator, key) catch |e| switch (e) { if (!map.contains(key)) return null;
std.process.GetEnvVarOwnedError.EnvironmentVariableNotFound => return null, return map.get(key);
else => return e,
};
} }
fn getWebIdentityToken(allocator: std.mem.Allocator) !?auth.Credentials { fn getWebIdentityToken(allocator: std.mem.Allocator) !?auth.Credentials {
@ -139,7 +138,7 @@ fn getWebIdentityToken(allocator: std.mem.Allocator) !?auth.Credentials {
// TODO: implement // TODO: implement
return null; return null;
} }
fn getContainerCredentials(allocator: std.mem.Allocator, io: std.Io) !?auth.Credentials { fn getContainerCredentials(allocator: std.mem.Allocator, io: std.Io, map: *const std.process.Environ.Map) !?auth.Credentials {
// A note on testing: The best way I have found to test this process is // A note on testing: The best way I have found to test this process is
// the following. Setup an ECS Fargate cluster and create a task definition // the following. Setup an ECS Fargate cluster and create a task definition
// with the command ["/bin/bash","-c","while true; do sleep 10; done"]. // with the command ["/bin/bash","-c","while true; do sleep 10; done"].
@ -180,8 +179,7 @@ fn getContainerCredentials(allocator: std.mem.Allocator, io: std.Io) !?auth.Cred
// //
// Compile code, copy to S3, install AWS CLI within the session, download // Compile code, copy to S3, install AWS CLI within the session, download
// from s3 and run // from s3 and run
const container_relative_uri = (try getEnvironmentVariable(allocator, "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI")) orelse return null; const container_relative_uri = getEnvironmentVariable(map, "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") orelse return null;
defer allocator.free(container_relative_uri);
const container_uri = try std.fmt.allocPrint(allocator, "http://169.254.170.2{s}", .{container_relative_uri}); const container_uri = try std.fmt.allocPrint(allocator, "http://169.254.170.2{s}", .{container_relative_uri});
defer allocator.free(container_uri); defer allocator.free(container_uri);
@ -214,9 +212,7 @@ fn getContainerCredentials(allocator: std.mem.Allocator, io: std.Io) !?auth.Cred
const res = std.json.parseFromSlice(CredsResponse, allocator, aw.written(), .{}) catch |e| { const res = std.json.parseFromSlice(CredsResponse, allocator, aw.written(), .{}) catch |e| {
log.err("Unexpected Json response from container credentials endpoint: {s}", .{aw.written()}); log.err("Unexpected Json response from container credentials endpoint: {s}", .{aw.written()});
log.err("Error parsing json: {}", .{e}); log.err("Error parsing json: {}", .{e});
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
return null; return null;
}; };
@ -312,9 +308,7 @@ fn getImdsRoleName(allocator: std.mem.Allocator, client: *std.http.Client, imds_
const imds_response = std.json.parseFromSlice(ImdsResponse, allocator, aw.written(), .{}) catch |e| { const imds_response = std.json.parseFromSlice(ImdsResponse, allocator, aw.written(), .{}) catch |e| {
log.err("Unexpected Json response from IMDS endpoint: {s}", .{aw.written()}); log.err("Unexpected Json response from IMDS endpoint: {s}", .{aw.written()});
log.err("Error parsing json: {}", .{e}); log.err("Error parsing json: {}", .{e});
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
return null; return null;
}; };
defer imds_response.deinit(); defer imds_response.deinit();
@ -367,10 +361,7 @@ fn getImdsCredentials(allocator: std.mem.Allocator, client: *std.http.Client, ro
const imds_response = std.json.parseFromSlice(ImdsResponse, allocator, aw.written(), .{}) catch |e| { const imds_response = std.json.parseFromSlice(ImdsResponse, allocator, aw.written(), .{}) catch |e| {
log.err("Unexpected Json response from IMDS endpoint: {s}", .{aw.written()}); log.err("Unexpected Json response from IMDS endpoint: {s}", .{aw.written()});
log.err("Error parsing json: {}", .{e}); log.err("Error parsing json: {}", .{e});
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
return null; return null;
}; };
defer imds_response.deinit(); defer imds_response.deinit();
@ -397,12 +388,13 @@ fn getImdsCredentials(allocator: std.mem.Allocator, client: *std.http.Client, ro
} }
fn getProfileCredentials(allocator: std.mem.Allocator, io: std.Io, options: Profile) !?auth.Credentials { fn getProfileCredentials(allocator: std.mem.Allocator, io: std.Io, map: *const std.process.Environ.Map, options: Profile) !?auth.Credentials {
var default_path: ?[]const u8 = null; var default_path: ?[]const u8 = null;
defer if (default_path) |p| allocator.free(p); defer if (default_path) |p| allocator.free(p);
const creds_file_path = try filePath( const creds_file_path = try filePath(
allocator, allocator,
map,
options.credential_file, options.credential_file,
"AWS_SHARED_CREDENTIALS_FILE", "AWS_SHARED_CREDENTIALS_FILE",
default_path, default_path,
@ -412,6 +404,7 @@ fn getProfileCredentials(allocator: std.mem.Allocator, io: std.Io, options: Prof
default_path = default_path orelse creds_file_path.home; default_path = default_path orelse creds_file_path.home;
const config_file_path = try filePath( const config_file_path = try filePath(
allocator, allocator,
map,
options.config_file, options.config_file,
"AWS_CONFIG_FILE", "AWS_CONFIG_FILE",
default_path, default_path,
@ -421,21 +414,21 @@ fn getProfileCredentials(allocator: std.mem.Allocator, io: std.Io, options: Prof
default_path = default_path orelse config_file_path.home; default_path = default_path orelse config_file_path.home;
// Get active profile // Get active profile
const profile = (try getEnvironmentVariable(allocator, "AWS_PROFILE")) orelse const profile = try allocator.dupe(u8, getEnvironmentVariable(map, "AWS_PROFILE") orelse
try allocator.dupe(u8, options.profile_name orelse "default"); options.profile_name orelse "default");
defer allocator.free(profile); defer allocator.free(profile);
log.debug("Looking for file credentials using profile '{s}'", .{profile}); log.debug("Looking for file credentials using profile '{s}'", .{profile});
log.debug("Checking credentials file: {s}", .{creds_file_path.evaluated_path}); log.debug("Checking credentials file: {s}", .{creds_file_path.evaluated_path});
const credentials_file = std.fs.openFileAbsolute(creds_file_path.evaluated_path, .{}) catch null; const credentials_file = std.Io.Dir.openFileAbsolute(io, creds_file_path.evaluated_path, .{}) catch null;
defer if (credentials_file) |f| f.close(); defer if (credentials_file) |f| f.close(io);
// It's much more likely that we'll find credentials in the credentials file // It's much more likely that we'll find credentials in the credentials file
// so we'll try that first // so we'll try that first
const creds_file_creds = try credsForFile(allocator, io, credentials_file, profile); const creds_file_creds = try credsForFile(allocator, io, credentials_file, profile);
var conf_file_creds = PartialCredentials{}; var conf_file_creds = PartialCredentials{};
if (creds_file_creds.access_key == null or creds_file_creds.secret_key == null) { if (creds_file_creds.access_key == null or creds_file_creds.secret_key == null) {
log.debug("Checking config file: {s}", .{config_file_path.evaluated_path}); log.debug("Checking config file: {s}", .{config_file_path.evaluated_path});
const config_file = std.fs.openFileAbsolute(creds_file_path.evaluated_path, .{}) catch null; const config_file = std.Io.Dir.openFileAbsolute(io, creds_file_path.evaluated_path, .{}) catch null;
defer if (config_file) |f| f.close(); defer if (config_file) |f| f.close(io);
conf_file_creds = try credsForFile(allocator, io, config_file, profile); conf_file_creds = try credsForFile(allocator, io, config_file, profile);
} }
const access_key = keyFrom(allocator, creds_file_creds.access_key, conf_file_creds.access_key); const access_key = keyFrom(allocator, creds_file_creds.access_key, conf_file_creds.access_key);
@ -475,7 +468,7 @@ const PartialCredentials = struct {
access_key: ?[]const u8 = null, access_key: ?[]const u8 = null,
secret_key: ?[]const u8 = null, secret_key: ?[]const u8 = null,
}; };
fn credsForFile(allocator: std.mem.Allocator, io: std.Io, file: ?std.fs.File, profile: []const u8) !PartialCredentials { fn credsForFile(allocator: std.mem.Allocator, io: std.Io, file: ?std.Io.File, profile: []const u8) !PartialCredentials {
if (file == null) return PartialCredentials{}; if (file == null) return PartialCredentials{};
var fbuf: [1024]u8 = undefined; var fbuf: [1024]u8 = undefined;
var freader = file.?.reader(io, &fbuf); var freader = file.?.reader(io, &fbuf);
@ -610,6 +603,7 @@ fn trimmed(text: []const u8, start: ?usize, end: ?usize) []const u8 {
fn filePath( fn filePath(
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
map: *const std.process.Environ.Map,
specified_path: ?[]const u8, specified_path: ?[]const u8,
env_var_name: []const u8, env_var_name: []const u8,
config_dir: ?[]const u8, config_dir: ?[]const u8,
@ -617,39 +611,28 @@ fn filePath(
) !EvaluatedPath { ) !EvaluatedPath {
if (specified_path) |p| return EvaluatedPath{ .evaluated_path = try allocator.dupe(u8, p) }; if (specified_path) |p| return EvaluatedPath{ .evaluated_path = try allocator.dupe(u8, p) };
// Not specified. Check environment variable, otherwise, hard coded default // Not specified. Check environment variable, otherwise, hard coded default
if (try getEnvironmentVariable(allocator, env_var_name)) |v| return EvaluatedPath{ .evaluated_path = v }; if (getEnvironmentVariable(map, env_var_name)) |v| return EvaluatedPath{ .evaluated_path = try allocator.dupe(u8, v) };
// Not in environment variable either. Go fish // Not in environment variable either. Go fish
return try getDefaultPath(allocator, config_dir, ".aws", config_file_name); return try getDefaultPath(allocator, map, config_dir, ".aws", config_file_name);
} }
const EvaluatedPath = struct { const EvaluatedPath = struct {
home: ?[]const u8 = null, home: ?[]const u8 = null,
evaluated_path: []const u8, evaluated_path: []const u8,
}; };
fn getDefaultPath(allocator: std.mem.Allocator, home_dir: ?[]const u8, dir: []const u8, file: []const u8) !EvaluatedPath { fn getDefaultPath(allocator: std.mem.Allocator, map: *const std.process.Environ.Map, home_dir: ?[]const u8, dir: []const u8, file: []const u8) !EvaluatedPath {
const home = home_dir orelse try getHomeDir(allocator); const home = home_dir orelse try getHomeDir(allocator, map);
log.debug("Home directory: {s}", .{home}); log.debug("Home directory: {s}", .{home});
const rc = try std.fs.path.join(allocator, &[_][]const u8{ home, dir, file }); const rc = try std.fs.path.join(allocator, &[_][]const u8{ home, dir, file });
log.debug("Path evaluated as: {s}", .{rc}); log.debug("Path evaluated as: {s}", .{rc});
return EvaluatedPath{ .home = home, .evaluated_path = rc }; return EvaluatedPath{ .home = home, .evaluated_path = rc };
} }
fn getHomeDir(allocator: std.mem.Allocator) ![]const u8 { fn getHomeDir(allocator: std.mem.Allocator, map: *const std.process.Environ.Map) ![]const u8 {
switch (builtin.os.tag) { const env_key = switch (builtin.os.tag) {
.windows => { .windows => "USERPROFILE",
return std.process.getEnvVarOwned(allocator, "USERPROFILE") catch |err| switch (err) { .macos, .linux, .freebsd, .netbsd, .dragonfly, .openbsd, .illumos => "HOME",
error.OutOfMemory => |e| return e,
else => return error.HomeDirUnavailable,
};
},
.macos, .linux, .freebsd, .netbsd, .dragonfly, .openbsd, .illumos => {
const home_dir = std.posix.getenv("HOME") orelse {
// TODO look in /etc/passwd
return error.HomeDirUnavailable;
};
return allocator.dupe(u8, home_dir);
},
// Code from https://github.com/ziglang/zig/blob/9f9f215305389c08a21730859982b68bf2681932/lib/std/fs/get_app_data_dir.zig // Code from https://github.com/ziglang/zig/blob/9f9f215305389c08a21730859982b68bf2681932/lib/std/fs/get_app_data_dir.zig
// be_user_settings magic number is probably different for home directory // be_user_settings magic number is probably different for home directory
// .haiku => { // .haiku => {
@ -665,17 +648,26 @@ fn getHomeDir(allocator: std.mem.Allocator) ![]const u8 {
// } // }
// }, // },
else => @compileError("Unsupported OS"), else => @compileError("Unsupported OS"),
} };
return try allocator.dupe(u8, getEnvironmentVariable(map, env_key) orelse return error.HomeDirUnavailable);
} }
test "filePath" { test "filePath" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var map = std.process.Environ.Map.init(allocator);
defer map.deinit();
try map.put("USERPROFILE", "c:\\users\\myuser");
try map.put("HOME", "/home/user");
// std.testing.log_level = .debug; // std.testing.log_level = .debug;
// log.debug("\n", .{}); // log.debug("\n", .{});
const path = try filePath(allocator, null, "NOTHING", null, "hello"); const path = try filePath(allocator, &map, null, "NOTHING", null, "hello");
defer allocator.free(path.evaluated_path); defer allocator.free(path.evaluated_path);
defer allocator.free(path.home.?); defer allocator.free(path.home.?);
try std.testing.expect(path.evaluated_path.len > 10); // try std.testing.expect(path.evaluated_path.len > 10);
if (builtin.os.tag == .windows)
try std.testing.expectEqualStrings("c:\\users\\myuser\\.aws\\hello", path.evaluated_path)
else
try std.testing.expectEqualStrings("/home/user/.aws/hello", path.evaluated_path);
try std.testing.expectEqualStrings("hello", path.evaluated_path[path.evaluated_path.len - 5 ..]); try std.testing.expectEqualStrings("hello", path.evaluated_path[path.evaluated_path.len - 5 ..]);
try std.testing.expect(path.home != null); try std.testing.expect(path.home != null);
} }

49
src/aws_http.zig
View file

@ -103,6 +103,7 @@ pub const Mock = struct {
context: usize = 0, context: usize = 0,
request_fn: *const fn ( request_fn: *const fn (
usize, usize,
std.Io,
std.http.Method, std.http.Method,
std.Uri, std.Uri,
std.http.Client.RequestOptions, std.http.Client.RequestOptions,
@ -111,8 +112,8 @@ pub const Mock = struct {
receive_head: *const fn (usize) std.http.Client.Request.ReceiveHeadError!std.http.Client.Response, receive_head: *const fn (usize) std.http.Client.Request.ReceiveHeadError!std.http.Client.Response,
reader_decompressing: *const fn (usize) *std.Io.Reader, reader_decompressing: *const fn (usize) *std.Io.Reader,
fn request(m: Mock, method: std.http.Method, uri: std.Uri, options: std.http.Client.RequestOptions) std.http.Client.RequestError!std.http.Client.Request { fn request(m: Mock, io: std.Io, method: std.http.Method, uri: std.Uri, options: std.http.Client.RequestOptions) std.http.Client.RequestError!std.http.Client.Request {
return m.request_fn(m.context, method, uri, options); return m.request_fn(m.context, io, method, uri, options);
} }
fn sendBodyComplete(m: Mock, body: []u8) std.Io.Writer.Error!void { fn sendBodyComplete(m: Mock, body: []u8) std.Io.Writer.Error!void {
return m.send_body_complete(m.context, body); return m.send_body_complete(m.context, body);
@ -147,14 +148,16 @@ pub const AwsHttp = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
proxy: ?std.http.Client.Proxy, proxy: ?std.http.Client.Proxy,
io: std.Io, io: std.Io,
map: *const std.process.Environ.Map,
const Self = @This(); const Self = @This();
pub fn init(allocator: std.mem.Allocator, io: std.Io, proxy: ?std.http.Client.Proxy) Self { pub fn init(allocator: std.mem.Allocator, io: std.Io, map: *const std.process.Environ.Map, proxy: ?std.http.Client.Proxy) Self {
return Self{ return Self{
.allocator = allocator, .allocator = allocator,
.proxy = proxy, .proxy = proxy,
.io = io, .io = io,
.map = map,
// .credentialsProvider = // creds provider could be useful // .credentialsProvider = // creds provider could be useful
}; };
} }
@ -186,11 +189,11 @@ pub const AwsHttp = struct {
// S3 control uses <account-id>.s3-control.<region>.amazonaws.com // S3 control uses <account-id>.s3-control.<region>.amazonaws.com
// //
// So this regionSubDomain call needs to handle generic customization // So this regionSubDomain call needs to handle generic customization
const endpoint = try endpointForRequest(self.allocator, service, request, options); const endpoint = try endpointForRequest(self.allocator, service, request, self.map, options);
defer endpoint.deinit(); defer endpoint.deinit();
log.debug("Calling endpoint {s}", .{endpoint.uri}); log.debug("Calling endpoint {s}", .{endpoint.uri});
// TODO: Should we allow customization here? // TODO: Should we allow customization here?
const creds = try credentials.getCredentials(self.allocator, self.io, options.credential_options); const creds = try credentials.getCredentials(self.allocator, self.map, self.io, options.credential_options);
defer creds.deinit(); defer creds.deinit();
const signing_config: signing.Config = .{ const signing_config: signing.Config = .{
.region = getRegion(service, options.region), .region = getRegion(service, options.region),
@ -238,7 +241,7 @@ pub const AwsHttp = struct {
// We will use endpoint instead // We will use endpoint instead
request_cp.path = endpoint.path; request_cp.path = endpoint.path;
var request_headers = std.ArrayList(std.http.Header){}; var request_headers: std.ArrayList(std.http.Header) = .empty;
defer request_headers.deinit(self.allocator); defer request_headers.deinit(self.allocator);
const len = try addHeaders(self.allocator, &request_headers, endpoint.host, request_cp.body, request_cp.content_type, request_cp.headers); const len = try addHeaders(self.allocator, &request_headers, endpoint.host, request_cp.body, request_cp.content_type, request_cp.headers);
@ -252,7 +255,7 @@ pub const AwsHttp = struct {
} }
} }
var headers = std.ArrayList(std.http.Header){}; var headers: std.ArrayList(std.http.Header) = .empty;
defer headers.deinit(self.allocator); defer headers.deinit(self.allocator);
for (request_cp.headers) |header| for (request_cp.headers) |header|
try headers.append(self.allocator, .{ .name = header.name, .value = header.value }); try headers.append(self.allocator, .{ .name = header.name, .value = header.value });
@ -287,7 +290,7 @@ pub const AwsHttp = struct {
}; };
var req = if (options.mock) |m| var req = if (options.mock) |m|
try m.request(method, uri, req_options) // This will call the test harness try m.request(self.io, method, uri, req_options) // This will call the test harness
else else
try cl.request(method, uri, req_options); try cl.request(method, uri, req_options);
defer req.deinit(); defer req.deinit();
@ -328,7 +331,7 @@ pub const AwsHttp = struct {
.{ @intFromEnum(response.head.status), response.head.status.phrase() }, .{ @intFromEnum(response.head.status), response.head.status.phrase() },
); );
log.debug("Response headers:", .{}); log.debug("Response headers:", .{});
var resp_headers = std.ArrayList(Header){}; var resp_headers: std.ArrayList(Header) = .empty;
defer resp_headers.deinit(self.allocator); defer resp_headers.deinit(self.allocator);
var it = response.head.iterateHeaders(); var it = response.head.iterateHeaders();
while (it.next()) |h| { // even though we don't expect to fill the buffer, while (it.next()) |h| { // even though we don't expect to fill the buffer,
@ -365,10 +368,11 @@ pub const AwsHttp = struct {
log.debug("raw response body:\n{s}", .{aw.written()}); log.debug("raw response body:\n{s}", .{aw.written()});
const rc = HttpResult{ const rc = HttpResult{
.response_code = @intFromEnum(response.head.status), .response_code = response.head.status,
.body = try aw.toOwnedSlice(), .body = try aw.toOwnedSlice(),
.headers = try resp_headers.toOwnedSlice(self.allocator), .headers = try resp_headers.toOwnedSlice(self.allocator),
.allocator = self.allocator, .allocator = self.allocator,
.io = self.io,
}; };
return rc; return rc;
} }
@ -412,25 +416,22 @@ fn addHeaders(
return null; return null;
} }
fn getEnvironmentVariable(allocator: std.mem.Allocator, key: []const u8) !?[]const u8 { fn getEnvironmentVariable(map: *const std.process.Environ.Map, key: []const u8) ?[]const u8 {
return std.process.getEnvVarOwned(allocator, key) catch |e| switch (e) { if (!map.contains(key)) return null;
std.process.GetEnvVarOwnedError.EnvironmentVariableNotFound => return null, return map.get(key);
else => return e,
};
} }
/// override endpoint url. Intended for use in testing. Normally, you should /// override endpoint url. Intended for use in testing. Normally, you should
/// rely on AWS_ENDPOINT_URL environment variable for this /// rely on AWS_ENDPOINT_URL environment variable for this
pub var endpoint_override: ?[]const u8 = null; pub var endpoint_override: ?[]const u8 = null;
fn endpointForRequest(allocator: std.mem.Allocator, service: []const u8, request: HttpRequest, options: Options) !EndPoint { fn endpointForRequest(allocator: std.mem.Allocator, service: []const u8, request: HttpRequest, map: *const std.process.Environ.Map, options: Options) !EndPoint {
if (endpoint_override) |override| { if (endpoint_override) |override| {
const uri = try allocator.dupe(u8, override); const uri = try allocator.dupe(u8, override);
return endPointFromUri(allocator, uri, request.path); return endPointFromUri(allocator, uri, request.path);
} }
const environment_override = try getEnvironmentVariable(allocator, "AWS_ENDPOINT_URL"); const environment_override = getEnvironmentVariable(map, "AWS_ENDPOINT_URL");
if (environment_override) |override| { if (environment_override) |override| {
defer allocator.free(override);
const uri = try allocator.dupe(u8, override); const uri = try allocator.dupe(u8, override);
return endPointFromUri(allocator, uri, request.path); return endPointFromUri(allocator, uri, request.path);
} }
@ -577,7 +578,8 @@ test "endpointForRequest standard operation" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
const service = "dynamodb"; const service = "dynamodb";
const endpoint = try endpointForRequest(allocator, service, request, options); const map = std.process.Environ.Map.init(allocator);
const endpoint = try endpointForRequest(allocator, service, request, &map, options);
defer endpoint.deinit(); defer endpoint.deinit();
try std.testing.expectEqualStrings("https://dynamodb.us-west-2.amazonaws.com", endpoint.uri); try std.testing.expectEqualStrings("https://dynamodb.us-west-2.amazonaws.com", endpoint.uri);
} }
@ -592,7 +594,8 @@ test "endpointForRequest for cloudfront" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
const service = "cloudfront"; const service = "cloudfront";
const endpoint = try endpointForRequest(allocator, service, request, options); const map = std.process.Environ.Map.init(allocator);
const endpoint = try endpointForRequest(allocator, service, request, &map, options);
defer endpoint.deinit(); defer endpoint.deinit();
try std.testing.expectEqualStrings("https://cloudfront.amazonaws.com", endpoint.uri); try std.testing.expectEqualStrings("https://cloudfront.amazonaws.com", endpoint.uri);
} }
@ -607,7 +610,8 @@ test "endpointForRequest for s3" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
const service = "s3"; const service = "s3";
const endpoint = try endpointForRequest(allocator, service, request, options); const map = std.process.Environ.Map.init(allocator);
const endpoint = try endpointForRequest(allocator, service, request, &map, options);
defer endpoint.deinit(); defer endpoint.deinit();
try std.testing.expectEqualStrings("https://s3.us-east-2.amazonaws.com", endpoint.uri); try std.testing.expectEqualStrings("https://s3.us-east-2.amazonaws.com", endpoint.uri);
} }
@ -623,7 +627,8 @@ test "endpointForRequest for s3 - specific bucket" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
const service = "s3"; const service = "s3";
const endpoint = try endpointForRequest(allocator, service, request, options); const map = std.process.Environ.Map.init(allocator);
const endpoint = try endpointForRequest(allocator, service, request, &map, options);
defer endpoint.deinit(); defer endpoint.deinit();
try std.testing.expectEqualStrings("https://bucket.s3.us-east-2.amazonaws.com", endpoint.uri); try std.testing.expectEqualStrings("https://bucket.s3.us-east-2.amazonaws.com", endpoint.uri);
try std.testing.expectEqualStrings("/key", endpoint.path); try std.testing.expectEqualStrings("/key", endpoint.path);

2
src/aws_http_base.zig
View file

@ -13,6 +13,8 @@ pub const Result = struct {
body: []const u8, body: []const u8,
headers: []const std.http.Header, headers: []const std.http.Header,
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
/// The io that was used for the request
io: std.Io,
pub fn deinit(self: Result) void { pub fn deinit(self: Result) void {
self.allocator.free(self.body); self.allocator.free(self.body);

24
src/aws_signing.zig
View file

@ -157,7 +157,7 @@ pub const SigningError = error{
XAmzExpiresHeaderInRequest, XAmzExpiresHeaderInRequest,
/// Used if the request headers already includes x-amz-region-set /// Used if the request headers already includes x-amz-region-set
XAmzRegionSetHeaderInRequest, XAmzRegionSetHeaderInRequest,
} || error{OutOfMemory} || std.Io.Clock.Error; } || error{OutOfMemory}; // || std.Io.Clock.Error;
const forbidden_headers = .{ const forbidden_headers = .{
.{ .name = "x-amz-content-sha256", .err = SigningError.XAmzContentSha256HeaderInRequest }, .{ .name = "x-amz-content-sha256", .err = SigningError.XAmzContentSha256HeaderInRequest },
@ -196,7 +196,7 @@ pub fn signRequest(allocator: std.mem.Allocator, io: std.Io, request: base.Reque
var rc = request; var rc = request;
const signing_time = config.signing_time orelse blk: { const signing_time = config.signing_time orelse blk: {
const now = try std.Io.Clock.Timestamp.now(io, .awake); const now = std.Io.Clock.Timestamp.now(io, .real);
break :blk @as(i64, @intCast(@divFloor(now.raw.nanoseconds, std.time.ns_per_s))); break :blk @as(i64, @intCast(@divFloor(now.raw.nanoseconds, std.time.ns_per_s)));
}; };
@ -336,9 +336,7 @@ pub fn signRequest(allocator: std.mem.Allocator, io: std.Io, request: base.Reque
pub fn freeSignedRequest(allocator: std.mem.Allocator, request: *base.Request, config: Config) void { pub fn freeSignedRequest(allocator: std.mem.Allocator, request: *base.Request, config: Config) void {
validateConfig(config) catch |e| { validateConfig(config) catch |e| {
log.err("Signing validation failed during signature free: {}", .{e}); log.err("Signing validation failed during signature free: {}", .{e});
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
return; return;
}; };
@ -369,7 +367,7 @@ pub const UnverifiedRequest = struct {
raw: *std.http.Server.Request, raw: *std.http.Server.Request,
pub fn init(allocator: std.mem.Allocator, request: *std.http.Server.Request) !UnverifiedRequest { pub fn init(allocator: std.mem.Allocator, request: *std.http.Server.Request) !UnverifiedRequest {
var al = std.ArrayList(std.http.Header){}; var al = std.ArrayList(std.http.Header).empty;
defer al.deinit(allocator); defer al.deinit(allocator);
var it = request.iterateHeaders(); var it = request.iterateHeaders();
while (it.next()) |h| try al.append(allocator, h); while (it.next()) |h| try al.append(allocator, h);
@ -811,7 +809,7 @@ fn canonicalQueryString(allocator: std.mem.Allocator, path: []const u8) ![]const
// Split this by component // Split this by component
var portions = std.mem.splitScalar(u8, query, '&'); var portions = std.mem.splitScalar(u8, query, '&');
var sort_me = std.ArrayList([]const u8){}; var sort_me = std.ArrayList([]const u8).empty;
defer sort_me.deinit(allocator); defer sort_me.deinit(allocator);
while (portions.next()) |item| while (portions.next()) |item|
try sort_me.append(allocator, item); try sort_me.append(allocator, item);
@ -1105,9 +1103,7 @@ test "can sign" {
// [debug] (awshttp): Content-Length: 43 // [debug] (awshttp): Content-Length: 43
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var threaded: std.Io.Threaded = .init(allocator); const io = std.testing.io;
defer threaded.deinit();
const io = threaded.io();
var headers = try std.ArrayList(std.http.Header).initCapacity(allocator, 5); var headers = try std.ArrayList(std.http.Header).initCapacity(allocator, 5);
defer headers.deinit(allocator); defer headers.deinit(allocator);
try headers.append(allocator, .{ .name = "Content-Type", .value = "application/x-www-form-urlencoded; charset=utf-8" }); try headers.append(allocator, .{ .name = "Content-Type", .value = "application/x-www-form-urlencoded; charset=utf-8" });
@ -1159,9 +1155,7 @@ test "can sign" {
var test_credential: ?Credentials = null; var test_credential: ?Credentials = null;
test "can verify server request" { test "can verify server request" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var threaded: std.Io.Threaded = .init(allocator); const io = std.testing.io;
defer threaded.deinit();
const io = threaded.io();
const access_key = try allocator.dupe(u8, "ACCESS"); const access_key = try allocator.dupe(u8, "ACCESS");
const secret_key = try allocator.dupe(u8, "SECRET"); const secret_key = try allocator.dupe(u8, "SECRET");
@ -1214,9 +1208,7 @@ test "can verify server request" {
} }
test "can verify server request without x-amz-content-sha256" { test "can verify server request without x-amz-content-sha256" {
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var threaded: std.Io.Threaded = .init(allocator); const io = std.testing.io;
defer threaded.deinit();
const io = threaded.io();
const access_key = try allocator.dupe(u8, "ACCESS"); const access_key = try allocator.dupe(u8, "ACCESS");
const secret_key = try allocator.dupe(u8, "SECRET"); const secret_key = try allocator.dupe(u8, "SECRET");

50
src/aws_test.zig
View file

@ -253,8 +253,8 @@ const TestOptions = struct {
}; };
const TestSetup = struct { const TestSetup = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
threaded: std.Io.Threaded,
io: std.Io, io: std.Io,
map: *const std.process.Environ.Map,
options: TestOptions, options: TestOptions,
creds: aws_auth.Credentials, creds: aws_auth.Credentials,
client: aws.Client, client: aws.Client,
@ -265,7 +265,6 @@ const TestSetup = struct {
pub const RequestActuals = struct { pub const RequestActuals = struct {
request: *std.http.Client.Request, request: *std.http.Client.Request,
trace: []const u8,
// Looks like uri might be getting trounced before deinit // Looks like uri might be getting trounced before deinit
request_uri: []const u8, request_uri: []const u8,
@ -304,7 +303,6 @@ const TestSetup = struct {
} }
allocator.free(self.extra_headers); allocator.free(self.extra_headers);
allocator.free(self.trace);
allocator.free(self.request_uri); allocator.free(self.request_uri);
allocator.destroy(self.request.reader.in); allocator.destroy(self.request.reader.in);
allocator.destroy(self.request.client); allocator.destroy(self.request.client);
@ -325,24 +323,21 @@ const TestSetup = struct {
fn request( fn request(
self_ptr: usize, self_ptr: usize,
io: std.Io,
method: std.http.Method, method: std.http.Method,
uri: std.Uri, uri: std.Uri,
options: std.http.Client.RequestOptions, options: std.http.Client.RequestOptions,
) std.http.Client.RequestError!std.http.Client.Request { ) std.http.Client.RequestError!std.http.Client.Request {
_ = io;
const self: *Self = @ptrFromInt(self_ptr); const self: *Self = @ptrFromInt(self_ptr);
if (self.request_actuals) |r| { if (self.request_actuals) |_| {
std.debug.print("request has been called twice. Previous stack trace:\n", .{}); std.debug.print("request has been called twice:\n", .{});
var stderr = std.fs.File.stderr().writer(&.{});
stderr.interface.writeAll(r.trace) catch @panic("could not write to stderr");
std.debug.print("Current stack trace:\n", .{}); std.debug.print("Current stack trace:\n", .{});
std.debug.dumpCurrentStackTrace(.{}); std.debug.dumpCurrentStackTrace(.{});
return error.ConnectionRefused; // we should not be called twice return error.ConnectionRefused; // we should not be called twice
} }
const acts = try self.allocator.create(RequestActuals); const acts = try self.allocator.create(RequestActuals);
errdefer self.allocator.destroy(acts); errdefer self.allocator.destroy(acts);
var aw = std.Io.Writer.Allocating.init(self.allocator);
defer aw.deinit();
std.debug.writeCurrentStackTrace(.{}, &aw.writer, .no_color) catch return error.OutOfMemory;
const req = try self.allocator.create(std.http.Client.Request); const req = try self.allocator.create(std.http.Client.Request);
errdefer self.allocator.destroy(req); errdefer self.allocator.destroy(req);
const reader = try self.allocator.create(std.Io.Reader); const reader = try self.allocator.create(std.Io.Reader);
@ -386,7 +381,6 @@ const TestSetup = struct {
}); });
acts.* = .{ acts.* = .{
.trace = try self.allocator.dupe(u8, aw.written()),
.request = req, .request = req,
.request_uri = try std.fmt.allocPrint(self.allocator, "{f}", .{uri}), .request_uri = try std.fmt.allocPrint(self.allocator, "{f}", .{uri}),
.extra_headers = try al.toOwnedSlice(self.allocator), .extra_headers = try al.toOwnedSlice(self.allocator),
@ -445,9 +439,10 @@ const TestSetup = struct {
return self.request_actuals.?.request.reader.in; return self.request_actuals.?.request.reader.in;
} }
fn init(options: TestOptions) !*Self { fn init(options: TestOptions) !*Self {
var threaded: std.Io.Threaded = .init(options.allocator); const io = std.testing.io;
const io = threaded.io(); const map = try options.allocator.create(std.process.Environ.Map);
const client = aws.Client.init(options.allocator, .{ .io = io }); map.* = std.process.Environ.Map.init(options.allocator);
const client = aws.Client.init(options.allocator, .{ .io = io, .map = map });
const call_options = try options.allocator.create(aws.Options); const call_options = try options.allocator.create(aws.Options);
const self = try options.allocator.create(Self); const self = try options.allocator.create(Self);
call_options.* = .{ call_options.* = .{
@ -467,8 +462,8 @@ const TestSetup = struct {
self.* = .{ self.* = .{
.options = options, .options = options,
.allocator = options.allocator, .allocator = options.allocator,
.threaded = threaded,
.io = io, .io = io,
.map = map,
.creds = aws_auth.Credentials.init( .creds = aws_auth.Credentials.init(
options.allocator, options.allocator,
try options.allocator.dupe(u8, "ACCESS"), try options.allocator.dupe(u8, "ACCESS"),
@ -482,6 +477,7 @@ const TestSetup = struct {
return self; return self;
} }
fn deinit(self: *Self) void { fn deinit(self: *Self) void {
self.options.allocator.destroy(self.map);
if (self.response_actuals) |r| { if (self.response_actuals) |r| {
self.allocator.free(r.body); self.allocator.free(r.body);
self.allocator.destroy(r); self.allocator.destroy(r);
@ -492,7 +488,6 @@ const TestSetup = struct {
} }
self.allocator.destroy(self.call_options); self.allocator.destroy(self.call_options);
self.call_options = undefined; self.call_options = undefined;
self.threaded.deinit();
self.allocator.destroy(self); self.allocator.destroy(self);
aws_creds.static_credentials = null; aws_creds.static_credentials = null;
} }
@ -1182,13 +1177,9 @@ test "json_1_1: ECR timestamps" {
try std.testing.expectEqualStrings("https://146325435496.dkr.ecr.us-west-2.amazonaws.com", call.response.authorization_data.?[0].proxy_endpoint.?); try std.testing.expectEqualStrings("https://146325435496.dkr.ecr.us-west-2.amazonaws.com", call.response.authorization_data.?[0].proxy_endpoint.?);
// try std.testing.expectEqual(@as(i64, 1.73859841557E9), call.response.authorization_data.?[0].expires_at.?); // try std.testing.expectEqual(@as(i64, 1.73859841557E9), call.response.authorization_data.?[0].expires_at.?);
const zeit = @import("zeit"); const expected_ts = try date.Timestamp.parse("2022-05-17T06:56:13.652000+00:00");
const expected_ins = try zeit.instant(.{ const actual = call.response.authorization_data.?[0].expires_at.?;
.source = .{ .iso8601 = "2022-05-17T06:56:13.652000+00:00" }, try std.testing.expectEqual(expected_ts, actual);
});
const expected_ts: date.Timestamp = @enumFromInt(expected_ins.timestamp);
try std.testing.expectEqual(expected_ts, call.response.authorization_data.?[0].expires_at.?);
} }
test "jsonStringify: structure + enums" { test "jsonStringify: structure + enums" {
@ -1340,7 +1331,7 @@ test "works against a live server" {
const Server = struct { const Server = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
io: std.Io, io: std.Io,
ready: std.Thread.Semaphore = .{}, ready: std.Io.Semaphore = .{},
requests_received: usize = 0, requests_received: usize = 0,
thread: ?std.Thread = null, thread: ?std.Thread = null,
listening_uri: []const u8 = undefined, listening_uri: []const u8 = undefined,
@ -1362,7 +1353,7 @@ test "works against a live server" {
threadMain, threadMain,
.{self}, .{self},
); );
try self.ready.timedWait(1000 * std.time.ns_per_ms); try self.ready.wait(self.io); // This could hang the test...
awshttp.endpoint_override = self.listening_uri; awshttp.endpoint_override = self.listening_uri;
if (awshttp.endpoint_override == null) return error.TestSetupStartFailure; if (awshttp.endpoint_override == null) return error.TestSetupStartFailure;
std.log.debug("endpoint override set to {?s}", .{awshttp.endpoint_override}); std.log.debug("endpoint override set to {?s}", .{awshttp.endpoint_override});
@ -1391,7 +1382,7 @@ test "works against a live server" {
self.allocator.free(self.listening_uri); self.allocator.free(self.listening_uri);
self.listening_uri = undefined; self.listening_uri = undefined;
} }
self.ready.post(); self.ready.post(self.io);
while (true) { while (true) {
var connection = try server.accept(self.io); var connection = try server.accept(self.io);
defer connection.close(self.io); defer connection.close(self.io);
@ -1424,9 +1415,8 @@ test "works against a live server" {
} }
}; };
const allocator = std.testing.allocator; const allocator = std.testing.allocator;
var threaded: std.Io.Threaded = .init(allocator); const io = std.testing.io;
defer threaded.deinit(); const map = std.process.Environ.Map.init(allocator);
const io = threaded.io();
var server = Server{ .allocator = allocator, .io = io }; var server = Server{ .allocator = allocator, .io = io };
try server.start(); try server.start();
var stopped = false; var stopped = false;
@ -1447,7 +1437,7 @@ test "works against a live server" {
// } // }
const sts = (Services(.{.sts}){}).sts; const sts = (Services(.{.sts}){}).sts;
const client = aws.Client.init(std.testing.allocator, .{ .io = io }); const client = aws.Client.init(std.testing.allocator, .{ .io = io, .map = &map });
const creds = aws_auth.Credentials.init( const creds = aws_auth.Credentials.init(
allocator, allocator,
try allocator.dupe(u8, "ACCESS"), try allocator.dupe(u8, "ACCESS"),

27
src/main.zig
View file

@ -32,10 +32,9 @@ pub fn log(
const prefix = "[" ++ @tagName(level) ++ "] " ++ scope_prefix; const prefix = "[" ++ @tagName(level) ++ "] " ++ scope_prefix;
// Print the message to stderr, silently ignoring any errors // Print the message to stderr, silently ignoring any errors
std.debug.lockStdErr(); const locked = std.debug.lockStderr(&.{});
defer std.debug.unlockStdErr(); defer std.debug.unlockStderr();
var stderr_writer = std.fs.File.stderr().writer(&.{}); const stderr = &locked.file_writer.interface;
const stderr = &stderr_writer.interface;
nosuspend stderr.print(prefix ++ format ++ "\n", args) catch return; nosuspend stderr.print(prefix ++ format ++ "\n", args) catch return;
} }
@ -59,16 +58,15 @@ const Tests = enum {
rest_xml_work_with_s3, rest_xml_work_with_s3,
}; };
pub fn main() anyerror!void { pub fn main(init: std.process.Init) anyerror!void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){}; const allocator = init.gpa;
defer _ = gpa.deinit(); const io = init.io;
const allocator = gpa.allocator(); const map = init.environ_map;
var tests = try std.ArrayList(Tests).initCapacity(allocator, @typeInfo(Tests).@"enum".fields.len); var tests = try std.ArrayList(Tests).initCapacity(allocator, @typeInfo(Tests).@"enum".fields.len);
defer tests.deinit(allocator); defer tests.deinit(allocator);
var args = try std.process.argsWithAllocator(allocator); var args = try init.minimal.args.iterateAllocator(init.arena.allocator());
defer args.deinit();
var stdout_buf: [4096]u8 = undefined; var stdout_buf: [4096]u8 = undefined;
const stdout_raw = std.fs.File.stdout().writer(&stdout_buf); const stdout_raw = std.Io.File.stdout().writer(io, &stdout_buf);
var stdout = stdout_raw.interface; var stdout = stdout_raw.interface;
defer stdout.flush() catch @panic("could not flush stdout"); defer stdout.flush() catch @panic("could not flush stdout");
var arg0: ?[]const u8 = null; var arg0: ?[]const u8 = null;
@ -111,10 +109,7 @@ pub fn main() anyerror!void {
} }
std.log.info("Start\n", .{}); std.log.info("Start\n", .{});
var threaded: std.Io.Threaded = .init(allocator); const client_options = aws.ClientOptions{ .proxy = proxy, .io = io, .map = map };
defer threaded.deinit();
const io = threaded.io();
const client_options = aws.ClientOptions{ .proxy = proxy, .io = io };
var client = aws.Client.init(allocator, client_options); var client = aws.Client.init(allocator, client_options);
const options = aws.Options{ const options = aws.Options{
.region = "us-west-2", .region = "us-west-2",
@ -376,7 +371,7 @@ fn proxyFromString(string: []const u8) !std.http.Client.Proxy {
rc.protocol = .tls; rc.protocol = .tls;
} else return error.InvalidScheme; } else return error.InvalidScheme;
var split_iterator = std.mem.splitScalar(u8, remaining, ':'); var split_iterator = std.mem.splitScalar(u8, remaining, ':');
const host_str = std.mem.trimRight(u8, split_iterator.first(), "/"); const host_str = std.mem.trimEnd(u8, split_iterator.first(), "/");
rc.host = try std.Io.net.HostName.init(host_str); rc.host = try std.Io.net.HostName.init(host_str);
if (split_iterator.next()) |port| if (split_iterator.next()) |port|
rc.port = try std.fmt.parseInt(u16, port, 10); rc.port = try std.fmt.parseInt(u16, port, 10);

4
src/xml.zig
View file

@ -31,8 +31,8 @@ pub const Element = struct {
fn init(tag: []const u8, alloc: Allocator) Element { fn init(tag: []const u8, alloc: Allocator) Element {
return .{ return .{
.tag = tag, .tag = tag,
.attributes = AttributeList{}, .attributes = .empty,
.children = ContentList{}, .children = .empty,
.allocator = alloc, .allocator = alloc,
}; };
} }

6
src/xml_shaper.zig
View file

@ -192,9 +192,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions)
e, e,
}, },
); );
if (@errorReturnTrace()) |trace| { std.debug.dumpCurrentStackTrace(.{});
std.debug.dumpStackTrace(trace);
}
} }
return e; return e;
}; };
@ -381,7 +379,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions)
log.debug("type = {s}, style = {s}, ptr_info.child == {s}, element = {s}", .{ @typeName(T), @tagName(array_style), @typeName(ptr_info.child), element.tag }); log.debug("type = {s}, style = {s}, ptr_info.child == {s}, element = {s}", .{ @typeName(T), @tagName(array_style), @typeName(ptr_info.child), element.tag });
var children = std.ArrayList(ptr_info.child){}; var children = std.ArrayList(ptr_info.child).empty;
defer children.deinit(allocator); defer children.deinit(allocator);
switch (array_style) { switch (array_style) {