Upgrade to Zig 0.14

Author: lalinsky

build.zig.zon

@@ -1,23 +1,24 @@
 .{
-    .name = "fpindex",
+    .name = .fpindex,
     .version = "2.0.0",
-    .minimum_zig_version = "0.13.0",
+    .minimum_zig_version = "0.14.0",
+    .fingerprint = 0x38793b7ca08220b7,
     .dependencies = .{
         .httpz = .{
-            .url = "git+https://github.com/karlseguin/http.zig?ref=zig-0.13#7d2ddae87af9b110783085c0ea6b03985faa4584",
-            .hash = "12208c1f2c5f730c4c03aabeb0632ade7e21914af03e6510311b449458198d0835d6",
+            .url = "git+https://github.com/karlseguin/http.zig?ref=master#56258131ef4505543fef5484451867c13c5ff322",
+            .hash = "httpz-0.0.0-PNVzrJSuBgDFvO7mtd2qDzaq8_hXIu1BqFuL1jwAV8Ac",
         },
         .zul = .{
-            .url = "git+https://github.com/karlseguin/zul.git#df74463d223810a720f37db9dac3b160efbb9d4b",
-            .hash = "122012992f8502acdcb69ae0f35682850b5c57abe892b1c717bc6dba65d05653fa76",
+            .url = "git+https://github.com/karlseguin/zul.git?ref=master#d9142c73aedc5698beba58b3fbf2bcfe69864778",
+            .hash = "zul-0.0.0-1oDot0BCBwA9cUo5OOrPs5NGmvoM7sk1ztfbdfL7mh4P",
         },
         .metrics = .{
-            .url = "git+https://github.com/karlseguin/metrics.zig?ref=zig-0.13#fcf9e94fa54a20f4954e9821801c32e44d407a2f",
-            .hash = "12201776681f1e5ec6df7df30786e90771c5de564c941a309c73c4299c7864ddb4c3",
+            .url = "git+https://github.com/karlseguin/metrics.zig?ref=master#cf2797bcb3aea7e5cdaf4de39c5550c70796e7b1",
+            .hash = "122061f30077ef518dd435d397598ab3c45daa3d2c25e6b45383fb94d0bd2c3af1af",
         },
         .msgpack = .{
-            .url = "git+https://github.com/lalinsky/msgpack.zig?ref=v0.1.0#d141ef4e1f585fecbbcdac9a9f85e41b5759182c",
-            .hash = "1220cb5fbd418638a830cb3c8a47d95d766d5ec1904631a14cde18cad89047165404",
+            .url = "git+https://github.com/lalinsky/msgpack.zig?ref=v0.2.0#964ed489cf663fd3d7b79fe328300a71d3ab12d5",
+            .hash = "msgpack-0.1.0-ZOu9PHimAQCfeM27BhUPC1NY6ZXjMlL2_ZEkjWRDldrT",
         },
     },
     .paths = .{

src/FileSegment.zig

@@ -36,7 +36,7 @@ num_items: usize = 0,
 delete_in_deinit: bool = false,
 
 mmaped_file: ?std.fs.File = null,
-mmaped_data: ?[]align(std.mem.page_size) u8 = null,
+mmaped_data: ?[]align(std.heap.page_size_min) u8 = null,
 
 pub fn init(allocator: std.mem.Allocator, options: Options) Self {
     return Self{
@@ -72,6 +72,10 @@ pub fn getBlockData(self: Self, block: usize) []const u8 {
     return self.blocks[block * self.block_size .. (block + 1) * self.block_size];
 }
 
+fn compareHashes(a: u32, b: u32) std.math.Order {
+    return std.math.order(a, b);
+}
+
 pub fn search(self: Self, sorted_hashes: []const u32, results: *SearchResults, deadline: Deadline) !void {
     var prev_block_no: usize = std.math.maxInt(usize);
     var prev_block_range_start: usize = 0;
@@ -89,7 +93,7 @@ pub fn search(self: Self, sorted_hashes: []const u32, results: *SearchResults, d
     // We want to find hash=10, lowerBound returns block=3 (EOF), but block=2 could still contain hash=6, so we go one back.
 
     for (sorted_hashes, 1..) |hash, i| {
-        var block_no = std.sort.lowerBound(u32, hash, self.index.items[prev_block_range_start..], {}, std.sort.asc(u32)) + prev_block_range_start;
+        var block_no = std.sort.lowerBound(u32, self.index.items[prev_block_range_start..], hash, compareHashes) + prev_block_range_start;
         if (block_no > 0) {
             block_no -= 1;
         }
@@ -103,7 +107,7 @@ pub fn search(self: Self, sorted_hashes: []const u32, results: *SearchResults, d
                 const block_data = self.getBlockData(block_no);
                 try filefmt.readBlock(block_data, &block_items, self.min_doc_id);
             }
-            const matches = std.sort.equalRange(Item, Item{ .hash = hash, .id = 0 }, block_items.items, {}, Item.cmpByHash);
+            const matches = std.sort.equalRange(Item, block_items.items, Item{ .hash = hash, .id = 0 }, Item.orderByHash);
             for (matches[0]..matches[1]) |j| {
                 try results.incr(block_items.items[j].id, self.info.version);
             }

src/MemorySegment.zig

@@ -49,7 +49,7 @@ pub fn deinit(self: *Self, delete_file: KeepOrDelete) void {
 pub fn search(self: Self, sorted_hashes: []const u32, results: *SearchResults, deadline: Deadline) !void {
     var items = self.items.items;
     for (sorted_hashes) |hash| {
-        const matches = std.sort.equalRange(Item, Item{ .hash = hash, .id = 0 }, items, {}, Item.cmpByHash);
+        const matches = std.sort.equalRange(Item, items, Item{ .hash = hash, .id = 0 }, Item.orderByHash);
         for (matches[0]..matches[1]) |i| {
             try results.incr(items[i].id, self.info.version);
         }
@@ -131,7 +131,7 @@ pub fn build(self: *Self, changes: []const Change) !void {
         }
     }
 
-    std.sort.pdq(Item, self.items.items, {}, Item.cmp);
+    std.sort.pdq(Item, self.items.items, {}, Item.lessThan);
 }
 
 pub fn cleanup(self: *Self) void {

src/Oplog.zig

@@ -12,9 +12,13 @@ const Self = @This();
 pub const FileInfo = struct {
     id: u64 = 0,
 
-    fn cmp(_: void, a: FileInfo, b: FileInfo) bool {
+    fn lessThan(_: void, a: FileInfo, b: FileInfo) bool {
         return a.id < b.id;
     }
+
+    fn order(a: FileInfo, b: FileInfo) std.math.Order {
+        return std.math.order(a.id, b.id);
+    }
 };
 
 allocator: std.mem.Allocator,
@@ -70,7 +74,7 @@ pub fn open(self: *Self, first_commit_id: u64, receiver: anytype, ctx: anytype)
         }
     }
 
-    std.sort.pdq(FileInfo, self.files.items, {}, FileInfo.cmp);
+    std.sort.pdq(FileInfo, self.files.items, {}, FileInfo.lessThan);
 
     try self.truncateNoLock(first_commit_id);
 
@@ -177,9 +181,9 @@ fn getFile(self: *Self, commit_id: u64) !std.fs.File {
 }
 
 fn truncateNoLock(self: *Self, commit_id: u64) !void {
-    assert(std.sort.isSorted(FileInfo, self.files.items, {}, FileInfo.cmp));
+    assert(std.sort.isSorted(FileInfo, self.files.items, {}, FileInfo.lessThan));
 
-    var pos = std.sort.lowerBound(FileInfo, FileInfo{ .id = commit_id }, self.files.items, {}, FileInfo.cmp);
+    var pos = std.sort.lowerBound(FileInfo, self.files.items, FileInfo{ .id = commit_id }, FileInfo.order);
     if (pos > 0) {
         pos -= 1;
     }

src/filefmt.zig

@@ -327,7 +327,7 @@ pub fn writeSegmentFile(dir: std.fs.Dir, reader: anytype) !void {
         .has_attributes = true,
         .has_docs = true,
     };
-    try packer.write(SegmentFileHeader, header);
+    try packer.write(header);
 
     try packer.writeMap(segment.attributes);
     try packer.writeMap(segment.docs);
@@ -359,7 +359,7 @@ pub fn writeSegmentFile(dir: std.fs.Dir, reader: anytype) !void {
         .num_blocks = num_blocks,
         .checksum = crc.final(),
     };
-    try packer.write(SegmentFileFooter, footer);
+    try packer.write(footer);
 
     try buffered_writer.flush();
 

src/main.zig

@@ -8,7 +8,7 @@ const MultiIndex = @import("MultiIndex.zig");
 const server = @import("server.zig");
 const metrics = @import("metrics.zig");
 
-pub const std_options = .{
+pub const std_options = std.Options{
     .log_level = .debug,
     .logFn = logHandler,
 };

src/segment.zig

@@ -54,14 +54,20 @@ pub const Item = packed struct(u64) {
     id: u32,
     hash: u32,
 
-    pub fn cmp(_: void, a: Item, b: Item) bool {
+    pub fn lessThan(_: void, a: Item, b: Item) bool {
         const xa: u64 = @bitCast(a);
         const xb: u64 = @bitCast(b);
         return xa < xb;
     }
 
-    pub fn cmpByHash(_: void, a: Item, b: Item) bool {
-        return a.hash < b.hash;
+    pub fn order(a: Item, b: Item) std.math.Order {
+        const xa: u64 = @bitCast(a);
+        const xb: u64 = @bitCast(b);
+        return std.math.order(xa, xb);
+    }
+
+    pub fn orderByHash(a: Item, b: Item) std.math.Order {
+        return std.math.order(a.hash, b.hash);
     }
 };
 

src/segment_merger.zig

@@ -155,7 +155,7 @@ pub fn SegmentMerger(comptime Segment: type) type {
 
                 for (self.sources.items, 0..) |*source, i| {
                     if (try source.read()) |item| {
-                        if (min_item == null or Item.cmp({}, item, min_item.?)) {
+                        if (min_item == null or Item.order(item, min_item.?) == .lt) {
                             min_item = item;
                             min_item_index = i;
                         }

src/server.zig

@@ -16,9 +16,17 @@ const metrics = @import("metrics.zig");
 
 const Context = struct {
     indexes: *MultiIndex,
+
+    pub fn notFound(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !void {
+        return handleNotFound(ctx, req, res);
+    }
+
+    pub fn uncaughtError(ctx: *Context, req: *httpz.Request, res: *httpz.Response, err: anyerror) void {
+        return handleError(ctx, req, res, err);
+    }
 };
 
-const Server = httpz.ServerApp(*Context);
+const Server = httpz.Server(*Context);
 
 var global_server: ?*Server = null;
 
@@ -30,16 +38,16 @@ fn shutdown(_: c_int) callconv(.C) void {
     }
 }
 
-fn installSignalHandlers(server: *Server) !void {
+fn installSignalHandlers(server: *Server) void {
     global_server = server;
 
-    try std.posix.sigaction(std.posix.SIG.INT, &.{
+    std.posix.sigaction(std.posix.SIG.INT, &.{
         .handler = .{ .handler = shutdown },
         .mask = std.posix.empty_sigset,
         .flags = 0,
     }, null);
 
-    try std.posix.sigaction(std.posix.SIG.TERM, &.{
+    std.posix.sigaction(std.posix.SIG.TERM, &.{
         .handler = .{ .handler = shutdown },
         .mask = std.posix.empty_sigset,
         .flags = 0,
@@ -67,35 +75,32 @@ pub fn run(allocator: std.mem.Allocator, indexes: *MultiIndex, address: []const
     var server = try Server.init(allocator, config, &ctx);
     defer server.deinit();
 
-    server.errorHandler(handleError);
-    server.notFound(handleNotFound);
-
-    try installSignalHandlers(&server);
+    installSignalHandlers(&server);
 
-    var router = server.router();
+    var router = try server.router(.{});
 
     // Monitoring API
-    router.get("/_metrics", handleMetrics);
-    router.get("/_health", handleHealth);
-    router.get("/:index/_health", handleIndexHealth);
+    router.get("/_metrics", handleMetrics, .{});
+    router.get("/_health", handleHealth, .{});
+    router.get("/:index/_health", handleIndexHealth, .{});
 
     // Search API
-    router.post("/:index/_search", handleSearch);
+    router.post("/:index/_search", handleSearch, .{});
 
     // Bulk API
-    router.post("/:index/_update", handleUpdate);
+    router.post("/:index/_update", handleUpdate, .{});
 
     // Fingerprint API
-    router.head("/:index/:id", handleHeadFingerprint);
-    router.get("/:index/:id", handleGetFingerprint);
-    router.put("/:index/:id", handlePutFingerprint);
-    router.delete("/:index/:id", handleDeleteFingerprint);
+    router.head("/:index/:id", handleHeadFingerprint, .{});
+    router.get("/:index/:id", handleGetFingerprint, .{});
+    router.put("/:index/:id", handlePutFingerprint, .{});
+    router.delete("/:index/:id", handleDeleteFingerprint, .{});
 
     // Index API
-    router.head("/:index", handleHeadIndex);
-    router.get("/:index", handleGetIndex);
-    router.put("/:index", handlePutIndex);
-    router.delete("/:index", handleDeleteIndex);
+    router.head("/:index", handleHeadIndex, .{});
+    router.get("/:index", handleGetIndex, .{});
+    router.put("/:index", handlePutIndex, .{});
+    router.delete("/:index", handleDeleteIndex, .{});
 
     log.info("listening on {s}:{d}", .{ address, port });
     try server.listen();
@@ -453,8 +458,8 @@ const Attributes = struct {
         try packer.writeMapHeader(self.attributes.count());
         var iter = self.attributes.iterator();
         while (iter.next()) |entry| {
-            try packer.write(@TypeOf(entry.key_ptr.*), entry.key_ptr.*);
-            try packer.write(@TypeOf(entry.value_ptr.*), entry.value_ptr.*);
+            try packer.write(entry.key_ptr.*);
+            try packer.write(entry.value_ptr.*);
         }
     }
 };

src/utils/shared_ptr.zig

@@ -24,7 +24,7 @@ pub fn RefCounter(comptime T: type) type {
         pub fn decr(self: *Self) bool {
             const prev_ref_count = self.refs.fetchSub(1, .monotonic);
             if (prev_ref_count == 1) {
-                self.refs.fence(.acquire);
+                _ = self.refs.load(.acquire);
                 return true;
             }
             return false;