Added cache logic

Author: jfkonecn

src/cache.zig

@@ -1,4 +1,10 @@
+// Generally Questions
+// How will the compiler/roc symlink be set?
+// Spec here https://github.com/roc-lang/roc/issues/7517
+const builtin = @import("builtin");
 const std = @import("std");
+const testing = std.testing;
+const Allocator = std.mem.Allocator;
 const base = @import("base.zig");
 const canonicalize = @import("check/canonicalize.zig");
 
@@ -19,3 +25,381 @@ pub fn getPackageRootAbsDir(url_data: Package.Url, gpa: std.mem.Allocator) []con
 
     @panic("not implemented");
 }
+
+pub const CacheFileQuery = union(enum) {
+    compiler: Compiler,
+    build,
+    packages_src,
+    packages_build,
+
+    pub const Compiler = struct {
+        version_name: []const u8,
+    };
+};
+
+pub const CacheFileData = union(enum) {
+    compiler: Compiler,
+    build,
+    packages_src,
+    packages_build,
+
+    pub const Compiler = struct {
+        version_name: []const u8,
+        binary: []const u8,
+    };
+};
+
+const target_os = builtin.target.os.tag;
+fn setEnvVar(allocator: Allocator, name: []const u8, value: []const u8) !void {
+    // SKILL_ISSUE: it's required to use -lc to run the tests because of the
+    // c library calls. Is there a better way to run a single test file?
+    // zig test ./src/cache.zig -lc
+    const c_str = try allocator.dupeZ(u8, value);
+    defer allocator.free(c_str);
+
+    return {
+        switch (target_os) {
+            .macos, .linux => {
+                const c = @cImport({
+                    @cInclude("stdlib.h");
+                });
+                if (c.setenv(name.ptr, c_str.ptr, 1) != 0) {
+                    return error.SetEnvFailed;
+                }
+            },
+            //.windows => {
+            // TODO: figure out windows implementation
+            //const c = @cImport({
+            //@cInclude("windows.h");
+            //});
+            //if (c.SetEnvironmentVariableA(name.ptr, value.ptr) == 0) {
+            //return error.SetEnvFailed;
+            //}
+            //},
+            else => {
+                @compileError("\"" ++ @tagName(target_os) ++ "\" is not supported in cache.zig");
+            },
+        }
+    };
+}
+
+pub fn unsetEnvVar(name: []const u8) !void {
+    // SKILL_ISSUE: it's required to use -lc to run the tests because of the
+    // c library calls. Is there a better way to run a single test file?
+    // zig test ./src/cache.zig -lc
+    return {
+        switch (target_os) {
+            .macos, .linux => {
+                const c = @cImport({
+                    @cInclude("stdlib.h");
+                });
+                if (c.unsetenv(name.ptr) != 0) {
+                    return error.UnsetEnvFailed;
+                }
+            },
+            // FIX_FOR_WINDOWS:
+            //.windows => {
+            // TODO: figure out windows implementation
+            //const c = @cImport({
+            //@cInclude("windows.h");
+            //});
+            //if (c.SetEnvironmentVariableA(name.ptr, value.ptr) == 0) {
+            //return error.SetEnvFailed;
+            //}
+            //},
+            else => {
+                @compileError("\"" ++ @tagName(target_os) ++ "\" is not supported in cache.zig");
+            },
+        }
+    };
+}
+
+fn getDefaultCacheFolder(allocator: Allocator) ![]u8 {
+    return {
+        switch (target_os) {
+            .macos, .linux => {
+                const home_dir = try std.process.getEnvVarOwned(allocator, "HOME");
+                defer allocator.free(home_dir);
+                const default_cache_folder_parts = [_][]const u8{
+                    home_dir,
+                    ".cache",
+                };
+                const default_cache_folder = try std.fs.path.join(allocator, &default_cache_folder_parts);
+                return default_cache_folder;
+            },
+            .windows => {
+                const default_cache_folder_parts = [_][]const u8{"%APPDATA%"};
+                const default_cache_folder = try std.fs.path.join(allocator, &default_cache_folder_parts);
+                return default_cache_folder;
+            },
+            else => {
+                @compileError("\"" ++ @tagName(target_os) ++ "\" is not supported in cache.zig");
+            },
+        }
+    };
+}
+
+const xdg_cache_home_var_name = "XDG_CACHE_HOME";
+fn getBaseRocCacheFolder(allocator: Allocator, sub_path: []const u8) ![]u8 {
+    const xdg_cache_home = std.process.getEnvVarOwned(allocator, xdg_cache_home_var_name) catch null;
+    defer {
+        if (xdg_cache_home) |x| {
+            allocator.free(x);
+        }
+    }
+    const base_dir = if (xdg_cache_home) |x|
+        try allocator.dupe(u8, x)
+    else
+        try getDefaultCacheFolder(allocator);
+
+    defer allocator.free(base_dir);
+    const roc_cache_parts = [_][]const u8{
+        base_dir,
+        "roc",
+        sub_path,
+    };
+    return try std.fs.path.join(allocator, &roc_cache_parts);
+}
+
+fn getCompilerPath(allocator: Allocator, version_name: []const u8) ![]u8 {
+    const sub_path_parts = [_][]const u8{ "compiler", version_name };
+    const sub_path = try std.fs.path.join(allocator, &sub_path_parts);
+    defer allocator.free(sub_path);
+    return try getBaseRocCacheFolder(allocator, sub_path);
+}
+
+const SaveCacheFileError = error{
+    FailedToMakeCacheFolder,
+    FailedToMakeCacheFile,
+    FailedToWriteToCacheFile,
+};
+
+fn saveCacheFile(file_cache_path: []const u8, file_binary: []const u8) SaveCacheFileError!void {
+    const cwd = std.fs.cwd();
+    const roc_cache_folder = std.fs.path.dirname(file_cache_path);
+    if (roc_cache_folder) |x| {
+        cwd.makePath(x) catch {
+            return error.FailedToMakeCacheFolder;
+        };
+    }
+    const file = cwd.createFile(file_cache_path, .{}) catch {
+        return SaveCacheFileError.FailedToMakeCacheFile;
+    };
+    file.writeAll(file_binary) catch {
+        return SaveCacheFileError.FailedToWriteToCacheFile;
+    };
+}
+
+fn saveToCacheInternal(
+    // SKILL_ISSUE: force my formatter to put the arguments in a vertical line
+    allocator: Allocator,
+    roc_cache_file: CacheFileData,
+    comptime save: fn (file_cache_path: []const u8, file_binary: []const u8) SaveCacheFileError!void,
+) !void {
+    const file_cache_path = switch (roc_cache_file) {
+        .compiler => |value| try getCompilerPath(allocator, value.version_name),
+        else => @panic("FIX ME!!!!!!"),
+    };
+
+    defer allocator.free(file_cache_path);
+
+    const file_binary = switch (roc_cache_file) {
+        .compiler => |value| value.binary,
+        else => @panic("FIX ME!!!!!!"),
+    };
+
+    try save(file_cache_path, file_binary);
+}
+
+pub fn saveToCache(allocator: Allocator, roc_cache_file: CacheFileData) !void {
+    try saveToCacheInternal(allocator, roc_cache_file, saveCacheFile);
+}
+
+const GetCacheFileError = error{
+    AccessDeniedToCache,
+    Unexpected,
+    OutOfMemory,
+};
+
+fn getCacheFile(allocator: Allocator, file_cache_path: []const u8) GetCacheFileError!?[]const u8 {
+    const File = std.fs.File;
+    const OpenError = File.OpenError;
+    const file = std.fs.cwd().openFile(file_cache_path, .{ .mode = .read_only }) catch |e| {
+        return switch (e) {
+            OpenError.FileNotFound => null,
+            OpenError.AccessDenied => GetCacheFileError.AccessDeniedToCache,
+            OpenError.NameTooLong => null,
+            else => GetCacheFileError.Unexpected,
+        };
+    };
+    defer file.close();
+
+    const GetSeekPosError = File.GetSeekPosError;
+    const file_size = file.getEndPos() catch |e| {
+        return switch (e) {
+            GetSeekPosError.AccessDenied => GetCacheFileError.AccessDeniedToCache,
+            else => GetCacheFileError.Unexpected,
+        };
+    };
+    const buf = try allocator.alloc(u8, file_size);
+
+    const ReadError = File.ReadError;
+    _ = file.readAll(buf) catch |e| {
+        return switch (e) {
+            ReadError.AccessDenied => GetCacheFileError.AccessDeniedToCache,
+            else => GetCacheFileError.Unexpected,
+        };
+    };
+    return buf;
+}
+
+fn tryToGetCacheFileInternal(allocator: Allocator, cache_file_query: CacheFileQuery) !?[]const u8 {
+    const file_cache_path = switch (cache_file_query) {
+        .compiler => |value| try getCompilerPath(allocator, value.version_name),
+        else => @panic("FIX ME!!!!!!"),
+    };
+    defer allocator.free(file_cache_path);
+    return try getCacheFile(allocator, file_cache_path);
+}
+
+pub fn tryToGetCacheFile(allocator: Allocator, cache_file_query: CacheFileQuery) !?[]const u8 {
+    return try tryToGetCacheFileInternal(allocator, cache_file_query);
+}
+
+fn create_test_cache_folder(allocator: Allocator) !testing.TmpDir {
+    const tmp_dir = testing.tmpDir(.{});
+    const path = try tmp_dir.dir.realpathAlloc(allocator, ".");
+    defer allocator.free(path);
+    try setEnvVar(allocator, xdg_cache_home_var_name, path);
+    return tmp_dir;
+}
+
+pub fn create_save_stub(allocator: Allocator) type {
+    return struct {
+        const Self = @This();
+        var file_cache_path_list = std.ArrayList([]const u8).init(allocator);
+        var file_binary_list = std.ArrayList([]const u8).init(allocator);
+
+        fn deinit() void {
+            for (Self.file_cache_path_list.items) |path| {
+                allocator.free(path);
+            }
+            for (Self.file_binary_list.items) |binary| {
+                allocator.free(binary);
+            }
+
+            Self.file_cache_path_list.deinit();
+            Self.file_binary_list.deinit();
+        }
+
+        fn closure(file_cache_path: []const u8, file_binary: []const u8) SaveCacheFileError!void {
+            const file_cache_path_copy = allocator.dupe(u8, file_cache_path) catch {
+                @panic("Failed to copy cache path string in test");
+            };
+            Self.file_cache_path_list.append(file_cache_path_copy) catch {
+                @panic("Failed to append to file_cache_path_list in test");
+            };
+            const file_binary_copy = allocator.dupe(u8, file_binary) catch {
+                @panic("Failed to copy cache path string in test");
+            };
+            Self.file_binary_list.append(file_binary_copy) catch {
+                @panic("Failed to append to file_binary_list in test");
+            };
+        }
+
+        fn assert_save_called_with_correct_arguments(file_cache_path: []const u8, file_binary: []const u8) !void {
+            try testing.expectEqual(1, Self.file_cache_path_list.items.len);
+            try testing.expectEqual(1, Self.file_binary_list.items.len);
+            try testing.expectEqualStrings(file_cache_path, Self.file_cache_path_list.items[0]);
+            try testing.expectEqualStrings(file_binary, Self.file_binary_list.items[0]);
+        }
+    };
+}
+
+fn get_home_directory(allocator: Allocator) ![]u8 {
+    return {
+        switch (target_os) {
+            .macos, .linux => {
+                return try std.process.getEnvVarOwned(allocator, "HOME");
+            },
+            .windows => {
+                return "%APPDATA%";
+            },
+            else => {
+                @compileError("\"" ++ @tagName(target_os) ++ "\" is not supported in cache.zig");
+            },
+        }
+    };
+}
+
+test "Should save to XDG_CACHE_HOME if it is set for compiler cache" {
+    const allocator = testing.allocator;
+    var tmp_dir = try create_test_cache_folder(allocator);
+    defer tmp_dir.cleanup();
+    defer {
+        unsetEnvVar(xdg_cache_home_var_name) catch {
+            @panic("failed to unset " ++ xdg_cache_home_var_name);
+        };
+    }
+    const cache_file = CacheFileData.Compiler{
+        .version_name = "1.0.0",
+        .binary = "A roc compiler binary",
+    };
+    try saveToCache(allocator, CacheFileData{ .compiler = cache_file });
+
+    const binary = try tryToGetCacheFile(allocator, CacheFileQuery{ .compiler = CacheFileQuery.Compiler{
+        .version_name = cache_file.version_name,
+    } }) orelse @panic("Binary file should exist");
+    defer allocator.free(binary);
+
+    try testing.expectEqual(cache_file.binary.len, binary.len);
+    try testing.expectEqualStrings(cache_file.binary, binary);
+}
+
+test "Should save to .cache folder if XDG_CACHE_HOME is not set for compiler cache" {
+    const allocator = testing.allocator;
+    const home_dir = try get_home_directory(allocator);
+    defer allocator.free(home_dir);
+
+    const cache_file = CacheFileData.Compiler{
+        .version_name = "1.0.0",
+        .binary = "A roc compiler binary",
+    };
+
+    const save_stub_context = create_save_stub(allocator);
+    defer save_stub_context.deinit();
+
+    try saveToCacheInternal(allocator, CacheFileData{ .compiler = cache_file }, save_stub_context.closure);
+
+    const expected_binary = cache_file.binary;
+    const expected_file_cache_path = try std.fs.path.join(allocator, &[_][]const u8{
+        home_dir,
+        ".cache",
+        "roc",
+        "compiler",
+        cache_file.version_name,
+    });
+    defer allocator.free(expected_file_cache_path);
+    try save_stub_context.assert_save_called_with_correct_arguments(expected_file_cache_path, expected_binary);
+}
+
+test "Should return if there is no cache file" {
+    const allocator = testing.allocator;
+    const home_dir = try get_home_directory(allocator);
+    defer allocator.free(home_dir);
+    const fake_path = try std.fs.path.join(allocator, &[_][]const u8{
+        home_dir,
+        "fake-cache",
+    });
+    defer allocator.free(fake_path);
+    try setEnvVar(allocator, xdg_cache_home_var_name, fake_path);
+    const cache_file_query = CacheFileQuery.Compiler{
+        .version_name = "1.0.0",
+    };
+    const binary = try tryToGetCacheFile(allocator, CacheFileQuery{ .compiler = cache_file_query });
+    if (binary) |b| {
+        defer allocator.free(b);
+    }
+
+    try testing.expectEqual(null, binary);
+}