upgrade to zig 0.12

Author: krichprollsch

src/async/Client.zig

@@ -31,7 +31,7 @@ pub const Stream = struct {
     handle: posix.socket_t,
 
     pub fn close(self: Stream) void {
-        posix.closeSocket(self.handle);
+        posix.close(self.handle);
         self.alloc.destroy(self.conn);
     }
 

src/async/stream.zig

@@ -98,7 +98,7 @@ pub fn tcpConnectToHost(alloc: std.mem.Allocator, loop: *Loop, name: []const u8,
 
 pub fn tcpConnectToAddress(alloc: std.mem.Allocator, loop: *Loop, addr: net.Address) !Stream {
     const sockfd = try std.posix.socket(addr.any.family, std.posix.SOCK.STREAM, std.posix.IPPROTO.TCP);
-    errdefer std.posix.closeSocket(sockfd);
+    errdefer std.posix.close(sockfd);
 
     var conn = try alloc.create(Conn);
     conn.* = Conn{ .loop = loop };

src/async/tcp.zig

@@ -40,11 +40,9 @@ test "blocking mode fetch API" {
     // force client's CA cert scan from system.
     try client.ca_bundle.rescan(client.allocator);
 
-    var res = try client.fetch(alloc, .{
+    const res = try client.fetch(.{
         .location = .{ .uri = try std.Uri.parse(url) },
-        .payload = .none,
     });
-    defer res.deinit();
 
     try std.testing.expect(res.status == .ok);
 }
@@ -64,10 +62,10 @@ test "blocking mode open/send/wait API" {
     // force client's CA cert scan from system.
     try client.ca_bundle.rescan(client.allocator);
 
-    var headers = try std.http.Headers.initList(alloc, &[_]std.http.Field{});
-    defer headers.deinit();
-
-    var req = try client.open(.GET, try std.Uri.parse(url), headers, .{});
+    var buf: [2014]u8 = undefined;
+    var req = try client.open(.GET, try std.Uri.parse(url), .{
+        .server_header_buffer = &buf,
+    });
     defer req.deinit();
 
     try req.send(.{});
@@ -87,17 +85,17 @@ const AsyncClient = struct {
 
         cli: *Client,
         uri: std.Uri,
-        headers: std.http.Headers,
 
         req: ?Request = undefined,
         state: State = .new,
 
         impl: YieldImpl,
         err: ?anyerror = null,
 
+        buf: [2014]u8 = undefined,
+
         pub fn deinit(self: *AsyncRequest) void {
             if (self.req) |*r| r.deinit();
-            self.headers.deinit();
         }
 
         pub fn fetch(self: *AsyncRequest) void {
@@ -116,7 +114,9 @@ const AsyncClient = struct {
             switch (self.state) {
                 .new => {
                     self.state = .open;
-                    self.req = self.cli.open(.GET, self.uri, self.headers, .{}) catch |e| return self.onerr(e);
+                    self.req = self.cli.open(.GET, self.uri, .{
+                        .server_header_buffer = &self.buf,
+                    }) catch |e| return self.onerr(e);
                 },
                 .open => {
                     self.state = .send;
@@ -164,7 +164,6 @@ const AsyncClient = struct {
             .impl = YieldImpl.init(self.cli.loop),
             .cli = &self.cli,
             .uri = uri,
-            .headers = .{ .allocator = self.cli.allocator, .owned = false },
         };
     }
 };

src/async/test.zig

@@ -247,29 +247,39 @@ pub const Page = struct {
 
         // TODO handle redirection
         if (req.response.status != .ok) {
-            log.debug("{?} {d} {s}\n{any}", .{
+            log.debug("{?} {d} {s}", .{
                 req.response.version,
                 req.response.status,
                 req.response.reason,
-                req.response.headers,
+                // TODO log headers
             });
             return error.BadStatusCode;
         }
 
         // TODO handle charset
         // https://html.spec.whatwg.org/#content-type
-        const ct = req.response.headers.getFirstValue("Content-Type") orelse {
+        var it = req.response.iterateHeaders();
+        var ct: ?[]const u8 = null;
+        while (true) {
+            const h = it.next() orelse break;
+            if (std.ascii.eqlIgnoreCase(h.name, "Content-Type")) {
+                ct = try alloc.dupe(u8, h.value);
+            }
+        }
+        if (ct == null) {
             // no content type in HTTP headers.
             // TODO try to sniff mime type from the body.
             log.info("no content-type HTTP header", .{});
             return;
-        };
-        log.debug("header content-type: {s}", .{ct});
-        const mime = try Mime.parse(ct);
+        }
+        defer alloc.free(ct.?);
+
+        log.debug("header content-type: {s}", .{ct.?});
+        const mime = try Mime.parse(ct.?);
         if (mime.eql(Mime.HTML)) {
             try self.loadHTMLDoc(req.reader(), mime.charset orelse "utf-8");
         } else {
-            log.info("non-HTML document: {s}", .{ct});
+            log.info("non-HTML document: {s}", .{ct.?});
 
             // save the body into the page.
             self.raw_data = try req.reader().readAllAlloc(alloc, 16 * 1024 * 1024);
@@ -500,20 +510,24 @@ pub const Page = struct {
 
         log.debug("starting fetch script {s}", .{src});
 
-        const u = std.Uri.parse(src) catch try std.Uri.parseWithoutScheme(src);
-        const ru = try std.Uri.resolve(self.uri, u, false, alloc);
+        var buffer: [1024]u8 = undefined;
+        const u = try std.Uri.resolve_inplace(self.uri, src, &buffer);
 
-        var fetchres = try self.session.loader.fetch(alloc, ru);
+        var fetchres = try self.session.loader.get(alloc, u);
         defer fetchres.deinit();
 
-        log.info("fech script {any}: {d}", .{ ru, fetchres.status });
+        const resp = fetchres.req.response;
+
+        log.info("fech script {any}: {d}", .{ u, resp.status });
 
-        if (fetchres.status != .ok) return FetchError.BadStatusCode;
+        if (resp.status != .ok) return FetchError.BadStatusCode;
 
         // TODO check content-type
+        const body = try fetchres.req.reader().readAllAlloc(alloc, 16 * 1024 * 1024);
+        defer alloc.free(body);
 
         // check no body
-        if (fetchres.body == null) return FetchError.NoBody;
+        if (body.len == 0) return FetchError.NoBody;
 
         var res = try self.session.env.execTryCatch(alloc, fetchres.body.?, src);
         defer res.deinit(alloc);

src/browser/browser.zig

@@ -22,6 +22,7 @@ const user_agent = "Lightpanda.io/1.0";
 
 pub const Loader = struct {
     client: std.http.Client,
+    server_header_buffer: [1024]u8 = undefined,
 
     pub const Response = struct {
         alloc: std.mem.Allocator,
@@ -45,42 +46,26 @@ pub const Loader = struct {
         self.client.deinit();
     }
 
-    // the caller must deinit the FetchResult.
-    pub fn fetch(self: *Loader, alloc: std.mem.Allocator, uri: std.Uri) !std.http.Client.FetchResult {
-        var headers = try std.http.Headers.initList(alloc, &[_]std.http.Field{
-            .{ .name = "User-Agent", .value = user_agent },
-            .{ .name = "Accept", .value = "*/*" },
-            .{ .name = "Accept-Language", .value = "en-US,en;q=0.5" },
-        });
-        defer headers.deinit();
-
-        return try self.client.fetch(alloc, .{
-            .location = .{ .uri = uri },
-            .headers = headers,
-            .payload = .none,
-        });
-    }
-
     // see
     // https://ziglang.org/documentation/master/std/#A;std:http.Client.fetch
     // for reference.
     // The caller is responsible for calling `deinit()` on the `Response`.
     pub fn get(self: *Loader, alloc: std.mem.Allocator, uri: std.Uri) !Response {
-        var headers = try std.http.Headers.initList(alloc, &[_]std.http.Field{
-            .{ .name = "User-Agent", .value = user_agent },
-            .{ .name = "Accept", .value = "*/*" },
-            .{ .name = "Accept-Language", .value = "en-US,en;q=0.5" },
-        });
-        defer headers.deinit();
-
         var resp = Response{
             .alloc = alloc,
             .req = try alloc.create(std.http.Client.Request),
         };
         errdefer alloc.destroy(resp.req);
 
-        resp.req.* = try self.client.open(.GET, uri, headers, .{
-            .handle_redirects = true, // TODO handle redirects manually
+        resp.req.* = try self.client.open(.GET, uri, .{
+            .headers = .{
+                .user_agent = .{ .override = user_agent },
+            },
+            .extra_headers = &.{
+                .{ .name = "Accept", .value = "*/*" },
+                .{ .name = "Accept-Language", .value = "en-US,en;q=0.5" },
+            },
+            .server_header_buffer = &self.server_header_buffer,
         });
         errdefer resp.req.deinit();
 
@@ -92,13 +77,13 @@ pub const Loader = struct {
     }
 };
 
-test "basic url fetch" {
+test "basic url get" {
     const alloc = std.testing.allocator;
     var loader = Loader.init(alloc);
     defer loader.deinit();
 
-    var result = try loader.fetch(alloc, "https://en.wikipedia.org/wiki/Main_Page");
+    var result = try loader.get(alloc, "https://en.wikipedia.org/wiki/Main_Page");
     defer result.deinit();
 
-    try std.testing.expect(result.status == std.http.Status.ok);
+    try std.testing.expect(result.req.response.status == std.http.Status.ok);
 }

src/browser/loader.zig

@@ -25,8 +25,8 @@ const apiweb = @import("apiweb.zig");
 pub const Types = jsruntime.reflect(apiweb.Interfaces);
 pub const UserContext = apiweb.UserContext;
 
-pub const std_options = struct {
-    pub const log_level = .debug;
+pub const std_options = std.Options{
+    .log_level = .debug,
 };
 
 const usage =