Add attributes to GET /index

Author: lalinsky

src/Index.zig

@@ -446,6 +446,11 @@ fn releaseSegments(self: *Self, segments: *SegmentsSnapshot) void {
     FileSegmentList.destroySegments(self.allocator, &segments.file_segments);
 }
 
+const segment_lists = [_][]const u8{
+    "file_segments",
+    "memory_segments",
+};
+
 pub fn search(self: *Self, hashes: []const u32, allocator: std.mem.Allocator, deadline: Deadline) !SearchResults {
     const sorted_hashes = try allocator.dupe(u32, hashes);
     defer allocator.free(sorted_hashes);
@@ -457,14 +462,39 @@ pub fn search(self: *Self, hashes: []const u32, allocator: std.mem.Allocator, de
     var snapshot = self.acquireSegments();
     defer self.releaseSegments(&snapshot); // FIXME this possibly deletes orphaned segments, do it in a separate thread
 
-    try snapshot.file_segments.value.search(sorted_hashes, &results, deadline);
-    try snapshot.memory_segments.value.search(sorted_hashes, &results, deadline);
+    inline for (segment_lists) |n| {
+        const segments = @field(snapshot, n);
+        try segments.value.search(sorted_hashes, &results, deadline);
+    }
 
     results.sort();
 
     return results;
 }
 
+pub fn getAttributes(self: *Self, allocator: std.mem.Allocator) !std.AutoHashMapUnmanaged(u64, u64) {
+    var result: std.AutoHashMapUnmanaged(u64, u64) = .{};
+    errdefer result.deinit(allocator);
+
+    var snapshot = self.acquireSegments();
+    defer self.releaseSegments(&snapshot); // FIXME this possibly deletes orphaned segments, do it in a separate thread
+
+    var last_version: u64 = 0;
+    inline for (segment_lists) |n| {
+        const segments = @field(snapshot, n);
+        for (segments.value.nodes.items) |node| {
+            var iter = node.value.attributes.iterator();
+            while (iter.next()) |entry| {
+                try result.put(allocator, entry.key_ptr.*, entry.value_ptr.*);
+            }
+            std.debug.assert(node.value.info.version > last_version);
+            last_version = node.value.info.version;
+        }
+    }
+
+    return result;
+}
+
 test {
     _ = @import("index_tests.zig");
 }

src/server.zig

@@ -270,16 +270,35 @@ fn handleHeadIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !vo
     return;
 }
 
+const Attributes = struct {
+    attributes: std.AutoHashMapUnmanaged(u64, u64),
+
+    pub fn jsonStringify(self: Attributes, jws: anytype) !void {
+        try jws.beginArray();
+        var iter = self.attributes.iterator();
+        while (iter.next()) |entry| {
+            try jws.beginArray();
+            try jws.write(entry.key_ptr.*);
+            try jws.write(entry.value_ptr.*);
+            try jws.endArray();
+        }
+        try jws.endArray();
+    }
+};
+
 const GetIndexResponse = struct {
     status: []const u8,
+    attributes: Attributes,
 };
 
 fn handleGetIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !void {
     const index_ref = try getIndex(ctx, req, res, true) orelse return;
     defer releaseIndex(ctx, index_ref);
 
+    const attributes = try index_ref.index.getAttributes(req.arena);
     const response = GetIndexResponse{
         .status = "ok",
+        .attributes = .{ .attributes = attributes },
     };
     return res.json(&response, .{});
 }