HomePhorge
Diffusion Ant (master) Code

ant/src/pkg/cache.zig
8755416ca476master

Last Change
Raw File

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