srctree

* when scanning the file system, detect files that are in the database but have

been deleted from the file system

 

try db.files.entries.resize(gpa, files.len);

@memcpy(db.files.entries.items(.key), files);

try db.files.reIndex(gpa);

 

try db.directories.entries.resize(gpa, directories.len);

@memcpy(db.directories.entries.items(.key), directories);

try db.directories.reIndex(gpa);

 

.debug => av.LOG.WARNING.set_level(),

const Directory = std.Build.Cache.Directory;

var opt_install_directory: ?Directory = null;

const install_directory: Directory = opt_install_directory orelse b: {

try loadDb(gpa, &db, install_directory, config.db_path);

try saveDb(&db, install_directory, config.db_path);

std.log.debug("loaded {d} files", .{db.files.entries.len});

const files = std.mem.sliceAsBytes(s.db.files.keys());

const directories = std.mem.sliceAsBytes(s.db.directories.keys());

.files_len = @intCast(s.db.files.entries.len),

.directories_len = @intCast(s.db.directories.entries.len),

for (s.db.files.keys(), 0..) |*db_file, i| {

const files = ctx.db.files.keys();

return files[a_index].track_number < files[b_index].track_number;

const file_gop = try db.files.getOrPut(gpa, .{

.directory = db_dir,

.basename = basename,

.title = undefined,

.artist = undefined,

.album = undefined,

.track_number = undefined,

.composer = undefined,

.performer = undefined,

});

if (file_gop.found_existing) continue;

db.files.lockPointers();

defer db.files.unlockPointers();

 

std.log.debug("opening new file '{s}'", .{basename_z});

file_gop.key_ptr.* = .{

};

 

pub const DbFileHeader = extern struct {

magic: Magic,

files_len: u32,

directories_len: u32,

albums_len: u32,

string_bytes_len: u32,

 

pub const Magic = enum(u32) {

v1 = 0x1f3686b5,

_,

};

};

 

fn saveDb(db: *const Db, install_directory: Directory, db_path: []const u8) !void {

const files = std.mem.sliceAsBytes(db.files.keys());

const directories = std.mem.sliceAsBytes(db.directories.keys());

const albums = std.mem.sliceAsBytes(db.albums.keys());

const string_bytes = db.string_bytes.items;

const header: DbFileHeader = .{

.magic = .v1,

.files_len = @intCast(db.files.entries.len),

.directories_len = @intCast(db.directories.entries.len),

.albums_len = @intCast(db.albums.entries.len),

.string_bytes_len = @intCast(db.string_bytes.items.len),

};

 

var iovecs = [_]std.posix.iovec_const{

.{ .iov_base = std.mem.asBytes(&header), .iov_len = @sizeOf(DbFileHeader) },

.{ .iov_base = files.ptr, .iov_len = files.len },

.{ .iov_base = directories.ptr, .iov_len = directories.len },

.{ .iov_base = albums.ptr, .iov_len = albums.len },

.{ .iov_base = string_bytes.ptr, .iov_len = string_bytes.len },

};

 

var atomic_file = try install_directory.handle.atomicFile(db_path, .{});

defer atomic_file.deinit();

try atomic_file.file.writevAll(&iovecs);

try atomic_file.finish();

}

 

fn loadDb(gpa: Allocator, db: *Db, install_directory: Directory, db_path: []const u8) !void {

var file = install_directory.handle.openFile(db_path, .{}) catch |err| switch (err) {

error.FileNotFound => return initEmptyDb(gpa, db),

else => |e| fatal("unable to load database '{}{s}: {s}'", .{ install_directory, db_path, @errorName(e) }),

};

defer file.close();

 

const header = file.reader().readStruct(DbFileHeader) catch |err| switch (err) {

error.EndOfStream => return initEmptyDb(gpa, db),

else => |e| return e,

};

 

if (header.magic != .v1)

fatal("invalid database header magic={x}", .{@intFromEnum(header.magic)});

 

try db.files.entries.resize(gpa, header.files_len);

try db.directories.entries.resize(gpa, header.directories_len);

try db.albums.entries.resize(gpa, header.albums_len);

try db.string_bytes.resize(gpa, header.string_bytes_len);

 

const files = std.mem.sliceAsBytes(db.files.keys());

const directories = std.mem.sliceAsBytes(db.directories.keys());

const albums = std.mem.sliceAsBytes(db.albums.keys());

const string_bytes = db.string_bytes.items;

 

var iovecs = [_]std.posix.iovec{

.{ .iov_base = files.ptr, .iov_len = files.len },

.{ .iov_base = directories.ptr, .iov_len = directories.len },

.{ .iov_base = albums.ptr, .iov_len = albums.len },

.{ .iov_base = string_bytes.ptr, .iov_len = string_bytes.len },

};

const amt_read = try file.readvAll(&iovecs);

const amt_expected = files.len + directories.len + albums.len + string_bytes.len;

if (amt_read != amt_expected) return error.UnexpectedFileSize;

 

try db.files.reIndexContext(gpa, .{});

try db.directories.reIndex(gpa);

try db.albums.reIndex(gpa);

 

{

// Build the string table map.

if (string_bytes.len < 2 or string_bytes[0] != 0 or string_bytes[string_bytes.len - 1] != 0)

return error.InvalidStringTable;

var i: usize = 0;

while (i < string_bytes.len) {

try db.string_table.putContext(gpa, @intCast(i), {}, .{

.bytes = &db.string_bytes,

});

i = std.mem.indexOfScalarPos(u8, string_bytes, i, 0).? + 1;

}

}

}

 

fn initEmptyDb(gpa: Allocator, db: *Db) !void {

// Reserve string index 0 for an empty string.

assert((try db.getOrPutString(gpa, "")) == .empty);

}

const Hash = std.hash.Wyhash;

files: std.ArrayHashMapUnmanaged(File, void, File.Hasher, false),

directories: std.AutoArrayHashMapUnmanaged(Path, void),

 

pub const Hasher = struct {

pub fn hash(h: Hasher, a: File) u32 {

_ = h;

return @truncate(Hash.hash(@intFromEnum(a.basename), std.mem.asBytes(&a.directory)));

}

 

pub fn eql(h: Hasher, a: File, b: File, b_index: usize) bool {

_ = h;

_ = b_index;

return a.basename == b.basename and a.directory == b.directory;

}

};

const gop = try db.directories.getOrPut(gpa, path);

return @enumFromInt(gop.index);

return db.directories.keys()[@intFromEnum(i)];