Rename index file to manifest file

Author: lalinsky

src/Index.zig

@@ -155,10 +155,10 @@ fn loadSegments(self: *Self) !u64 {
     self.segments_lock.lock();
     defer self.segments_lock.unlock();
 
-    const segment_ids = filefmt.readIndexFile(self.dir, self.allocator) catch |err| {
+    const segment_ids = filefmt.readManifestFile(self.dir, self.allocator) catch |err| {
         if (err == error.FileNotFound) {
             if (self.options.create) {
-                try self.updateIndexFile(self.file_segments.segments.value);
+                try self.updateManifestFile(self.file_segments.segments.value);
                 return 0;
             }
             return error.IndexNotFound;
@@ -212,7 +212,7 @@ fn doCheckpoint(self: *Self) !bool {
 
     file_segments_update.appendSegment(target);
 
-    try self.updateIndexFile(file_segments_update.segments.value);
+    try self.updateManifestFile(file_segments_update.segments.value);
 
     // commit updated lists
 
@@ -259,18 +259,18 @@ fn stopCheckpointThread(self: *Self) void {
     self.checkpoint_thread = null;
 }
 
-fn updateIndexFile(self: *Self, segments: *FileSegmentList) !void {
-    var ids = try segments.getInfos(self.allocator);
-    defer ids.deinit(self.allocator);
+fn updateManifestFile(self: *Self, segments: *FileSegmentList) !void {
+    const infos = try segments.getInfos(self.allocator);
+    defer self.allocator.free(infos);
 
-    try filefmt.writeIndexFile(self.dir, ids.items);
+    try filefmt.writeManifestFile(self.dir, infos);
 }
 
 fn maybeMergeFileSegments(self: *Self) !bool {
     var upd = try self.file_segments.prepareMerge(self.allocator) orelse return false;
     defer self.file_segments.cleanupAfterUpdate(self.allocator, &upd);
 
-    try self.updateIndexFile(upd.segments.value);
+    try self.updateManifestFile(upd.segments.value);
 
     self.segments_lock.lock();
     defer self.segments_lock.unlock();

src/filefmt.zig

@@ -92,7 +92,7 @@ test "check writeVarint32" {
 
 pub const max_file_name_size = 64;
 const segment_file_name_fmt = "{x:0>16}-{x:0>8}.data";
-pub const index_file_name = "index.dat";
+pub const manifest_file_name = "manifest";
 
 pub fn buildSegmentFileName(buf: []u8, info: SegmentInfo) []u8 {
     assert(buf.len == max_file_name_size);
@@ -487,26 +487,26 @@ test "writeFile/readFile" {
     }
 }
 
-const index_header_magic_v1: u32 = 0x49445831; // "IDX1" in big endian
+const manifest_header_magic_v1: u32 = 0x49445831; // "IDX1" in big endian
 
-const IndexFileHeader = struct {
-    magic: u32 = index_header_magic_v1,
+const ManifestFileHeader = struct {
+    magic: u32 = manifest_header_magic_v1,
 
     pub fn msgpackFormat() msgpack.StructFormat {
         return .{ .as_map = .{ .key = .field_index } };
     }
 };
 
-pub fn writeIndexFile(dir: std.fs.Dir, segments: []const SegmentInfo) !void {
-    log.info("writing index file {s}", .{index_file_name});
+pub fn writeManifestFile(dir: std.fs.Dir, segments: []const SegmentInfo) !void {
+    log.info("writing manifest file {s}", .{manifest_file_name});
 
-    var file = try dir.atomicFile(index_file_name, .{});
+    var file = try dir.atomicFile(manifest_file_name, .{});
     defer file.deinit();
 
     var buffered_writer = std.io.bufferedWriter(file.file.writer());
     const writer = buffered_writer.writer();
 
-    try msgpack.encode(IndexFileHeader{}, writer);
+    try msgpack.encode(ManifestFileHeader{}, writer);
     try msgpack.encode(segments, writer);
 
     try buffered_writer.flush();
@@ -516,23 +516,23 @@ pub fn writeIndexFile(dir: std.fs.Dir, segments: []const SegmentInfo) !void {
     try file.finish();
 
     log.info("wrote index file {s} (segments = {})", .{
-        index_file_name,
+        manifest_file_name,
         segments.len,
     });
 }
 
-pub fn readIndexFile(dir: std.fs.Dir, allocator: std.mem.Allocator) ![]SegmentInfo {
-    log.info("reading index file {s}", .{index_file_name});
+pub fn readManifestFile(dir: std.fs.Dir, allocator: std.mem.Allocator) ![]SegmentInfo {
+    log.info("reading manifest file {s}", .{manifest_file_name});
 
-    var file = try dir.openFile(index_file_name, .{});
+    var file = try dir.openFile(manifest_file_name, .{});
     defer file.close();
 
     var buffered_reader = std.io.bufferedReader(file.reader());
     const reader = buffered_reader.reader();
 
-    const header = try msgpack.decodeLeaky(IndexFileHeader, null, reader);
-    if (header.magic != index_header_magic_v1) {
-        return error.InvalidIndexfile;
+    const header = try msgpack.decodeLeaky(ManifestFileHeader, null, reader);
+    if (header.magic != manifest_header_magic_v1) {
+        return error.InvalidManifestFile;
     }
 
     return try msgpack.decodeLeaky([]SegmentInfo, allocator, reader);
@@ -548,9 +548,9 @@ test "readIndexFile/writeIndexFile" {
         .{ .version = 4, .merges = 0 },
     };
 
-    try writeIndexFile(tmp.dir, &segments);
+    try writeManifestFile(tmp.dir, &segments);
 
-    const segments2 = try readIndexFile(tmp.dir, std.testing.allocator);
+    const segments2 = try readManifestFile(tmp.dir, std.testing.allocator);
     defer std.testing.allocator.free(segments2);
 
     try testing.expectEqualSlices(SegmentInfo, &segments, segments2);

src/segment_list.zig

@@ -100,12 +100,12 @@ pub fn SegmentList(Segment: type) type {
             }
         }
 
-        pub fn getInfos(self: Self, allocator: Allocator) Allocator.Error!std.ArrayListUnmanaged(SegmentInfo) {
-            var ids = try std.ArrayListUnmanaged(SegmentInfo).initCapacity(allocator, self.nodes.items.len);
-            for (self.nodes.items) |node| {
-                ids.appendAssumeCapacity(node.value.info);
+        pub fn getInfos(self: Self, allocator: Allocator) Allocator.Error![]SegmentInfo {
+            var infos = try allocator.alloc(SegmentInfo, self.nodes.items.len);
+            for (self.nodes.items, 0..) |node, i| {
+                infos[i] = node.value.info;
             }
-            return ids;
+            return infos;
         }
 
         pub fn search(self: Self, hashes: []const u32, results: *SearchResults, deadline: Deadline) !void {