Something went wrong. Try again.
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions ant.themackabu.dev
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678const std = @import("std");
const c = @cImport({ @cInclude("lmdb.h");});
extern fn strip_npm_metadata(json_data: [*]const u8, json_len: usize, out_len: *usize) ?[*]u8;extern fn strip_metadata_free(ptr: [*]u8) void;
pub const CacheEntry = struct { integrity: [64]u8, path: []const u8, unpacked_size: u64, file_count: u32, cached_at: i64, allocator: ?std.mem.Allocator = null,
pub fn deinit(self: *CacheEntry) void { if (self.allocator) |alloc| alloc.free(self.path); }};
const SerializedEntry = extern struct { unpacked_size: u64, file_count: u32, cached_at: i64, path_len: u32,};
fn check(rc: c_int) !void { if (rc != 0) return error.MdbError;}
pub const CacheDB = struct { env: *c.MDB_env, dbi_primary: c.MDB_dbi, dbi_secondary: c.MDB_dbi, dbi_metadata: c.MDB_dbi, cache_dir: []const u8, allocator: std.mem.Allocator,
const MAP_SIZE: usize = 8 * 1024 * 1024 * 1024; const METADATA_TTL_SECS: i64 = 24 * 60 * 60;
pub fn open(cache_dir: []const u8) !*CacheDB { const allocator = std.heap.c_allocator;
std.fs.cwd().makePath(cache_dir) catch |err| switch (err) { error.PathAlreadyExists => {}, else => return error.CacheError, };
const packages_path = try std.fmt.allocPrintSentinel(allocator, "{s}/cache", .{cache_dir}, 0); defer allocator.free(packages_path); std.fs.cwd().makePath(packages_path) catch |err| switch (err) { error.PathAlreadyExists => {}, else => return error.CacheError, };
var env: ?*c.MDB_env = null; if (c.mdb_env_create(&env) != 0) { return error.DatabaseOpen; } errdefer c.mdb_env_close(env);
try check(c.mdb_env_set_mapsize(env, MAP_SIZE)); try check(c.mdb_env_set_maxdbs(env, 3));
const db_path = try std.fmt.allocPrintSentinel(allocator, "{s}/index.lmdb", .{cache_dir}, 0); defer allocator.free(db_path);
const flags: c_uint = c.MDB_NOSUBDIR | c.MDB_NOSYNC; if (c.mdb_env_open(env, db_path.ptr, flags, 0o644) != 0) { return error.DatabaseOpen; }
const self = try allocator.create(CacheDB); errdefer allocator.destroy(self);
self.* = .{ .env = env.?, .dbi_primary = 0, .dbi_secondary = 0, .dbi_metadata = 0, .cache_dir = try allocator.dupe(u8, cache_dir), .allocator = allocator, };
try self.openDatabases(); self.autoPruneMetadata();
return self; }
fn autoPruneMetadata(self: *CacheDB) void { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) return; self.pruneExpiredMetadata(txn.?); _ = c.mdb_txn_commit(txn); }
fn openDatabases(self: *CacheDB) !void { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.DatabaseOpen; } errdefer c.mdb_txn_abort(txn);
if (c.mdb_dbi_open(txn, "primary", c.MDB_CREATE, &self.dbi_primary) != 0) return error.DatabaseOpen; if (c.mdb_dbi_open(txn, "secondary", c.MDB_CREATE, &self.dbi_secondary) != 0) return error.DatabaseOpen; if (c.mdb_dbi_open(txn, "metadata", c.MDB_CREATE, &self.dbi_metadata) != 0) return error.DatabaseOpen; if (c.mdb_txn_commit(txn) != 0) return error.DatabaseOpen; }
pub fn close(self: *CacheDB) void { c.mdb_dbi_close(self.env, self.dbi_primary); c.mdb_dbi_close(self.env, self.dbi_secondary); c.mdb_dbi_close(self.env, self.dbi_metadata); c.mdb_env_close(self.env); self.allocator.free(self.cache_dir); self.allocator.destroy(self); }
fn makeIntegrityKey(integrity: *const [64]u8) [66]u8 { var key: [66]u8 = undefined; key[0] = 'i'; key[1] = ':'; @memcpy(key[2..66], integrity); return key; }
fn makeNameKey(allocator: std.mem.Allocator, name: []const u8, version: []const u8) ![]u8 { return std.fmt.allocPrint(allocator, "n:{s}@{s}", .{ name, version }); }
pub fn lookup(self: *CacheDB, integrity: *const [64]u8) ?CacheEntry { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return null; } defer c.mdb_txn_abort(txn);
const key_bytes = makeIntegrityKey(integrity); var key = c.MDB_val{ .mv_size = key_bytes.len, .mv_data = @constCast(&key_bytes), }; var value: c.MDB_val = undefined;
if (c.mdb_get(txn, self.dbi_primary, &key, &value) != 0) return null; return deserializeEntry(integrity, value, self.allocator); }
pub fn hasIntegrity(self: *CacheDB, integrity: *const [64]u8) bool { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return false; } defer c.mdb_txn_abort(txn);
const key_bytes = makeIntegrityKey(integrity); var key = c.MDB_val{ .mv_size = key_bytes.len, .mv_data = @constCast(&key_bytes), }; var value: c.MDB_val = undefined;
return c.mdb_get(txn, self.dbi_primary, &key, &value) == 0; }
fn deserializeEntry(integrity: *const [64]u8, value: c.MDB_val, allocator: std.mem.Allocator) ?CacheEntry { if (value.mv_size < @sizeOf(SerializedEntry)) return null;
const data: [*]const u8 = @ptrCast(value.mv_data);
var header: SerializedEntry = undefined; @memcpy(std.mem.asBytes(&header), data[0..@sizeOf(SerializedEntry)]);
const path_start = @sizeOf(SerializedEntry); if (value.mv_size < path_start + header.path_len) return null;
const path = allocator.dupe(u8, data[path_start..][0..header.path_len]) catch return null;
return CacheEntry{ .integrity = integrity.*, .path = path, .unpacked_size = header.unpacked_size, .file_count = header.file_count, .cached_at = header.cached_at, .allocator = allocator, }; }
pub fn lookupByName(self: *CacheDB, name: []const u8, version: []const u8) ?CacheEntry { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return null; } defer c.mdb_txn_abort(txn);
const name_key = makeNameKey(self.allocator, name, version) catch return null; defer self.allocator.free(name_key);
var key = c.MDB_val{ .mv_size = name_key.len, .mv_data = @constCast(name_key.ptr), }; var value: c.MDB_val = undefined;
if (c.mdb_get(txn, self.dbi_secondary, &key, &value) != 0) return null; if (value.mv_size != 64) return null;
const integrity: *const [64]u8 = @ptrCast(value.mv_data); return self.lookup(integrity); }
pub const BatchHit = struct { index: u32, file_count: u32, };
pub fn batchLookup( self: *CacheDB, integrities: []const [64]u8, allocator: std.mem.Allocator, ) !struct { items: []BatchHit, allocator: std.mem.Allocator, pub fn deinit(s: *@This()) void { s.allocator.free(s.items); } } { var hits = std.ArrayListUnmanaged(BatchHit){}; errdefer hits.deinit(allocator);
var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return .{ .items = &.{}, .allocator = allocator }; } defer c.mdb_txn_abort(txn);
for (integrities, 0..) |integrity, i| { const key_bytes = makeIntegrityKey(&integrity); var key = c.MDB_val{ .mv_size = key_bytes.len, .mv_data = @constCast(&key_bytes), }; var value: c.MDB_val = undefined; if (c.mdb_get(txn, self.dbi_primary, &key, &value) == 0) { var file_count: u32 = 0; if (value.mv_size >= @sizeOf(SerializedEntry)) { const data: [*]const u8 = @ptrCast(value.mv_data); var header: SerializedEntry = undefined; @memcpy(std.mem.asBytes(&header), data[0..@sizeOf(SerializedEntry)]); file_count = header.file_count; } try hits.append(allocator, .{ .index = @intCast(i), .file_count = file_count }); } }
return .{ .items = hits.toOwnedSlice(allocator) catch &.{}, .allocator = allocator }; }
pub fn insert(self: *CacheDB, entry: *const CacheEntry, name: ?[]const u8, version: ?[]const u8) !void { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.InsertError; } errdefer c.mdb_txn_abort(txn);
try self.insertInTxn(txn.?, entry, name, version); if (c.mdb_txn_commit(txn) != 0) return error.InsertError; }
fn insertInTxn(self: *CacheDB, txn: *c.MDB_txn, entry: *const CacheEntry, name: ?[]const u8, version: ?[]const u8) !void { const value_size = @sizeOf(SerializedEntry) + entry.path.len; const value_buf = try self.allocator.alloc(u8, value_size); defer self.allocator.free(value_buf);
const header: *SerializedEntry = @ptrCast(@alignCast(value_buf.ptr)); header.* = .{ .unpacked_size = entry.unpacked_size, .file_count = entry.file_count, .cached_at = entry.cached_at, .path_len = @intCast(entry.path.len), }; @memcpy(value_buf[@sizeOf(SerializedEntry)..], entry.path); const key_bytes = makeIntegrityKey(&entry.integrity); var key = c.MDB_val{ .mv_size = key_bytes.len, .mv_data = @constCast(&key_bytes), }; var value = c.MDB_val{ .mv_size = value_size, .mv_data = value_buf.ptr, };
if (c.mdb_put(txn, self.dbi_primary, &key, &value, 0) != 0) { return error.InsertError; }
if (name != null and version != null) { const name_key = try makeNameKey(self.allocator, name.?, version.?); defer self.allocator.free(name_key);
var sec_key = c.MDB_val{ .mv_size = name_key.len, .mv_data = @constCast(name_key.ptr), }; var sec_value = c.MDB_val{ .mv_size = 64, .mv_data = @constCast(&entry.integrity), };
if (c.mdb_put(txn, self.dbi_secondary, &sec_key, &sec_value, 0) != 0) { return error.InsertError; } } }
pub fn batchInsert(self: *CacheDB, entries: []const CacheEntry) !void { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.InsertError; } errdefer c.mdb_txn_abort(txn);
for (entries) |*entry| { try self.insertInTxn(txn.?, entry, null, null); } if (c.mdb_txn_commit(txn) != 0) return error.InsertError; }
pub const NamedCacheEntry = struct { entry: CacheEntry, name: []const u8, version: []const u8, };
pub fn batchInsertNamed(self: *CacheDB, entries: []const NamedCacheEntry) !void { if (entries.len == 0) return;
var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.InsertError; } errdefer c.mdb_txn_abort(txn);
for (entries) |item| { self.insertInTxn(txn.?, &item.entry, item.name, item.version) catch continue; } if (c.mdb_txn_commit(txn) != 0) return error.InsertError; }
pub fn delete(self: *CacheDB, integrity: *const [64]u8) !void { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.DeleteError; } errdefer c.mdb_txn_abort(txn);
const key_bytes = makeIntegrityKey(integrity); var key = c.MDB_val{ .mv_size = key_bytes.len, .mv_data = @constCast(&key_bytes), };
_ = c.mdb_del(txn, self.dbi_primary, &key, null); if (c.mdb_txn_commit(txn) != 0) return error.DeleteError; }
pub fn getPackagePath(self: *CacheDB, integrity: *const [64]u8, allocator: std.mem.Allocator) ![]u8 { const hex = std.fmt.bytesToHex(integrity.*, .lower); return std.fmt.allocPrint(allocator, "{s}/cache/{s}", .{ self.cache_dir, hex }); }
pub fn sync(self: *CacheDB) void { _ = c.mdb_env_sync(self.env, 1); }
pub fn stats(self: *CacheDB) !struct { entries: usize, db_size: usize, cache_size: usize } { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return error.DatabaseError; } defer c.mdb_txn_abort(txn);
var db_stat: c.MDB_stat = undefined; _ = c.mdb_stat(txn, self.dbi_primary, &db_stat);
var env_info: c.MDB_envinfo = undefined; _ = c.mdb_env_info(self.env, &env_info);
const db_size = self.getDbFileSize(); const cache_size = self.calculateCacheSize();
return .{ .entries = db_stat.ms_entries, .db_size = db_size, .cache_size = cache_size, }; }
const BLOCK_SIZE: usize = 4096;
inline fn alignToBlock(size: u64) usize { const s: usize = @intCast(size); return ((s + BLOCK_SIZE - 1) / BLOCK_SIZE) * BLOCK_SIZE; }
fn getDbFileSize(self: *CacheDB) usize { const db_path = std.fmt.allocPrint(self.allocator, "{s}/index.lmdb", .{self.cache_dir}) catch return 0; defer self.allocator.free(db_path);
const stat = std.fs.cwd().statFile(db_path) catch return 0; return alignToBlock(stat.size); }
fn calculateCacheSize(self: *CacheDB) usize { const cache_path = std.fmt.allocPrint(self.allocator, "{s}/cache", .{self.cache_dir}) catch return 0; defer self.allocator.free(cache_path);
var total: usize = 0; var dir = std.fs.cwd().openDir(cache_path, .{ .iterate = true }) catch return 0; defer dir.close();
var iter = dir.iterate(); while (iter.next() catch null) |entry| { if (entry.kind == .directory) { total += self.getDirSize(dir, entry.name); } else if (entry.kind == .file) { const stat = dir.statFile(entry.name) catch continue; total += alignToBlock(stat.size); } } return total; }
fn getDirSize(self: *CacheDB, parent: std.fs.Dir, name: []const u8) usize { var subdir = parent.openDir(name, .{ .iterate = true }) catch return 0; defer subdir.close();
var total: usize = 0; var iter = subdir.iterate(); while (iter.next() catch null) |entry| { if (entry.kind == .directory) { total += self.getDirSize(subdir, entry.name); } else if (entry.kind == .file) { const stat = subdir.statFile(entry.name) catch continue; total += alignToBlock(stat.size); } } return total; }
fn makeMetadataKey(allocator: std.mem.Allocator, name: []const u8) ![]u8 { return std.fmt.allocPrint(allocator, "m:{s}", .{name}); }
pub fn lookupMetadata(self: *CacheDB, name: []const u8, allocator: std.mem.Allocator) ?[]u8 { var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, c.MDB_RDONLY, &txn) != 0) { return null; } defer c.mdb_txn_abort(txn);
const meta_key = makeMetadataKey(self.allocator, name) catch return null; defer self.allocator.free(meta_key);
var key = c.MDB_val{ .mv_size = meta_key.len, .mv_data = @constCast(meta_key.ptr), }; var value: c.MDB_val = undefined;
if (c.mdb_get(txn, self.dbi_metadata, &key, &value) != 0) return null; if (value.mv_size < @sizeOf(i64)) return null;
const data: [*]const u8 = @ptrCast(value.mv_data); var cached_at: i64 = undefined; @memcpy(std.mem.asBytes(&cached_at), data[0..@sizeOf(i64)]);
const now = std.time.timestamp(); if (now - cached_at > METADATA_TTL_SECS) return null;
const json_data = data[@sizeOf(i64)..value.mv_size]; return allocator.dupe(u8, json_data) catch null; }
pub fn insertMetadata(self: *CacheDB, name: []const u8, json_data: []const u8) !void { var stripped_len: usize = 0; const stripped_ptr = strip_npm_metadata(json_data.ptr, json_data.len, &stripped_len); defer if (stripped_ptr) |p| strip_metadata_free(p);
const data_to_store = if (stripped_ptr) |p| p[0..stripped_len] else json_data;
var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) { return error.InsertError; } errdefer c.mdb_txn_abort(txn);
const meta_key = try makeMetadataKey(self.allocator, name); defer self.allocator.free(meta_key);
const value_size = @sizeOf(i64) + data_to_store.len; const value_buf = try self.allocator.alloc(u8, value_size); defer self.allocator.free(value_buf);
const now: i64 = std.time.timestamp(); @memcpy(value_buf[0..@sizeOf(i64)], std.mem.asBytes(&now)); @memcpy(value_buf[@sizeOf(i64)..], data_to_store);
var key = c.MDB_val{ .mv_size = meta_key.len, .mv_data = @constCast(meta_key.ptr), }; var value = c.MDB_val{ .mv_size = value_size, .mv_data = value_buf.ptr, };
if (c.mdb_put(txn, self.dbi_metadata, &key, &value, 0) != 0) return error.InsertError; if (c.mdb_txn_commit(txn) != 0) return error.InsertError; }
const PruneCollections = struct { keys: std.ArrayListUnmanaged([66]u8) = .{}, paths: std.ArrayListUnmanaged([]const u8) = .{}, fn deinit(self: *PruneCollections, allocator: std.mem.Allocator) void { for (self.paths.items) |p| allocator.free(p); self.paths.deinit(allocator); self.keys.deinit(allocator); } };
inline fn collectExpiredEntries( self: *CacheDB, txn: *c.MDB_txn, cutoff: i64, collections: *PruneCollections, ) !void { var cursor: ?*c.MDB_cursor = null; if (c.mdb_cursor_open(txn, self.dbi_primary, &cursor) != 0) return error.DatabaseError; defer c.mdb_cursor_close(cursor);
var key: c.MDB_val = undefined; var value: c.MDB_val = undefined; var rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_FIRST);
while (rc == 0) : (rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_NEXT)) { if (value.mv_size < @sizeOf(SerializedEntry)) continue;
const data: [*]const u8 = @ptrCast(value.mv_data); var header: SerializedEntry = undefined; @memcpy(std.mem.asBytes(&header), data[0..@sizeOf(SerializedEntry)]);
if (header.cached_at >= cutoff) continue; if (key.mv_size != 66) continue;
const key_data: [*]const u8 = @ptrCast(key.mv_data); var key_copy: [66]u8 = undefined; @memcpy(&key_copy, key_data[0..66]); collections.keys.append(self.allocator, key_copy) catch continue;
const path_start = @sizeOf(SerializedEntry); if (value.mv_size >= path_start + header.path_len) { const path = self.allocator.dupe(u8, data[path_start..][0..header.path_len]) catch continue; collections.paths.append(self.allocator, path) catch self.allocator.free(path); } } }
inline fn deletePrimaryEntries(self: *CacheDB, txn: *c.MDB_txn, keys: []const [66]u8) u32 { var pruned: u32 = 0; for (keys) |*key_bytes| { var del_key = c.MDB_val{ .mv_size = 66, .mv_data = @constCast(key_bytes) }; if (c.mdb_del(txn, self.dbi_primary, &del_key, null) == 0) pruned += 1; } return pruned; }
inline fn pruneStaleSecondaryEntries(self: *CacheDB, txn: *c.MDB_txn) void { var cursor: ?*c.MDB_cursor = null; if (c.mdb_cursor_open(txn, self.dbi_secondary, &cursor) != 0) return; defer c.mdb_cursor_close(cursor);
var to_delete = std.ArrayListUnmanaged([]u8){}; defer { for (to_delete.items) |k| self.allocator.free(k); to_delete.deinit(self.allocator); }
var key: c.MDB_val = undefined; var value: c.MDB_val = undefined; var rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_FIRST);
while (rc == 0) : (rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_NEXT)) { if (value.mv_size != 64) continue;
const integrity: *const [64]u8 = @ptrCast(value.mv_data); const int_key = makeIntegrityKey(integrity); var check_key = c.MDB_val{ .mv_size = int_key.len, .mv_data = @constCast(&int_key) }; var check_val: c.MDB_val = undefined;
if (c.mdb_get(txn, self.dbi_primary, &check_key, &check_val) == 0) continue;
const key_data: [*]const u8 = @ptrCast(key.mv_data); const key_copy = self.allocator.dupe(u8, key_data[0..key.mv_size]) catch continue; to_delete.append(self.allocator, key_copy) catch self.allocator.free(key_copy); }
for (to_delete.items) |sec_key| { var del_key = c.MDB_val{ .mv_size = sec_key.len, .mv_data = @ptrCast(sec_key.ptr) }; _ = c.mdb_del(txn, self.dbi_secondary, &del_key, null); } }
inline fn deletePackageFiles(paths: []const []const u8) void { for (paths) |path| std.fs.cwd().deleteTree(path) catch {}; }
inline fn pruneExpiredMetadata(self: *CacheDB, txn: *c.MDB_txn) void { const now = std.time.timestamp();
var cursor: ?*c.MDB_cursor = null; if (c.mdb_cursor_open(txn, self.dbi_metadata, &cursor) != 0) return; defer c.mdb_cursor_close(cursor);
var to_delete = std.ArrayListUnmanaged([]u8){}; defer { for (to_delete.items) |k| self.allocator.free(k); to_delete.deinit(self.allocator); }
var key: c.MDB_val = undefined; var value: c.MDB_val = undefined; var rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_FIRST);
while (rc == 0) : (rc = c.mdb_cursor_get(cursor, &key, &value, c.MDB_NEXT)) { if (value.mv_size < @sizeOf(i64)) continue;
const data: [*]const u8 = @ptrCast(value.mv_data); var cached_at: i64 = undefined; @memcpy(std.mem.asBytes(&cached_at), data[0..@sizeOf(i64)]);
if (now - cached_at <= METADATA_TTL_SECS) continue;
const key_data: [*]const u8 = @ptrCast(key.mv_data); const key_copy = self.allocator.dupe(u8, key_data[0..key.mv_size]) catch continue; to_delete.append(self.allocator, key_copy) catch self.allocator.free(key_copy); }
for (to_delete.items) |meta_key| { var del_key = c.MDB_val{ .mv_size = meta_key.len, .mv_data = @ptrCast(meta_key.ptr) }; _ = c.mdb_del(txn, self.dbi_metadata, &del_key, null); } }
pub fn prune(self: *CacheDB, max_age_days: u32) !u32 { const now = std.time.timestamp(); const max_age_secs: i64 = @as(i64, max_age_days) * 24 * 60 * 60; const cutoff = now - max_age_secs;
var txn: ?*c.MDB_txn = null; if (c.mdb_txn_begin(self.env, null, 0, &txn) != 0) return error.DatabaseError; errdefer c.mdb_txn_abort(txn);
var collections = PruneCollections{}; defer collections.deinit(self.allocator);
try self.collectExpiredEntries(txn.?, cutoff, &collections); const pruned = self.deletePrimaryEntries(txn.?, collections.keys.items); self.pruneStaleSecondaryEntries(txn.?); self.pruneExpiredMetadata(txn.?);
if (c.mdb_txn_commit(txn) != 0) return error.DatabaseError; deletePackageFiles(collections.paths.items);
return pruned; }};