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

Compare commits

base: lobo:d84824b84ec634cafdf617af744bc9c683b67af5
Branches Tags
lobo:master
lobo:zig-develop
lobo:0.11.0
lobo:0.11
lobo:0.9.0
lobo:aws-crt
lobo:xml
lobo:zig-0.12.0
lobo:v0.1
..
compare: lobo:645cc1d7ca4109a662f76e6018db3a5070ae66c2
Branches Tags
lobo:master
lobo:zig-develop
lobo:0.11.0
lobo:0.11
lobo:0.9.0
lobo:aws-crt
lobo:xml
lobo:zig-0.12.0
lobo:v0.1

No commits in common. "d84824b84ec634cafdf617af744bc9c683b67af5" and "645cc1d7ca4109a662f76e6018db3a5070ae66c2" have entirely different histories.
d84824b84e ... 645cc1d7ca

17 changed files with 134 additions and 137 deletions
Show Stats Expand all files Collapse all files

17
Package.zig
View File

@ -33,7 +33,7 @@ pub fn fetchOneAndUnpack(
var http_client: std.http.Client = .{ .allocator = allocator }; var http_client: std.http.Client = .{ .allocator = allocator };
defer http_client.deinit(); defer http_client.deinit();
const global_cache_directory: std.Build.Cache.Directory = .{ var global_cache_directory: std.Build.Cache.Directory = .{
.handle = try std.fs.cwd().makeOpenPath(cache_directory, .{}), .handle = try std.fs.cwd().makeOpenPath(cache_directory, .{}),
.path = cache_directory, .path = cache_directory,
}; };
@ -111,14 +111,12 @@ pub fn fetchAndUnpack(
const path = try global_cache_directory.join(gpa, &.{tmp_dir_sub_path}); const path = try global_cache_directory.join(gpa, &.{tmp_dir_sub_path});
errdefer gpa.free(path); errdefer gpa.free(path);
const iterable_dir = try global_cache_directory.handle.makeOpenPath(tmp_dir_sub_path, .{ const iterable_dir = try global_cache_directory.handle.makeOpenPathIterable(tmp_dir_sub_path, .{});
.iterate = true,
});
errdefer iterable_dir.close(); errdefer iterable_dir.close();
break :d .{ break :d .{
.path = path, .path = path,
.handle = iterable_dir, .handle = iterable_dir.dir,
}; };
}; };
defer tmp_directory.closeAndFree(gpa); defer tmp_directory.closeAndFree(gpa);
@ -126,10 +124,10 @@ pub fn fetchAndUnpack(
var h = std.http.Headers{ .allocator = gpa }; var h = std.http.Headers{ .allocator = gpa };
defer h.deinit(); defer h.deinit();
var req = try http_client.open(.GET, uri, h, .{}); var req = try http_client.request(.GET, uri, h, .{});
defer req.deinit(); defer req.deinit();
try req.send(.{}); try req.start();
try req.wait(); try req.wait();
if (req.response.status != .ok) { if (req.response.status != .ok) {
@ -204,8 +202,7 @@ pub fn fetchAndUnpack(
// Of course, if the ignore rules above omit the file from the package, then everything // Of course, if the ignore rules above omit the file from the package, then everything
// is fine and no error should be raised. // is fine and no error should be raised.
var options = .{}; break :a try Hasher.computeDirectoryHash(thread_pool, .{ .dir = tmp_directory.handle }, &.{});
break :a try Hasher.computeDirectoryHash(thread_pool, tmp_directory.handle, &options);
}; };
const pkg_dir_sub_path = "p" ++ s ++ Hasher.hexDigest(actual_hash); const pkg_dir_sub_path = "p" ++ s ++ Hasher.hexDigest(actual_hash);
@ -467,7 +464,7 @@ test "fetch and unpack" {
var http_client: std.http.Client = .{ .allocator = alloc }; var http_client: std.http.Client = .{ .allocator = alloc };
defer http_client.deinit(); defer http_client.deinit();
const global_cache_directory: std.Build.Cache.Directory = .{ var global_cache_directory: std.Build.Cache.Directory = .{
.handle = try std.fs.cwd().makeOpenPath("test-pkg", .{}), .handle = try std.fs.cwd().makeOpenPath("test-pkg", .{}),
.path = "test-pkg", .path = "test-pkg",
}; };

26
build.zig
View File

@ -1,6 +1,6 @@
const std = @import("std"); const std = @import("std");
const builtin = @import("builtin"); const builtin = @import("builtin");
const Builder = @import("std").Build; const Builder = @import("std").build.Builder;
const Package = @import("Package.zig"); const Package = @import("Package.zig");
const models_url = "https://github.com/aws/aws-sdk-go-v2/archive/7502ff360b1c3b79cbe117437327f6ff5fb89f65.tar.gz"; const models_url = "https://github.com/aws/aws-sdk-go-v2/archive/7502ff360b1c3b79cbe117437327f6ff5fb89f65.tar.gz";
@ -79,18 +79,22 @@ pub fn build(b: *Builder) !void {
.optimize = optimize, .optimize = optimize,
}); });
const smithy_module = smithy_dep.module("smithy"); const smithy_module = smithy_dep.module("smithy");
exe.root_module.addImport("smithy", smithy_module); // not sure this should be here... exe.addModule("smithy", smithy_module); // not sure this should be here...
// Expose module to others // Expose module to others
_ = b.addModule("aws", .{ _ = b.addModule("aws", .{
.root_source_file = .{ .path = "src/aws.zig" }, .source_file = .{ .path = "src/aws.zig" },
.imports = &.{.{ .name = "smithy", .module = smithy_module }}, .dependencies = &[_]std.build.ModuleDependency{
.{ .name = "smithy", .module = smithy_module },
},
}); });
// Expose module to others // Expose module to others
_ = b.addModule("aws-signing", .{ _ = b.addModule("aws-signing", .{
.root_source_file = .{ .path = "src/aws_signing.zig" }, .source_file = .{ .path = "src/aws_signing.zig" },
.imports = &.{.{ .name = "smithy", .module = smithy_module }}, .dependencies = &[_]std.build.ModuleDependency{
.{ .name = "smithy", .module = smithy_module },
},
}); });
// TODO: This does not work correctly due to https://github.com/ziglang/zig/issues/16354 // TODO: This does not work correctly due to https://github.com/ziglang/zig/issues/16354
// //
@ -124,10 +128,10 @@ pub fn build(b: *Builder) !void {
.name = "codegen", .name = "codegen",
.root_source_file = .{ .path = "codegen/src/main.zig" }, .root_source_file = .{ .path = "codegen/src/main.zig" },
// We need this generated for the host, not the real target // We need this generated for the host, not the real target
.target = b.host, // .target = target,
.optimize = if (b.verbose) .Debug else .ReleaseSafe, .optimize = if (b.verbose) .Debug else .ReleaseSafe,
}); });
cg_exe.root_module.addImport("smithy", smithy_dep.module("smithy")); cg_exe.addModule("smithy", smithy_dep.module("smithy"));
var cg_cmd = b.addRunArtifact(cg_exe); var cg_cmd = b.addRunArtifact(cg_exe);
cg_cmd.addArg("--models"); cg_cmd.addArg("--models");
cg_cmd.addArg(try std.fs.path.join( cg_cmd.addArg(try std.fs.path.join(
@ -135,7 +139,7 @@ pub fn build(b: *Builder) !void {
&[_][]const u8{ b.global_cache_root.path.?, models_dir }, &[_][]const u8{ b.global_cache_root.path.?, models_dir },
)); ));
cg_cmd.addArg("--output"); cg_cmd.addArg("--output");
cg_cmd.addDirectoryArg(std.Build.LazyPath.relative("src/models")); cg_cmd.addDirectoryArg(std.Build.FileSource.relative("src/models"));
if (b.verbose) if (b.verbose)
cg_cmd.addArg("--verbose"); cg_cmd.addArg("--verbose");
cg_cmd.step.dependOn(&fetch_step.step); cg_cmd.step.dependOn(&fetch_step.step);
@ -169,10 +173,10 @@ pub fn build(b: *Builder) !void {
// but does not run it. // but does not run it.
const unit_tests = b.addTest(.{ const unit_tests = b.addTest(.{
.root_source_file = .{ .path = "src/aws.zig" }, .root_source_file = .{ .path = "src/aws.zig" },
.target = b.resolveTargetQuery(t), .target = t,
.optimize = optimize, .optimize = optimize,
}); });
unit_tests.root_module.addImport("smithy", smithy_dep.module("smithy")); unit_tests.addModule("smithy", smithy_dep.module("smithy"));
unit_tests.step.dependOn(gen_step); unit_tests.step.dependOn(gen_step);
const run_unit_tests = b.addRunArtifact(unit_tests); const run_unit_tests = b.addRunArtifact(unit_tests);

7
build.zig.zon
View File

@ -1,14 +1,11 @@
.{ .{
.name = "aws-zig", .name = "aws-zig",
.version = "0.0.1", .version = "0.0.1",
.paths = .{""},
.dependencies = .{ .dependencies = .{
.smithy = .{ .smithy = .{
.url = "https://github.com/melhindi/smithy/archive/refs/heads/master.tar.gz", .url = "https://git.lerch.org/lobo/smithy/archive/41b61745d25a65817209dd5dddbb5f9b66896a99.tar.gz",
.hash = "12209568cc5c0bad2fcf6a62dbf6792fbbf3727214da98b21c390fc399f6dd743d3a", .hash = "122087deb0ae309b2258d59b40d82fe5921fdfc35b420bb59033244851f7f276fa34",
// .url = "https://git.lerch.org/lobo/smithy/archive/41b61745d25a65817209dd5dddbb5f9b66896a99.tar.gz",
// .hash = "122087deb0ae309b2258d59b40d82fe5921fdfc35b420bb59033244851f7f276fa34",
}, },
}, },
} }

10
codegen/src/Hasher.zig
View File

@ -77,13 +77,13 @@ pub fn hex64(x: u64) [16]u8 {
return result; return result;
} }
pub const walkerFn = *const fn (std.fs.Dir.Walker.WalkerEntry) bool; pub const walkerFn = *const fn (std.fs.IterableDir.Walker.WalkerEntry) bool;
fn included(entry: std.fs.Dir.Walker.WalkerEntry) bool { fn included(entry: std.fs.IterableDir.Walker.WalkerEntry) bool {
_ = entry; _ = entry;
return true; return true;
} }
fn excluded(entry: std.fs.Dir.Walker.WalkerEntry) bool { fn excluded(entry: std.fs.IterableDir.Walker.WalkerEntry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -96,7 +96,7 @@ pub const ComputeDirectoryOptions = struct {
pub fn computeDirectoryHash( pub fn computeDirectoryHash(
thread_pool: *std.Thread.Pool, thread_pool: *std.Thread.Pool,
dir: std.fs.Dir, dir: std.fs.IterableDir,
options: *ComputeDirectoryOptions, options: *ComputeDirectoryOptions,
) ![Hash.digest_length]u8 { ) ![Hash.digest_length]u8 {
const gpa = thread_pool.allocator; const gpa = thread_pool.allocator;
@ -138,7 +138,7 @@ pub fn computeDirectoryHash(
.failure = undefined, // to be populated by the worker .failure = undefined, // to be populated by the worker
}; };
wait_group.start(); wait_group.start();
try thread_pool.spawn(workerHashFile, .{ dir, hashed_file, &wait_group }); try thread_pool.spawn(workerHashFile, .{ dir.dir, hashed_file, &wait_group });
try all_files.append(hashed_file); try all_files.append(hashed_file);
} }

40
codegen/src/main.zig
View File

@ -17,7 +17,7 @@ pub fn main() anyerror!void {
var output_dir = std.fs.cwd(); var output_dir = std.fs.cwd();
defer if (output_dir.fd > 0) output_dir.close(); defer if (output_dir.fd > 0) output_dir.close();
var models_dir: ?std.fs.Dir = null; var models_dir: ?std.fs.IterableDir = null;
defer if (models_dir) |*m| m.close(); defer if (models_dir) |*m| m.close();
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
@ -29,19 +29,15 @@ pub fn main() anyerror!void {
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], .{ output_dir = try output_dir.makeOpenPath(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], .{ models_dir = try std.fs.cwd().openIterableDir(args[i + 1], .{});
.iterate = true,
});
} }
// TODO: Seems like we should remove this in favor of a package // TODO: Seems like we should remove this in favor of a package
try output_dir.writeFile("json.zig", json_zig); try output_dir.writeFile("json.zig", json_zig);
// TODO: We need a different way to handle this file... // TODO: We need a different way to handle this file...
const manifest_file_started = false; var manifest_file_started = false;
var manifest_file: std.fs.File = undefined; var manifest_file: std.fs.File = undefined;
defer if (manifest_file_started) manifest_file.close(); defer if (manifest_file_started) manifest_file.close();
var manifest: std.fs.File.Writer = undefined; var manifest: std.fs.File.Writer = undefined;
@ -75,11 +71,11 @@ pub fn main() anyerror!void {
// this is our normal mode of operation and where initial optimizations // this is our normal mode of operation and where initial optimizations
// can be made // can be made
if (models_dir) |m| { if (models_dir) |m| {
var cwd = try std.fs.cwd().openDir(".", .{ .iterate = true }); var cwd = try std.fs.cwd().openDir(".", .{});
defer cwd.close(); defer cwd.close();
defer cwd.setAsCwd() catch unreachable; defer cwd.setAsCwd() catch unreachable;
try m.setAsCwd(); try m.dir.setAsCwd();
try processDirectories(m, output_dir); try processDirectories(m, output_dir);
} }
} }
@ -91,7 +87,7 @@ 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(models_dir: std.fs.Dir, output_dir: std.fs.Dir) !void { fn processDirectories(models_dir: std.fs.IterableDir, output_dir: std.fs.Dir) !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();
@ -135,15 +131,15 @@ fn processDirectories(models_dir: std.fs.Dir, output_dir: std.fs.Dir) !void {
} }
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) !OutputManifest { fn calculateDigests(models_dir: std.fs.IterableDir, output_dir: std.fs.Dir, thread_pool: *std.Thread.Pool) !OutputManifest {
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(thread_pool, models_dir, @constCast(&Hasher.ComputeDirectoryOptions{
.isIncluded = struct { .isIncluded = struct {
pub fn include(entry: std.fs.Dir.Walker.WalkerEntry) bool { pub fn include(entry: std.fs.IterableDir.Walker.WalkerEntry) bool {
return std.mem.endsWith(u8, entry.basename, ".json"); return std.mem.endsWith(u8, entry.basename, ".json");
} }
}.include, }.include,
.isExcluded = struct { .isExcluded = struct {
pub fn exclude(entry: std.fs.Dir.Walker.WalkerEntry) bool { pub fn exclude(entry: std.fs.IterableDir.Walker.WalkerEntry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -152,14 +148,14 @@ 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(thread_pool, try output_dir.openIterableDir(".", .{}), @constCast(&Hasher.ComputeDirectoryOptions{
.isIncluded = struct { .isIncluded = struct {
pub fn include(entry: std.fs.Dir.Walker.WalkerEntry) bool { pub fn include(entry: std.fs.IterableDir.Walker.WalkerEntry) 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.WalkerEntry) bool { pub fn exclude(entry: std.fs.IterableDir.Walker.WalkerEntry) bool {
_ = entry; _ = entry;
return false; return false;
} }
@ -205,7 +201,7 @@ fn processFile(file_name: []const u8, output_dir: std.fs.Dir, manifest: anytype)
defer allocator.free(output_file_name); defer allocator.free(output_file_name);
for (service_names) |name| { for (service_names) |name| {
const seperator = if (output_file_name.len > 0) "-" else ""; const seperator = if (output_file_name.len > 0) "-" else "";
const new_output_file_name = try std.fmt.allocPrint( var new_output_file_name = try std.fmt.allocPrint(
allocator, allocator,
"{s}{s}{s}", "{s}{s}{s}",
.{ output_file_name, seperator, name }, .{ output_file_name, seperator, name },
@ -215,7 +211,7 @@ fn processFile(file_name: []const u8, output_dir: std.fs.Dir, manifest: anytype)
} }
{ {
// append .zig on to the file name // append .zig on to the file name
const new_output_file_name = try std.fmt.allocPrint( var new_output_file_name = try std.fmt.allocPrint(
allocator, allocator,
"{s}.zig", "{s}.zig",
.{output_file_name}, .{output_file_name},
@ -341,7 +337,7 @@ fn generateServices(allocator: std.mem.Allocator, comptime _: []const u8, file:
var generated = std.StringHashMap(void).init(allocator); var generated = std.StringHashMap(void).init(allocator);
defer generated.deinit(); defer generated.deinit();
const state = FileGenerationState{ var state = FileGenerationState{
.shape_references = shape_references, .shape_references = shape_references,
.additional_types_to_generate = &unresolved, .additional_types_to_generate = &unresolved,
.additional_types_generated = &generated, .additional_types_generated = &generated,
@ -349,8 +345,8 @@ fn generateServices(allocator: std.mem.Allocator, comptime _: []const u8, file:
}; };
for (services.items) |service| { for (services.items) |service| {
var sdk_id: []const u8 = undefined; var sdk_id: []const u8 = undefined;
const version: []const u8 = service.shape.service.version; var version: []const u8 = service.shape.service.version;
const name: []const u8 = service.name; var name: []const u8 = service.name;
var arn_namespace: []const u8 = undefined; var arn_namespace: []const u8 = undefined;
var sigv4_name: []const u8 = undefined; var sigv4_name: []const u8 = undefined;
var endpoint_prefix: []const u8 = undefined; var endpoint_prefix: []const u8 = undefined;

2
example/build.zig
View File

@ -35,7 +35,7 @@ pub fn build(b: *std.Build) void {
.target = target, .target = target,
.optimize = optimize, .optimize = optimize,
}); });
exe.root_module.addImport("aws", aws_dep.module("aws")); exe.addModule("aws", aws_dep.module("aws"));
// This declares intent for the executable to be installed into the // This declares intent for the executable to be installed into the
// standard location when the user invokes the "install" step (the default // standard location when the user invokes the "install" step (the default
// step when running `zig build`). // step when running `zig build`).

13
example/build.zig.zon
View File

@ -1,20 +1,15 @@
.{ .{
.name = "myapp", .name = "myapp",
.version = "0.0.1", .version = "0.0.1",
.paths = .{""},
.dependencies = .{ .dependencies = .{
.aws = .{ .aws = .{
.url = "https://github.com/melhindi/aws-sdk-for-zig/archive/refs/heads/master.tar.gz", .url = "https://git.lerch.org/api/packages/lobo/generic/aws-sdk-with-models/d08d0f338fb86f7d679a998ff4f65f4e2d0db595/d08d0f338fb86f7d679a998ff4f65f4e2d0db595-with-models.tar.gz",
.hash = "12205d584b2ef32dd5346a25f02ad3958eb221a08a47ad8d81605d3e3512364da5f0", .hash = "1220c8871d93592680ea2dcc88cc52fb4f0effabeed0584d2a5c54f93825741b7c66",
// .url = "https://git.lerch.org/api/packages/lobo/generic/aws-sdk-with-models/d08d0f338fb86f7d679a998ff4f65f4e2d0db595/d08d0f338fb86f7d679a998ff4f65f4e2d0db595-with-models.tar.gz",
// .hash = "1220c8871d93592680ea2dcc88cc52fb4f0effabeed0584d2a5c54f93825741b7c66",
}, },
.smithy = .{ .smithy = .{
.url = "https://github.com/melhindi/smithy/archive/refs/heads/master.tar.gz", .url = "https://git.lerch.org/lobo/smithy/archive/41b61745d25a65817209dd5dddbb5f9b66896a99.tar.gz",
.hash = "12209568cc5c0bad2fcf6a62dbf6792fbbf3727214da98b21c390fc399f6dd743d3a", .hash = "122087deb0ae309b2258d59b40d82fe5921fdfc35b420bb59033244851f7f276fa34",
// .url = "https://git.lerch.org/lobo/smithy/archive/41b61745d25a65817209dd5dddbb5f9b66896a99.tar.gz",
// .hash = "122087deb0ae309b2258d59b40d82fe5921fdfc35b420bb59033244851f7f276fa34",
}, },
}, },
} }

8
src/aws.zig
View File

@ -31,7 +31,7 @@ pub const services = servicemodel.services;
pub const Services = servicemodel.Services; pub const Services = servicemodel.Services;
pub const ClientOptions = struct { pub const ClientOptions = struct {
proxy: ?std.http.Client.Proxy = null, proxy: ?std.http.Client.HttpProxy = null,
}; };
pub const Client = struct { pub const Client = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
@ -365,7 +365,7 @@ pub fn Request(comptime request_action: anytype) type {
.raw_parsed = .{ .raw = .{} }, .raw_parsed = .{ .raw = .{} },
.allocator = options.client.allocator, .allocator = options.client.allocator,
}; };
const body_field = @field(rc.response, action.Response.http_payload); var body_field = @field(rc.response, action.Response.http_payload);
const BodyField = @TypeOf(body_field); const BodyField = @TypeOf(body_field);
if (BodyField == []const u8 or BodyField == ?[]const u8) { if (BodyField == []const u8 or BodyField == ?[]const u8) {
expected_body_field_len = 0; expected_body_field_len = 0;
@ -875,7 +875,7 @@ fn FullResponse(comptime action: anytype) type {
} }
} }
if (@hasDecl(Response, "http_payload")) { if (@hasDecl(Response, "http_payload")) {
const body_field = @field(self.response, Response.http_payload); var body_field = @field(self.response, Response.http_payload);
const BodyField = @TypeOf(body_field); const BodyField = @TypeOf(body_field);
if (BodyField == []const u8) { if (BodyField == []const u8) {
self.allocator.free(body_field); self.allocator.free(body_field);
@ -1465,7 +1465,7 @@ fn processRequest(options: *TestOptions, server: *std.http.Server) !void {
else else
res.transfer_encoding = .chunked; res.transfer_encoding = .chunked;
try res.send(); try res.do();
_ = try res.writer().writeAll(response_bytes); _ = try res.writer().writeAll(response_bytes);
try res.finish(); try res.finish();
log.debug( log.debug(

55
src/aws_credentials.zig
View File

@ -126,9 +126,9 @@ fn getContainerCredentials(allocator: std.mem.Allocator) !?auth.Credentials {
defer empty_headers.deinit(); defer empty_headers.deinit();
var cl = std.http.Client{ .allocator = allocator }; var cl = std.http.Client{ .allocator = allocator };
defer cl.deinit(); // I don't belive connection pooling would help much here as it's non-ssl and local defer cl.deinit(); // I don't belive connection pooling would help much here as it's non-ssl and local
var req = try cl.open(.GET, try std.Uri.parse(container_uri), empty_headers, .{}); var req = try cl.request(.GET, try std.Uri.parse(container_uri), empty_headers, .{});
defer req.deinit(); defer req.deinit();
try req.send(.{}); try req.start();
try req.wait(); try req.wait();
if (req.response.status != .ok and req.response.status != .not_found) { if (req.response.status != .ok and req.response.status != .not_found) {
log.warn("Bad status code received from container credentials endpoint: {}", .{@intFromEnum(req.response.status)}); log.warn("Bad status code received from container credentials endpoint: {}", .{@intFromEnum(req.response.status)});
@ -140,7 +140,7 @@ fn getContainerCredentials(allocator: std.mem.Allocator) !?auth.Credentials {
var resp_payload = try std.ArrayList(u8).initCapacity(allocator, @intCast(req.response.content_length.?)); var resp_payload = try std.ArrayList(u8).initCapacity(allocator, @intCast(req.response.content_length.?));
defer resp_payload.deinit(); defer resp_payload.deinit();
try resp_payload.resize(@intCast(req.response.content_length.?)); try resp_payload.resize(@intCast(req.response.content_length.?));
const response_data = try resp_payload.toOwnedSlice(); var response_data = try resp_payload.toOwnedSlice();
defer allocator.free(response_data); defer allocator.free(response_data);
_ = try req.readAll(response_data); _ = try req.readAll(response_data);
log.debug("Read {d} bytes from container credentials endpoint", .{response_data.len}); log.debug("Read {d} bytes from container credentials endpoint", .{response_data.len});
@ -185,9 +185,9 @@ fn getImdsv2Credentials(allocator: std.mem.Allocator) !?auth.Credentials {
var headers = std.http.Headers.init(allocator); var headers = std.http.Headers.init(allocator);
defer headers.deinit(); defer headers.deinit();
try headers.append("X-aws-ec2-metadata-token-ttl-seconds", "21600"); try headers.append("X-aws-ec2-metadata-token-ttl-seconds", "21600");
var req = try cl.open(.PUT, try std.Uri.parse("http://169.254.169.254/latest/api/token"), headers, .{}); var req = try cl.request(.PUT, try std.Uri.parse("http://169.254.169.254/latest/api/token"), headers, .{});
defer req.deinit(); defer req.deinit();
try req.send(.{}); try req.start();
try req.wait(); try req.wait();
if (req.response.status != .ok) { if (req.response.status != .ok) {
log.warn("Bad status code received from IMDS v2: {}", .{@intFromEnum(req.response.status)}); log.warn("Bad status code received from IMDS v2: {}", .{@intFromEnum(req.response.status)});
@ -228,10 +228,10 @@ fn getImdsRoleName(allocator: std.mem.Allocator, client: *std.http.Client, imds_
defer headers.deinit(); defer headers.deinit();
try headers.append("X-aws-ec2-metadata-token", imds_token); try headers.append("X-aws-ec2-metadata-token", imds_token);
var req = try client.open(.GET, try std.Uri.parse("http://169.254.169.254/latest/meta-data/iam/info"), headers, .{}); var req = try client.request(.GET, try std.Uri.parse("http://169.254.169.254/latest/meta-data/iam/info"), headers, .{});
defer req.deinit(); defer req.deinit();
try req.send(.{}); try req.start();
try req.wait(); try req.wait();
if (req.response.status != .ok and req.response.status != .not_found) { if (req.response.status != .ok and req.response.status != .not_found) {
@ -243,7 +243,7 @@ fn getImdsRoleName(allocator: std.mem.Allocator, client: *std.http.Client, imds_
log.warn("Unexpected empty response from IMDS endpoint post token", .{}); log.warn("Unexpected empty response from IMDS endpoint post token", .{});
return null; return null;
} }
const resp = try allocator.alloc(u8, @intCast(req.response.content_length.?)); var resp = try allocator.alloc(u8, @intCast(req.response.content_length.?));
defer allocator.free(resp); defer allocator.free(resp);
_ = try req.readAll(resp); _ = try req.readAll(resp);
@ -281,10 +281,10 @@ fn getImdsCredentials(allocator: std.mem.Allocator, client: *std.http.Client, ro
const url = try std.fmt.allocPrint(allocator, "http://169.254.169.254/latest/meta-data/iam/security-credentials/{s}/", .{role_name}); const url = try std.fmt.allocPrint(allocator, "http://169.254.169.254/latest/meta-data/iam/security-credentials/{s}/", .{role_name});
defer allocator.free(url); defer allocator.free(url);
var req = try client.open(.GET, try std.Uri.parse(url), headers, .{}); var req = try client.request(.GET, try std.Uri.parse(url), headers, .{});
defer req.deinit(); defer req.deinit();
try req.send(.{}); try req.start();
try req.wait(); try req.wait();
if (req.response.status != .ok and req.response.status != .not_found) { if (req.response.status != .ok and req.response.status != .not_found) {
@ -296,7 +296,7 @@ fn getImdsCredentials(allocator: std.mem.Allocator, client: *std.http.Client, ro
log.warn("Unexpected empty response from IMDS role endpoint", .{}); log.warn("Unexpected empty response from IMDS role endpoint", .{});
return null; return null;
} }
const resp = try allocator.alloc(u8, @intCast(req.response.content_length.?)); var resp = try allocator.alloc(u8, @intCast(req.response.content_length.?));
defer allocator.free(resp); defer allocator.free(resp);
_ = try req.readAll(resp); _ = try req.readAll(resp);
@ -455,7 +455,7 @@ const LineIterator = struct {
pub fn next(self: *Self) ?[]const u8 { pub fn next(self: *Self) ?[]const u8 {
if (self.inx >= self.text.len) return null; if (self.inx >= self.text.len) return null;
var current = self.inx; var current = self.inx;
const start = self.inx; var start = self.inx;
for (self.text[self.inx..], 0..) |c, i| { for (self.text[self.inx..], 0..) |c, i| {
if (c == '\n') { if (c == '\n') {
// log.debug("got \\n: {d}", .{i}); // log.debug("got \\n: {d}", .{i});
@ -571,7 +571,7 @@ const EvaluatedPath = struct {
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, home_dir: ?[]const u8, dir: []const u8, file: []const u8) !EvaluatedPath {
const home = home_dir orelse try getHomeDir(allocator); var home = home_dir orelse try getHomeDir(allocator);
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});
@ -581,18 +581,29 @@ fn getDefaultPath(allocator: std.mem.Allocator, home_dir: ?[]const u8, dir: []co
fn getHomeDir(allocator: std.mem.Allocator) ![]const u8 { fn getHomeDir(allocator: std.mem.Allocator) ![]const u8 {
switch (builtin.os.tag) { switch (builtin.os.tag) {
.windows => { .windows => {
var dir_path_ptr: [*:0]u16 = undefined;
// https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid // https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid
//const FOLDERID_Profile = std.os.windows.GUID.parse("{5E6C858F-0E22-4760-9AFE-EA3317B67173}"); const FOLDERID_Profile = std.os.windows.GUID.parse("{5E6C858F-0E22-4760-9AFE-EA3317B67173}");
switch (std.os.windows.shell32.SHGetKnownFolderPath(
const local_app_data_dir = std.process.getEnvVarOwned(allocator, "LOCALAPPDATA") catch |err| switch (err) { &FOLDERID_Profile,
error.InvalidUtf8 => return error.HomeDirUnavailable, std.os.windows.KF_FLAG_CREATE,
error.EnvironmentVariableNotFound => return error.HomeDirUnavailable, null,
&dir_path_ptr,
)) {
std.os.windows.S_OK => {
defer std.os.windows.ole32.CoTaskMemFree(@as(*anyopaque, @ptrCast(dir_path_ptr)));
const global_dir = std.unicode.utf16leToUtf8Alloc(allocator, std.mem.sliceTo(dir_path_ptr, 0)) catch |err| switch (err) {
error.UnexpectedSecondSurrogateHalf => return error.HomeDirUnavailable,
error.ExpectedSecondSurrogateHalf => return error.HomeDirUnavailable,
error.DanglingSurrogateHalf => return error.HomeDirUnavailable,
error.OutOfMemory => return error.OutOfMemory, error.OutOfMemory => return error.OutOfMemory,
}; };
return global_dir;
//defer allocator.free(local_app_data_dir); // defer allocator.free(global_dir);
//return std.fs.path.join(allocator, &[_][]const u8{ local_app_data_dir, appname }); },
return local_app_data_dir; std.os.windows.E_OUTOFMEMORY => return error.OutOfMemory,
else => return error.HomeDirUnavailable,
}
}, },
.macos, .linux, .freebsd, .netbsd, .dragonfly, .openbsd, .solaris => { .macos, .linux, .freebsd, .netbsd, .dragonfly, .openbsd, .solaris => {
const home_dir = std.os.getenv("HOME") orelse { const home_dir = std.os.getenv("HOME") orelse {

16
src/aws_http.zig
View File

@ -64,11 +64,11 @@ const EndPoint = struct {
}; };
pub const AwsHttp = struct { pub const AwsHttp = struct {
allocator: std.mem.Allocator, allocator: std.mem.Allocator,
proxy: ?std.http.Client.Proxy, proxy: ?std.http.Client.HttpProxy,
const Self = @This(); const Self = @This();
pub fn init(allocator: std.mem.Allocator, proxy: ?std.http.Client.Proxy) Self { pub fn init(allocator: std.mem.Allocator, proxy: ?std.http.Client.HttpProxy) Self {
return Self{ return Self{
.allocator = allocator, .allocator = allocator,
.proxy = proxy, .proxy = proxy,
@ -175,7 +175,7 @@ pub const AwsHttp = struct {
const url = try std.fmt.allocPrint(self.allocator, "{s}{s}{s}", .{ endpoint.uri, request_cp.path, request_cp.query }); const url = try std.fmt.allocPrint(self.allocator, "{s}{s}{s}", .{ endpoint.uri, request_cp.path, request_cp.query });
defer self.allocator.free(url); defer self.allocator.free(url);
log.debug("Request url: {s}", .{url}); log.debug("Request url: {s}", .{url});
var cl = std.http.Client{ .allocator = self.allocator, .http_proxy = self.proxy }; var cl = std.http.Client{ .allocator = self.allocator, .proxy = self.proxy };
defer cl.deinit(); // TODO: Connection pooling defer cl.deinit(); // TODO: Connection pooling
// //
// var req = try zfetch.Request.init(self.allocator, url, self.trust_chain); // var req = try zfetch.Request.init(self.allocator, url, self.trust_chain);
@ -209,11 +209,11 @@ pub const AwsHttp = struct {
// //
// const unescaped_url = try std.Uri.unescapeString(self.allocator, url); // const unescaped_url = try std.Uri.unescapeString(self.allocator, url);
// defer self.allocator.free(unescaped_url); // defer self.allocator.free(unescaped_url);
var req = try cl.open(method, try std.Uri.parse(url), headers, .{}); var req = try cl.request(method, try std.Uri.parse(url), headers, .{});
defer req.deinit(); defer req.deinit();
if (request_cp.body.len > 0) if (request_cp.body.len > 0)
req.transfer_encoding = .{ .content_length = request_cp.body.len }; req.transfer_encoding = .{ .content_length = request_cp.body.len };
try @import("http_client_17015_issue.zig").send(&req); try @import("http_client_17015_issue.zig").start(&req);
// try req.start(); // try req.start();
if (request_cp.body.len > 0) { if (request_cp.body.len > 0) {
// Workaround for https://github.com/ziglang/zig/issues/15626 // Workaround for https://github.com/ziglang/zig/issues/15626
@ -250,12 +250,12 @@ pub const AwsHttp = struct {
content_length = std.fmt.parseInt(usize, h.value, 10) catch 0; content_length = std.fmt.parseInt(usize, h.value, 10) catch 0;
} }
const response_data: []u8 = var response_data: []u8 =
if (req.response.transfer_encoding == .none) // the only value here is "chunked" if (req.response.transfer_encoding) |_| // the only value here is "chunked"
try req.reader().readAllAlloc(self.allocator, std.math.maxInt(usize)) try req.reader().readAllAlloc(self.allocator, std.math.maxInt(usize))
else blk: { else blk: {
// content length // content length
const tmp_data = try self.allocator.alloc(u8, content_length); var tmp_data = try self.allocator.alloc(u8, content_length);
errdefer self.allocator.free(tmp_data); errdefer self.allocator.free(tmp_data);
_ = try req.readAll(tmp_data); _ = try req.readAll(tmp_data);
break :blk tmp_data; break :blk tmp_data;

16
src/aws_signing.zig
View File

@ -177,7 +177,7 @@ pub fn signRequest(allocator: std.mem.Allocator, request: base.Request, config:
}; };
} }
errdefer freeSignedRequest(allocator, &rc, config); errdefer freeSignedRequest(allocator, &rc, config);
@memcpy(newheaders[0..oldheaders.len], oldheaders); std.mem.copy(base.Header, newheaders, oldheaders);
newheaders[newheaders.len - 3] = base.Header{ newheaders[newheaders.len - 3] = base.Header{
.name = "X-Amz-Date", .name = "X-Amz-Date",
.value = signing_iso8601, .value = signing_iso8601,
@ -364,7 +364,7 @@ fn verifyParsedAuthorization(
const service = credential_iterator.next().?; const service = credential_iterator.next().?;
const aws4_request = credential_iterator.next().?; const aws4_request = credential_iterator.next().?;
if (!std.mem.eql(u8, aws4_request, "aws4_request")) return error.UnexpectedCredentialValue; if (!std.mem.eql(u8, aws4_request, "aws4_request")) return error.UnexpectedCredentialValue;
const config = Config{ var config = Config{
.service = service, .service = service,
.credentials = credentials, .credentials = credentials,
.region = region, .region = region,
@ -444,7 +444,7 @@ fn getSigningKey(allocator: std.mem.Allocator, signing_date: []const u8, config:
\\ region: {s} \\ region: {s}
\\ service: {s} \\ service: {s}
, .{ signing_date, config.region, config.service }); , .{ signing_date, config.region, config.service });
const secret = try std.fmt.allocPrint(allocator, "AWS4{s}", .{config.credentials.secret_key}); var secret = try std.fmt.allocPrint(allocator, "AWS4{s}", .{config.credentials.secret_key});
defer { defer {
// secureZero avoids compiler optimizations that may say // secureZero avoids compiler optimizations that may say
// "WTF are you doing this thing? Looks like nothing to me. It's silly and we will remove it" // "WTF are you doing this thing? Looks like nothing to me. It's silly and we will remove it"
@ -716,7 +716,7 @@ fn canonicalQueryString(allocator: std.mem.Allocator, path: []const u8) ![]const
for (sort_me.items) |i| { for (sort_me.items) |i| {
if (!first) try normalized.append('&'); if (!first) try normalized.append('&');
first = false; first = false;
const first_equals = std.mem.indexOf(u8, i, "="); var first_equals = std.mem.indexOf(u8, i, "=");
if (first_equals == null) { if (first_equals == null) {
// Rare. This is "foo=" // Rare. This is "foo="
const normed_item = try encodeUri(allocator, i); const normed_item = try encodeUri(allocator, i);
@ -744,7 +744,7 @@ fn canonicalQueryString(allocator: std.mem.Allocator, path: []const u8) ![]const
} }
fn replace(allocator: std.mem.Allocator, haystack: []const u8, needle: []const u8, replacement_value: []const u8) ![]const u8 { fn replace(allocator: std.mem.Allocator, haystack: []const u8, needle: []const u8, replacement_value: []const u8) ![]const u8 {
const buffer = try allocator.alloc(u8, std.mem.replacementSize(u8, haystack, needle, replacement_value)); var buffer = try allocator.alloc(u8, std.mem.replacementSize(u8, haystack, needle, replacement_value));
_ = std.mem.replace(u8, haystack, needle, replacement_value, buffer); _ = std.mem.replace(u8, haystack, needle, replacement_value, buffer);
return buffer; return buffer;
} }
@ -837,7 +837,7 @@ fn canonicalHeaders(allocator: std.mem.Allocator, headers: []base.Header, servic
fn canonicalHeaderValue(allocator: std.mem.Allocator, value: []const u8) ![]const u8 { fn canonicalHeaderValue(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {
var started = false; var started = false;
const in_quote = false; var in_quote = false;
var start: usize = 0; var start: usize = 0;
const rc = try allocator.alloc(u8, value.len); const rc = try allocator.alloc(u8, value.len);
var rc_inx: usize = 0; var rc_inx: usize = 0;
@ -1002,7 +1002,7 @@ test "can sign" {
try headers.append(.{ .name = "Content-Type", .value = "application/x-www-form-urlencoded; charset=utf-8" }); try headers.append(.{ .name = "Content-Type", .value = "application/x-www-form-urlencoded; charset=utf-8" });
try headers.append(.{ .name = "Content-Length", .value = "13" }); try headers.append(.{ .name = "Content-Length", .value = "13" });
try headers.append(.{ .name = "Host", .value = "example.amazonaws.com" }); try headers.append(.{ .name = "Host", .value = "example.amazonaws.com" });
const req = base.Request{ var req = base.Request{
.path = "/", .path = "/",
.query = "", .query = "",
.body = "Param1=value1", .body = "Param1=value1",
@ -1071,7 +1071,7 @@ test "can verify server request" {
var buf = "bar".*; var buf = "bar".*;
var fis = std.io.fixedBufferStream(&buf); var fis = std.io.fixedBufferStream(&buf);
const request = std.http.Server.Request{ var request = std.http.Server.Request{
.method = std.http.Method.PUT, .method = std.http.Method.PUT,
.target = "/mysfitszj3t6webstack-hostingbucketa91a61fe-1ep3ezkgwpxr0/i/am/a/teapot/foo?x-id=PutObject", .target = "/mysfitszj3t6webstack-hostingbucketa91a61fe-1ep3ezkgwpxr0/i/am/a/teapot/foo?x-id=PutObject",
.version = .@"HTTP/1.1", .version = .@"HTTP/1.1",

16
src/date.zig
View File

@ -21,7 +21,7 @@ pub fn timestampToDateTime(timestamp: i64) DateTime {
const DAY_NUMBER_ADJUSTED_1970_01_01 = 719468; //* Day number relates to March 1st */ const DAY_NUMBER_ADJUSTED_1970_01_01 = 719468; //* Day number relates to March 1st */
var dayN: u64 = DAY_NUMBER_ADJUSTED_1970_01_01 + unixtime / SECONDS_PER_DAY; var dayN: u64 = DAY_NUMBER_ADJUSTED_1970_01_01 + unixtime / SECONDS_PER_DAY;
const seconds_since_midnight: u64 = unixtime % SECONDS_PER_DAY; var seconds_since_midnight: u64 = unixtime % SECONDS_PER_DAY;
var temp: u64 = 0; var temp: u64 = 0;
// Leap year rules for Gregorian Calendars // Leap year rules for Gregorian Calendars
@ -37,7 +37,7 @@ pub fn timestampToDateTime(timestamp: i64) DateTime {
// dayN calculates the days of the year in relation to March 1 // dayN calculates the days of the year in relation to March 1
var month = @as(u8, @intCast((5 * dayN + 2) / 153)); var month = @as(u8, @intCast((5 * dayN + 2) / 153));
const day = @as(u8, @intCast(dayN - (@as(u64, @intCast(month)) * 153 + 2) / 5 + 1)); var day = @as(u8, @intCast(dayN - (@as(u64, @intCast(month)) * 153 + 2) / 5 + 1));
// 153 = 31+30+31+30+31 Days for the 5 months from March through July // 153 = 31+30+31+30+31 Days for the 5 months from March through July
// 153 = 31+30+31+30+31 Days for the 5 months from August through December // 153 = 31+30+31+30+31 Days for the 5 months from August through December
// 31+28 Days for January and February (see below) // 31+28 Days for January and February (see below)
@ -50,9 +50,9 @@ pub fn timestampToDateTime(timestamp: i64) DateTime {
year += 1; year += 1;
} }
const hours = @as(u8, @intCast(seconds_since_midnight / 3600)); var hours = @as(u8, @intCast(seconds_since_midnight / 3600));
const minutes = @as(u8, @intCast(seconds_since_midnight % 3600 / 60)); var minutes = @as(u8, @intCast(seconds_since_midnight % 3600 / 60));
const seconds = @as(u8, @intCast(seconds_since_midnight % 60)); var seconds = @as(u8, @intCast(seconds_since_midnight % 60));
return DateTime{ .day = day, .month = month, .year = year, .hour = hours, .minute = minutes, .second = seconds }; return DateTime{ .day = day, .month = month, .year = year, .hour = hours, .minute = minutes, .second = seconds };
} }
@ -275,10 +275,10 @@ fn secondsBetween(start: DateTime, end: DateTime) DateTimeToTimestampError!i64 {
return (try secondsBetween(new_start, end)) - seconds_into_start_year; return (try secondsBetween(new_start, end)) - seconds_into_start_year;
} }
const leap_years_between = leapYearsBetween(start.year, end.year); const leap_years_between = leapYearsBetween(start.year, end.year);
const add_days: u1 = 0; var add_days: u1 = 0;
const years_diff = end.year - start.year; const years_diff = end.year - start.year;
// log.debug("Years from epoch: {d}, Leap years: {d}", .{ years_diff, leap_years_between }); // log.debug("Years from epoch: {d}, Leap years: {d}", .{ years_diff, leap_years_between });
const days_diff: i32 = (years_diff * DAYS_PER_YEAR) + leap_years_between + add_days; var days_diff: i32 = (years_diff * DAYS_PER_YEAR) + leap_years_between + add_days;
// log.debug("Days with leap year, without month: {d}", .{days_diff}); // log.debug("Days with leap year, without month: {d}", .{days_diff});
const seconds_into_year = secondsFromBeginningOfYear( const seconds_into_year = secondsFromBeginningOfYear(
@ -306,7 +306,7 @@ fn secondsFromBeginningOfYear(year: u16, month: u8, day: u8, hour: u8, minute: u
const normal_days_per_month: [12]u5 = .{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; const normal_days_per_month: [12]u5 = .{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
const days_per_month = if (current_year_is_leap_year) leap_year_days_per_month else normal_days_per_month; const days_per_month = if (current_year_is_leap_year) leap_year_days_per_month else normal_days_per_month;
var current_month: usize = 1; var current_month: usize = 1;
const end_month = month; var end_month = month;
var days_diff: u32 = 0; var days_diff: u32 = 0;
while (current_month != end_month) { while (current_month != end_month) {
days_diff += days_per_month[current_month - 1]; // months are 1-based vs array is 0-based days_diff += days_per_month[current_month - 1]; // months are 1-based vs array is 0-based

6
src/http_client_17015_issue.zig
View File

@ -10,8 +10,8 @@ const Uri = std.Uri;
/// only the two w.print lines for req.uri 16 and 18 lines down from this comment /// only the two w.print lines for req.uri 16 and 18 lines down from this comment
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
/// Send the request to the server. /// Send the request to the server.
pub fn send(req: *std.http.Client.Request) std.http.Client.Request.SendError!void { pub fn start(req: *std.http.Client.Request) std.http.Client.Request.StartError!void {
var buffered = std.io.bufferedWriter(req.connection.?.writer()); var buffered = std.io.bufferedWriter(req.connection.?.data.writer());
const w = buffered.writer(); const w = buffered.writer();
try w.writeAll(@tagName(req.method)); try w.writeAll(@tagName(req.method));
@ -21,7 +21,7 @@ pub fn send(req: *std.http.Client.Request) std.http.Client.Request.SendError!voi
try w.writeAll(req.uri.host.?); try w.writeAll(req.uri.host.?);
try w.writeByte(':'); try w.writeByte(':');
try w.print("{}", .{req.uri.port.?}); try w.print("{}", .{req.uri.port.?});
} else if (req.connection.?.proxied) { } else if (req.connection.?.data.proxied) {
// proxied connections require the full uri // proxied connections require the full uri
try format(req.uri, "+/", .{}, w); try format(req.uri, "+/", .{}, w);
} else { } else {

18
src/json.zig
View File

@ -1762,7 +1762,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options:
var r: T = undefined; var r: T = undefined;
const source_slice = stringToken.slice(tokens.slice, tokens.i - 1); const source_slice = stringToken.slice(tokens.slice, tokens.i - 1);
switch (stringToken.escapes) { switch (stringToken.escapes) {
.None => @memcpy(&r, source_slice), .None => mem.copy(u8, &r, source_slice),
.Some => try unescapeValidString(&r, source_slice), .Some => try unescapeValidString(&r, source_slice),
} }
return r; return r;
@ -2019,7 +2019,7 @@ test "parse into tagged union" {
} }
{ // failing allocations should be bubbled up instantly without trying next member { // failing allocations should be bubbled up instantly without trying next member
var fail_alloc = testing.FailingAllocator.init(testing.allocator, .{}); var fail_alloc = testing.FailingAllocator.init(testing.allocator, 0);
const options = ParseOptions{ .allocator = fail_alloc.allocator() }; const options = ParseOptions{ .allocator = fail_alloc.allocator() };
const T = union(enum) { const T = union(enum) {
// both fields here match the input // both fields here match the input
@ -2067,7 +2067,7 @@ test "parse union bubbles up AllocatorRequired" {
} }
test "parseFree descends into tagged union" { test "parseFree descends into tagged union" {
var fail_alloc = testing.FailingAllocator.init(testing.allocator, .{}); var fail_alloc = testing.FailingAllocator.init(testing.allocator, 1);
const options = ParseOptions{ .allocator = fail_alloc.allocator() }; const options = ParseOptions{ .allocator = fail_alloc.allocator() };
const T = union(enum) { const T = union(enum) {
int: i32, int: i32,
@ -2299,7 +2299,7 @@ pub const Parser = struct {
}, },
.ObjectValue => { .ObjectValue => {
var object = &p.stack.items[p.stack.items.len - 2].Object; var object = &p.stack.items[p.stack.items.len - 2].Object;
const key = p.stack.items[p.stack.items.len - 1].String; var key = p.stack.items[p.stack.items.len - 1].String;
switch (token) { switch (token) {
.ObjectBegin => { .ObjectBegin => {
@ -2827,14 +2827,14 @@ pub fn stringify(
} }
}, },
.Enum => { .Enum => {
if (comptime std.meta.hasFn(T, "jsonStringify")) { if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream); return value.jsonStringify(options, out_stream);
} }
@compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'"); @compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'");
}, },
.Union => { .Union => {
if (comptime std.meta.hasFn(T, "jsonStringify")) { if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream); return value.jsonStringify(options, out_stream);
} }
@ -2850,7 +2850,7 @@ pub fn stringify(
} }
}, },
.Struct => |S| { .Struct => |S| {
if (comptime std.meta.hasFn(T, "jsonStringify")) { if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
return value.jsonStringify(options, out_stream); return value.jsonStringify(options, out_stream);
} }
@ -2874,11 +2874,11 @@ pub fn stringify(
try child_whitespace.outputIndent(out_stream); try child_whitespace.outputIndent(out_stream);
} }
var field_written = false; var field_written = false;
if (comptime std.meta.hasFn(T, "jsonStringifyField")) if (comptime std.meta.trait.hasFn("jsonStringifyField")(T))
field_written = try value.jsonStringifyField(Field.name, child_options, out_stream); field_written = try value.jsonStringifyField(Field.name, child_options, out_stream);
if (!field_written) { if (!field_written) {
if (comptime std.meta.hasFn(T, "fieldNameFor")) { if (comptime std.meta.trait.hasFn("fieldNameFor")(T)) {
const name = value.fieldNameFor(Field.name); const name = value.fieldNameFor(Field.name);
try stringify(name, options, out_stream); try stringify(name, options, out_stream);
} else { } else {

11
src/main.zig
View File

@ -71,7 +71,7 @@ pub fn main() anyerror!void {
defer bw.flush() catch unreachable; defer bw.flush() catch unreachable;
const stdout = bw.writer(); const stdout = bw.writer();
var arg0: ?[]const u8 = null; var arg0: ?[]const u8 = null;
var proxy: ?std.http.Client.Proxy = null; var proxy: ?std.http.Client.HttpProxy = null;
while (args.next()) |arg| { while (args.next()) |arg| {
if (arg0 == null) arg0 = arg; if (arg0 == null) arg0 = arg;
if (std.mem.eql(u8, "-h", arg) or std.mem.eql(u8, "--help", arg)) { if (std.mem.eql(u8, "-h", arg) or std.mem.eql(u8, "--help", arg)) {
@ -87,7 +87,7 @@ pub fn main() anyerror!void {
return; return;
} }
if (std.mem.eql(u8, "-x", arg) or std.mem.eql(u8, "--proxy", arg)) { if (std.mem.eql(u8, "-x", arg) or std.mem.eql(u8, "--proxy", arg)) {
proxy = try proxyFromString(allocator, args.next().?); // parse stuff proxy = try proxyFromString(args.next().?); // parse stuff
continue; continue;
} }
if (std.mem.startsWith(u8, arg, "-v")) { if (std.mem.startsWith(u8, arg, "-v")) {
@ -353,13 +353,10 @@ pub fn main() anyerror!void {
std.log.info("===== Tests complete =====", .{}); std.log.info("===== Tests complete =====", .{});
} }
fn proxyFromString(allocator: std.mem.Allocator, string: []const u8) !std.http.Client.Proxy { fn proxyFromString(string: []const u8) !std.http.Client.HttpProxy {
var rc = std.http.Client.Proxy{ var rc = std.http.Client.HttpProxy{
.headers = std.http.Headers{ .allocator = allocator },
.allocator = allocator,
.protocol = undefined, .protocol = undefined,
.host = undefined, .host = undefined,
.port = undefined,
}; };
var remaining: []const u8 = string; var remaining: []const u8 = string;
if (std.mem.startsWith(u8, string, "http://")) { if (std.mem.startsWith(u8, string, "http://")) {

2
src/xml.zig
View File

@ -260,7 +260,7 @@ const ParseContext = struct {
begin = prev_nl + 1; begin = prev_nl + 1;
} }
const end = mem.indexOfScalarPos(u8, self.source, self.offset, '\n') orelse self.source.len; var end = mem.indexOfScalarPos(u8, self.source, self.offset, '\n') orelse self.source.len;
return self.source[begin..end]; return self.source[begin..end];
} }
}; };

4
src/xml_shaper.zig
View File

@ -214,9 +214,9 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions)
log.debug("Processing fields in struct: {s}", .{@typeName(T)}); log.debug("Processing fields in struct: {s}", .{@typeName(T)});
inline for (struct_info.fields, 0..) |field, i| { inline for (struct_info.fields, 0..) |field, i| {
var name: []const u8 = field.name; var name = field.name;
var found_value = false; var found_value = false;
if (comptime std.meta.hasFn(T, "fieldNameFor")) if (comptime std.meta.trait.hasFn("fieldNameFor")(T))
name = r.fieldNameFor(field.name); name = r.fieldNameFor(field.name);
log.debug("Field name: {s}, Element: {s}, Adjusted field name: {s}", .{ field.name, element.tag, name }); log.debug("Field name: {s}, Element: {s}, Adjusted field name: {s}", .{ field.name, element.tag, name });
var iterator = element.findChildrenByTag(name); var iterator = element.findChildrenByTag(name);