tiny.smg.storage.source

1pub const source = @import("source.zig");

1const std = @import("std");2const sql = @import("sql");3const sys = @import("sys");4const smg = @import("../root.zig");56const storage = smg.storage;7const fs_io = std.Options.debug_io;89pub const Digest = [std.crypto.hash.sha2.Sha256.digest_length]u8;1011pub const Owner = struct { executable: Digest, project: Digest };1213const magic = "tiny.smg.source/v1\n";14const identity_bytes = @sizeOf(sql.Hash) + 2 * @sizeOf(Digest);15const payload_bytes = magic.len + identity_bytes;16const file_bytes = payload_bytes + @sizeOf(Digest);17const read_buffer_bytes = 64 * 1024;1819pub fn executableDigest(allocator: std.mem.Allocator) !Digest {20    const executable = try std.process.executablePathAlloc(fs_io, allocator);21    defer allocator.free(executable);22    var file = try std.Io.Dir.openFileAbsolute(fs_io, executable, .{});23    defer file.close(fs_io);24    var reader_buffer: [read_buffer_bytes]u8 = undefined;25    var file_reader = file.reader(fs_io, &reader_buffer);26    var chunk: [read_buffer_bytes]u8 = undefined;27    var hasher = std.crypto.hash.sha2.Sha256.init(.{});28    while (true) {29        const count = file_reader.interface.readSliceShort(&chunk) catch |err| switch (err) {30            error.ReadFailed => return file_reader.err orelse error.ReadFailed,31        };32        if (count == 0) break;33        hasher.update(chunk[0..count]);34    }35    var digest: Digest = undefined;36    hasher.final(&digest);37    return digest;38}3940pub fn matches(41    allocator: std.mem.Allocator,42    root: []const u8,43    expected_head: sql.Hash,44    executable: Digest,45    project: Digest,46) std.mem.Allocator.Error!bool {47    const stored = try projectForOwner(allocator, root, expected_head, executable) orelse return false;48    return std.mem.eql(u8, &stored, &project);49}5051pub fn projectForOwner(52    allocator: std.mem.Allocator,53    root: []const u8,54    expected_head: sql.Hash,55    executable: Digest,56) std.mem.Allocator.Error!?Digest {57    const owner = try ownerForHead(allocator, root, expected_head) orelse return null;58    if (!std.mem.eql(u8, &owner.executable, &executable)) return null;59    return owner.project;60}6162/// Reads the checksummed scanner and project identity bound to one stored graph head.63pub fn ownerForHead(64    allocator: std.mem.Allocator,65    root: []const u8,66    expected_head: sql.Hash,67) std.mem.Allocator.Error!?Owner {68    const path = try cachePath(allocator, root, storage.paths.source_file_name);69    defer allocator.free(path);70    var file = std.Io.Dir.openFileAbsolute(fs_io, path, .{}) catch return null;71    defer file.close(fs_io);72    const stat = file.stat(fs_io) catch return null;73    if (stat.kind != .file or stat.size != file_bytes) return null;74    var encoded: [file_bytes]u8 = undefined;75    const read = file.readPositionalAll(fs_io, &encoded, 0) catch return null;76    if (read != encoded.len) return null;77    if (!std.mem.eql(u8, encoded[0..magic.len], magic)) return null;78    var computed: Digest = undefined;79    std.crypto.hash.sha2.Sha256.hash(encoded[0..payload_bytes], &computed, .{});80    if (!std.mem.eql(u8, &computed, encoded[payload_bytes..])) return null;81    var offset: usize = magic.len;82    if (!std.mem.eql(u8, expected_head[0..], encoded[offset .. offset + @sizeOf(sql.Hash)])) return null;83    offset += @sizeOf(sql.Hash);84    var executable: Digest = undefined;85    @memcpy(&executable, encoded[offset .. offset + @sizeOf(Digest)]);86    offset += @sizeOf(Digest);87    var project: Digest = undefined;88    @memcpy(&project, encoded[offset .. offset + @sizeOf(Digest)]);89    return .{ .executable = executable, .project = project };90}9192pub fn writeForHead(93    allocator: std.mem.Allocator,94    root: []const u8,95    head: sql.Hash,96    executable: Digest,97    project: Digest,98) !void {99    const temporary_name = try std.fmt.allocPrint(100        allocator,101        "{s}.{d}",102        .{ storage.paths.source_temp_file_name, try sys.process.currentProcessId() },103    );104    defer allocator.free(temporary_name);105    const temporary = try cachePath(allocator, root, temporary_name);106    defer allocator.free(temporary);107    const destination = try cachePath(allocator, root, storage.paths.source_file_name);108    defer allocator.free(destination);109    var encoded: [file_bytes]u8 = undefined;110    var offset: usize = 0;111    @memcpy(encoded[offset .. offset + magic.len], magic);112    offset += magic.len;113    @memcpy(encoded[offset .. offset + @sizeOf(sql.Hash)], &head);114    offset += @sizeOf(sql.Hash);115    @memcpy(encoded[offset .. offset + @sizeOf(Digest)], &executable);116    offset += @sizeOf(Digest);117    @memcpy(encoded[offset .. offset + @sizeOf(Digest)], &project);118    offset += @sizeOf(Digest);119    std.debug.assert(offset == payload_bytes);120    var digest: Digest = undefined;121    std.crypto.hash.sha2.Sha256.hash(encoded[0..payload_bytes], &digest, .{});122    @memcpy(encoded[payload_bytes..], &digest);123    errdefer std.Io.Dir.deleteFileAbsolute(fs_io, temporary) catch {};124    {125        var file = try std.Io.Dir.createFileAbsolute(fs_io, temporary, .{ .truncate = true });126        defer file.close(fs_io);127        try file.writeStreamingAll(fs_io, &encoded);128        try file.sync(fs_io);129    }130    try sys.fs.rename(temporary, destination);131}132133fn cachePath(134    allocator: std.mem.Allocator,135    root: []const u8,136    name: []const u8,137) std.mem.Allocator.Error![]const u8 {138    return try std.fs.path.join(139        allocator,140        &.{ root, storage.paths.smg_dir_name, name },141    );142}143144test "source identity cache matches only exact graph executable and project" {145    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);146    defer arena.deinit();147    const allocator = arena.allocator();148    const root = try std.fmt.allocPrint(allocator, "/tmp/smg-source-identity-test-{x}", .{@intFromPtr(&arena)});149    defer sys.fs.deleteTree(root) catch {};150    try sys.fs.createDirPath(try std.fs.path.join(allocator, &.{ root, storage.paths.smg_dir_name }));151    const head: sql.Hash = @splat(1);152    const executable: Digest = @splat(2);153    const project: Digest = @splat(3);154155    try writeForHead(allocator, root, head, executable, project);156157    const owner = (try ownerForHead(allocator, root, head)).?;158    try std.testing.expectEqualSlices(u8, &executable, &owner.executable);159    try std.testing.expectEqualSlices(u8, &project, &owner.project);160    try std.testing.expect(try ownerForHead(allocator, root, @splat(4)) == null);161    try std.testing.expect(try matches(allocator, root, head, executable, project));162    try std.testing.expect(!try matches(allocator, root, @as(sql.Hash, @splat(4)), executable, project));163    try std.testing.expect(!try matches(allocator, root, head, @as(Digest, @splat(4)), project));164    try std.testing.expect(!try matches(allocator, root, head, executable, @as(Digest, @splat(4))));165    const path = try cachePath(allocator, root, storage.paths.source_file_name);166    var file = try std.Io.Dir.openFileAbsolute(fs_io, path, .{ .mode = .read_write });167    defer file.close(fs_io);168    try file.writePositionalAll(fs_io, "x", magic.len + 1);169    try std.testing.expect(!try matches(allocator, root, head, executable, project));170}