nursery

cache.zig
View Options

			const 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;
			}
			};

Owner Packages

No Owners

ant/src/pkg/cache.zigddfe6237cab5feature/nursery

cache.zigView Options

Owner Packages

ant/src/pkg/cache.zig
ddfe6237cab5feature/nursery

cache.zig
View Options