updates for zig 0.13

Author: Steve🔆

.gitignore

@@ -1,3 +1,3 @@
 .DS_Store
-zig-cache
+.zig-cache
 zig-out

build.zig

@@ -10,7 +10,7 @@ pub fn build(b: *std.Build) void {
 
     const exe = b.addExecutable(.{
         .name = "zig-zag-zoe",
-        .root_source_file = .{ .path = "src/main.zig" },
+        .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
     });
@@ -27,7 +27,7 @@ pub fn build(b: *std.Build) void {
     run_step.dependOn(&run_cmd.step);
 
     const unit_tests = b.addTest(.{
-        .root_source_file = .{ .path = "src/main.zig" },
+        .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
     });

build.zig.zon

@@ -1,18 +1,17 @@
 .{
     .name = "zig-zag-zoe",
-    .version = "0.1.0",
+    .version = "0.1.13",
     .paths = .{""},
 
     .dependencies = .{
         .httpz = .{
-             .url = "git+https://github.com/zigster64/http.zig#master",
-             .hash = "1220a06b79fe8996ccfab3017f535f0ebc4976055e5b753fdfb2d8b0830aeb2d9a32",
-            // .url = "git+https://github.com/karseguin/http.zig#blocking",
-            // .hash = "1220b9cb100296f9ecbea1d5d335a074884e978c2f4fa9781cdeec47e2d222119b65",
+             // .url = "git+https://github.com/zigster64/http.zig#master",
+             .url = "git+https://github.com/karlseguin/http.zig#master",
+             .hash = "12206d8d2a7f2535a7d48872eaf43911ead71ba05456f97363ae25e4f057a985975f",
         },
         .zts = .{
             .url = "git+https://github.com/zigster64/zts#main",
-            .hash = "1220864472b1642b73155481ac7fe274c891816bd182a8853f378d0aefd42ef44c33",
+            .hash = "122097f35c2d1aa158464a2c6e30f76ca09f747596881cba3f86627195135dcbe70e",
         },
     },
 }

src/game.zig

@@ -70,7 +70,7 @@ pub fn init(grid_x: u8, grid_y: u8, players: u8, needed_to_win: u8, zero_wing: u
 
     // seed the RNG
     var os_seed: u64 = undefined;
-    try std.os.getrandom(std.mem.asBytes(&os_seed));
+    try std.posix.getrandom(std.mem.asBytes(&os_seed));
 
     var s = Self{
         .board = try Board.init(grid_x, grid_y),
@@ -170,7 +170,7 @@ pub fn logExtra(self: *Self, req: *httpz.Request, extra: []const u8) void {
     // do some memory logging and stats here
     self.game_mutex.lock();
     const player = self.getPlayer(req);
-    const ru = std.os.getrusage(0);
+    const ru = std.posix.getrusage(0);
     std.log.info("[{}:{s}:{}:{}:{}] {s} {s} {s}", .{ std.time.timestamp(), @tagName(self.state), player, ru.maxrss, ru.maxrss - self.last_rss, @tagName(req.method), req.url.raw, extra });
     self.last_rss = ru.maxrss;
     self.game_mutex.unlock();
@@ -180,7 +180,7 @@ pub fn log(self: *Self, req: *httpz.Request, elapsedUs: i128) void {
     // do some memory logging and stats here
     self.game_mutex.lock();
     const player = self.getPlayer(req);
-    const ru = std.os.getrusage(0);
+    const ru = std.posix.getrusage(0);
     std.log.info("[{}:{s}:{}:{}:{}] {s} {s} ({}µs)", .{ std.time.timestamp(), @tagName(self.state), player, ru.maxrss, ru.maxrss - self.last_rss, @tagName(req.method), req.url.raw, elapsedUs });
     self.game_mutex.unlock();
     self.last_rss = ru.maxrss;
@@ -685,12 +685,16 @@ fn events(self: *Self, req: *httpz.Request, res: *httpz.Response) !void {
     }
 
     res.disown();
-    const stream = try res.startEventStream();
-    const thread = try std.Thread.spawn(.{}, eventsLoop, .{ self, stream });
-    thread.detach();
+    try res.startEventStream(self, eventsLoopWrapper);
 }
 
-fn eventsLoop(self: *Self, stream: anytype) !void {
+fn eventsLoopWrapper(self: *Self, stream: std.net.Stream) void {
+    eventsLoop(self, stream) catch |err| {
+        std.log.err("eventsLoopWrapper: {}", .{err});
+    };
+}
+
+fn eventsLoop(self: *Self, stream: std.net.Stream) !void {
     // on initial connect, send the clock details, and send the last event processed
     try self.clock(stream);
     try stream.writer().print("event: update\ndata: {s}\n\n", .{@tagName(self.last_event)});

src/main.zig

@@ -6,19 +6,19 @@ const default_port = 3000;
 
 // always log .info, even in release modes
 // change this to .debug if you want extreme debugging
-pub const std_options = struct {
-    pub const log_level = .info;
+pub const std_options = std.Options{
+    .log_level = .info,
 };
 
 pub fn usage() void {
     std.debug.print("USAGE: zig-zag-zoe [-p PORTNUMBER]\n", .{});
-    std.debug.print("       or use the PORT env var to set the port, for like Docker or whatever\n", .{});
+    std.debug.print("       or use the PORT env var to set the port\n", .{});
 }
 
 pub fn main() !void {
     var port: u16 = default_port;
 
-    const env_port = std.os.getenv("PORT");
+    const env_port = std.posix.getenv("PORT");
     if (env_port != null and env_port.?.len > 0) {
         port = try std.fmt.parseInt(u16, env_port.?, 10);
         std.log.debug("Port set to {} via ENV\n", .{port});
@@ -60,31 +60,12 @@ pub fn main() !void {
     const zero_wing: u8 = 0;
 
     var game = try Game.init(grid_x, grid_y, players, win, zero_wing);
-    try game.startWatcher();
+    // try game.startWatcher();
 
-    std.log.debug("Setting pool size to {}", .{Game.MAX_PLAYERS * 4});
+    // std.log.debug("Setting pool size to {}", .{Game.MAX_PLAYERS * 4});
     var server = try httpz.ServerCtx(*Game, *Game).init(allocator, .{
         .address = "0.0.0.0",
         .port = port,
-        // .pool_size = Game.MAX_PLAYERS * 32, // allow up to 32 req/res pairs buffered for each player
-        // .pool = .{
-        //     .min = Game.MAX_PLAYERS * 4,
-        //     .max = Game.MAX_PLAYERS * 24,
-        //     .timeout = 5000,
-        // },
-        // .thread_pool = Game.MAX_PLAYERS * 2,
-        .request = .{
-            .max_body_size = 256,
-            .buffer_size = 1024,
-            .max_header_count = 32,
-            .max_param_count = 2,
-            .max_query_count = 1,
-        },
-        .response = .{
-            .body_buffer_size = 48_000, // big enough for the biggest file
-            .header_buffer_size = 256,
-            .max_header_count = 8,
-        },
     }, &game);
     server.notFound(notFound);
     server.errorHandler(errorHandler);
@@ -103,7 +84,7 @@ pub fn main() !void {
     // connect the game object to the router
     game.addRoutes(router);
 
-    const ru = std.os.getrusage(0);
+    const ru = std.posix.getrusage(0);
     std.log.info("[{}:{s}:{}:{}:{}] {s} {s}", .{ std.time.timestamp(), @tagName(game.state), 0, ru.maxrss, ru.maxrss, "BOOT", "Initial Startup" });
     return server.listen();
 }
@@ -113,8 +94,8 @@ fn printValidAddresses(allocator: std.mem.Allocator, port: u16) !void {
 
     // do some digging to get a list of IPv4 addresses that we are listening on
     std.log.info("- http://localhost:{}", .{port});
-    var hostBuffer: [std.os.HOST_NAME_MAX]u8 = undefined;
-    const hostname = try std.os.gethostname(&hostBuffer);
+    var hostBuffer: [std.posix.HOST_NAME_MAX]u8 = undefined;
+    const hostname = try std.posix.gethostname(&hostBuffer);
     std.log.info("- http://{s}:{}", .{ hostname, port });
 
     var addressList = try std.net.getAddressList(allocator, hostname, port);
@@ -124,7 +105,7 @@ fn printValidAddresses(allocator: std.mem.Allocator, port: u16) !void {
     defer uniqueIPv4Addresses.deinit();
 
     for (addressList.addrs) |address| {
-        if (address.any.family == std.os.AF.INET) {
+        if (address.any.family == std.posix.AF.INET) {
             try uniqueIPv4Addresses.put(address.in, true);
         }
     }