Allow non-numeric index names

Author: lalinsky

src/MultiIndex.zig

@@ -15,7 +15,24 @@ pub const IndexRef = struct {
 lock: std.Thread.Mutex = .{},
 allocator: std.mem.Allocator,
 dir: std.fs.Dir,
-indexes: std.AutoHashMap(u8, IndexRef),
+indexes: std.StringHashMap(IndexRef),
+
+fn isValidName(name: []const u8) bool {
+    for (name, 0) |c, i| {
+        if (i == 0) {
+            switch (c) {
+                '0'...'9', 'A'...'Z', 'a'...'z' => {},
+                else => return false,
+            }
+        } else {
+            switch (c) {
+                '0'...'9', 'A'...'Z', 'a'...'z', '_', '-' => {},
+                else => return false,
+            }
+        }
+    }
+    return true;
+}
 
 const max_sub_dir_name_size = 10;
 const sub_dir_name_fmt = "{x:0>2}";
@@ -24,7 +41,7 @@ pub fn init(allocator: std.mem.Allocator, dir: std.fs.Dir) Self {
     return .{
         .allocator = allocator,
         .dir = dir,
-        .indexes = std.AutoHashMap(u8, IndexRef).init(allocator),
+        .indexes = std.StringHashMap(IndexRef).init(allocator),
     };
 }
 
@@ -45,11 +62,15 @@ pub fn releaseIndex(self: *Self, index_data: *IndexRef) void {
     index_data.last_used_at = std.time.timestamp();
 }
 
-pub fn acquireIndex(self: *Self, id: u8, create: bool) !*IndexRef {
+pub fn acquireIndex(self: *Self, name: []const u8, create: bool) !*IndexRef {
+    if (!isValidName(name)) {
+        return error.InvalidIndexName;
+    }
+
     self.lock.lock();
     defer self.lock.unlock();
 
-    var result = try self.indexes.getOrPut(id);
+    var result = try self.indexes.getOrPutAdapted(name, self.indexes.ctx);
     if (result.found_existing) {
         result.value_ptr.references += 1;
         result.value_ptr.last_used_at = std.time.timestamp();
@@ -58,10 +79,10 @@ pub fn acquireIndex(self: *Self, id: u8, create: bool) !*IndexRef {
 
     errdefer self.indexes.removeByPtr(result.key_ptr);
 
-    var sub_dir_name_buf: [max_sub_dir_name_size]u8 = undefined;
-    const sub_dir_name = try std.fmt.bufPrint(&sub_dir_name_buf, sub_dir_name_fmt, .{id});
+    result.key_ptr.* = try self.allocator.dupe(u8, name);
+    errdefer self.allocator.free(result.key_ptr.*);
 
-    result.value_ptr.index = try Index.init(self.allocator, self.dir, sub_dir_name, .{ .create = create });
+    result.value_ptr.index = try Index.init(self.allocator, self.dir, name, .{ .create = create });
     errdefer result.value_ptr.index.deinit();
 
     try result.value_ptr.index.open();
@@ -71,26 +92,36 @@ pub fn acquireIndex(self: *Self, id: u8, create: bool) !*IndexRef {
     return result.value_ptr;
 }
 
-pub fn getIndex(self: *Self, id: u8) !*IndexRef {
-    return try self.acquireIndex(id, false);
+pub fn getIndex(self: *Self, name: []const u8) !*IndexRef {
+    if (!isValidName(name)) {
+        return error.InvalidIndexName;
+    }
+
+    return try self.acquireIndex(name, false);
 }
 
-pub fn createIndex(self: *Self, id: u8) !void {
-    const index_ref = try self.acquireIndex(id, true);
+pub fn createIndex(self: *Self, name: []const u8) !void {
+    if (!isValidName(name)) {
+        return error.InvalidIndexName;
+    }
+
+    const index_ref = try self.acquireIndex(name, true);
     defer self.releaseIndex(index_ref);
 }
 
-pub fn deleteIndex(self: *Self, id: u8) !void {
+pub fn deleteIndex(self: *Self, name: []const u8) !void {
+    if (!isValidName(name)) {
+        return error.InvalidIndexName;
+    }
+
     self.lock.lock();
     defer self.lock.unlock();
 
-    if (self.indexes.getEntry(id)) |entry| {
+    if (self.indexes.getEntry(name)) |entry| {
+        self.allocator.free(entry.key_ptr.*);
         entry.value_ptr.index.deinit();
         self.indexes.removeByPtr(entry.key_ptr);
     }
 
-    var sub_dir_name_buf: [max_sub_dir_name_size]u8 = undefined;
-    const sub_dir_name = try std.fmt.bufPrint(&sub_dir_name_buf, sub_dir_name_fmt, .{id});
-
-    try self.dir.deleteTree(sub_dir_name);
+    try self.dir.deleteTree(name);
 }

src/server.zig

@@ -103,22 +103,9 @@ const SearchResultsJSON = struct {
     results: []SearchResultJSON,
 };
 
-fn getIndexNo(ctx: *Context, req: *httpz.Request, res: *httpz.Response, send_body: bool) !?u8 {
-    _ = ctx;
-    const index_no_str = req.param("index") orelse "0";
-    const index_no = std.fmt.parseInt(u8, index_no_str, 10) catch {
-        res.status = 400;
-        if (send_body) {
-            try res.json(.{ .status = "invalid index number" }, .{});
-        }
-        return null;
-    };
-    return index_no;
-}
-
 fn getIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response, send_body: bool) !?*IndexData {
-    const index_no = try getIndexNo(ctx, req, res, send_body) orelse return null;
-    const index = ctx.indexes.getIndex(index_no) catch |err| {
+    const index_name = req.param("index") orelse return null;
+    const index = ctx.indexes.getIndex(index_name) catch |err| {
         if (err == error.IndexNotFound) {
             res.status = 404;
             if (send_body) {
@@ -230,9 +217,9 @@ fn handleGetIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !voi
 }
 
 fn handlePutIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !void {
-    const index_no = try getIndexNo(ctx, req, res, true) orelse return;
+    const index_name = req.param("index") orelse return;
 
-    ctx.indexes.createIndex(index_no) catch |err| {
+    ctx.indexes.createIndex(index_name) catch |err| {
         log.err("index create error: {}", .{err});
         res.status = 500;
         return res.json(.{ .status = "internal error" }, .{});
@@ -242,9 +229,9 @@ fn handlePutIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !voi
 }
 
 fn handleDeleteIndex(ctx: *Context, req: *httpz.Request, res: *httpz.Response) !void {
-    const index_no = try getIndexNo(ctx, req, res, true) orelse return;
+    const index_name = req.param("index") orelse return;
 
-    ctx.indexes.deleteIndex(index_no) catch |err| {
+    ctx.indexes.deleteIndex(index_name) catch |err| {
         log.err("index delete error: {}", .{err});
         res.status = 500;
         return res.json(.{ .status = "internal error" }, .{});