Version Fetching: Cache the master version

Author: trnxdev

README.md

@@ -13,7 +13,8 @@
 | :---------------: | :----------------------------------------------------------: |
 | install [version] | Installs a zig version                                       |
 | setup [version]   | Installs a zig version and sets it as default in the config. |
-| exists  [version] | Check if a zig version is installed on the system            |
+| exists [version]  | Check if a zig version is installed on the system            |
+| recache-master    | Re-cache the master version                                  |
 | help              | Help screen                                                  |
 | version           | Outputs zigd version                                         |
 
@@ -55,6 +56,10 @@ default=0.13.0
 
 ### `zig build`
 
+## Important Stuff to know
+
+### `master` version is cached for 12 hours at (zigd directory)/cached_master, you can use `zigd recache-master` to update it.
+
 ## An Example Usage
 
 ```

build.zig.zon

@@ -1,6 +1,6 @@
 .{
     .name = "zigd",
-    .version = "0.0.3",
+    .version = "0.0.4",
     .minimum_zig_version = "0.13.0",
     .paths = .{
         "build.zig",

src/utils.zig

@@ -58,14 +58,21 @@ pub inline fn createDirectoryIgnoreExist(path: []const u8) !void {
     };
 }
 
-pub inline fn existsReadFileCwd(allocator: std.mem.Allocator, cwd_path: []const u8) !?[]u8 {
+pub inline fn existsOpenFile(cwd_path: []const u8, flags: std.fs.File.OpenFlags) !?std.fs.File {
+    return std.fs.cwd().openFile(cwd_path, flags) catch |e| switch (e) {
+        std.fs.File.OpenError.FileNotFound => null,
+        else => e,
+    };
+}
+
+pub inline fn existsReadFile(allocator: std.mem.Allocator, cwd_path: []const u8) !?[]u8 {
     return std.fs.cwd().readFileAlloc(allocator, cwd_path, std.math.maxInt(usize)) catch |e| switch (e) {
         std.fs.File.OpenError.FileNotFound => null,
         else => e,
     };
 }
 
-pub inline fn existsReadFileCwdSentinel(allocator: std.mem.Allocator, cwd_path: [:0]const u8) !?[:0]u8 {
+pub inline fn existsReadFileSentinel(allocator: std.mem.Allocator, cwd_path: [:0]const u8) !?[:0]u8 {
     return std.fs.cwd().readFileAllocOptions(allocator, cwd_path, std.math.maxInt(usize), null, 1, 0) catch |e| switch (e) {
         std.fs.File.OpenError.FileNotFound => null,
         else => e,

src/zigd.version

@@ -1 +1 @@
-0.0.3
+0.0.4

src/zigdcli.zig

@@ -6,6 +6,7 @@ const Command = enum {
     install,
     setup,
     exists,
+    @"recache-master",
     help,
     version,
 };
@@ -28,6 +29,7 @@ pub fn main() !void {
             .install => install(allocator, args),
             .setup => setup(allocator, args),
             .exists => exists(allocator, args),
+            .@"recache-master" => recache_master(allocator),
             .help => help_menu(),
             .version => version(),
         };
@@ -44,6 +46,7 @@ fn help_menu() !void {
         \\install [version] - Install a zig version
         \\setup [version] - First time setup (creates a config and installs the version)
         \\exists [version] - Check if a zig version is installed on the system
+        \\recache-master - Re-cache the master version
         \\help - Outputs this help Menu
         \\version - Outputs zigd version
         \\
@@ -69,17 +72,17 @@ fn install(allocator: std.mem.Allocator, args: []const []const u8) !void {
         return;
     }
 
-    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false);
+    const zigd_path = try zigdcore.getZigdPath(allocator);
+    defer allocator.free(zigd_path);
+
+    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false, zigd_path, true);
     defer zig_version.deinitIfMasterOrZigverOrZonver(allocator);
 
     try std.io.getStdOut().writer().print("Installing zig version {s}\n", .{zig_version});
 
     const download_url = try zigdcore.downloadUrlFromVersion(allocator, zig_version.as_string, zig_version.source == .Master);
     defer allocator.free(download_url);
 
-    const zigd_path = try zigdcore.getZigdPath(allocator);
-    defer allocator.free(zigd_path);
-
     if (!try zigdcore.install_zig(allocator, download_url, zigd_path, zig_version)) {
         std.log.err("Installation failed!", .{});
     }
@@ -117,7 +120,7 @@ fn setup(allocator: std.mem.Allocator, args: []const []const u8) !void {
         }
     }
 
-    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false);
+    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false, zigd_path, true);
     defer zig_version.deinitIfMasterOrZigverOrZonver(allocator);
 
     if (zig_version.source == .Master) {
@@ -168,10 +171,10 @@ fn exists(allocator: std.mem.Allocator, args: []const []const u8) !void {
     const zigd_path = try zigdcore.getZigdPath(allocator);
     defer allocator.free(zigd_path);
 
-    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false);
+    var zig_version = try zigdcore.ZigVersion.parse(allocator, args[2], &user_arg, false, zigd_path, true);
     defer zig_version.deinitIfMasterOrZigverOrZonver(allocator);
 
-    const version_path = try std.fs.path.join(allocator, &.{ zigd_path, "versions", args[2] });
+    const version_path = try std.fs.path.join(allocator, &.{ zigd_path, "versions", zig_version.as_string });
     defer allocator.free(version_path);
 
     if (try utils.isDirectory(version_path)) {
@@ -180,3 +183,19 @@ fn exists(allocator: std.mem.Allocator, args: []const []const u8) !void {
         try std.io.getStdOut().writer().writeAll("No!\n");
     }
 }
+
+fn recache_master(allocator: std.mem.Allocator) !void {
+    const zigd_path = try zigdcore.getZigdPath(allocator);
+    defer allocator.free(zigd_path);
+
+    const master = try zigdcore.fetchMaster(allocator, zigd_path, false);
+    defer allocator.free(master);
+
+    const cache_path = try zigdcore.getCachePath(allocator, zigd_path);
+    defer allocator.free(cache_path);
+
+    const cache_file = try zigdcore.getCacheFile(cache_path);
+    defer cache_file.close();
+
+    try cache_file.writer().writeAll(master);
+}

src/zigdcore.zig

@@ -84,7 +84,46 @@ pub fn install_zig(allocator: std.mem.Allocator, download_url: []const u8, insta
     return true;
 }
 
-pub fn masterFromIndex(allocator: std.mem.Allocator) ![]const u8 {
+pub fn getCachePath(allocator: std.mem.Allocator, zigd_path: []const u8) ![]u8 {
+    return try std.fs.path.join(allocator, &.{ zigd_path, "cached_master" });
+}
+
+pub fn getCacheFile(cache_path: []const u8) !std.fs.File {
+    return try utils.existsOpenFile(cache_path, .{ .mode = .read_write }) orelse v: {
+        break :v try std.fs.createFileAbsolute(cache_path, .{
+            .read = true,
+            .truncate = false,
+            .exclusive = true,
+        });
+    };
+}
+
+// TODO: Add an command to re-cache or disable cache
+// Caller frees the memory
+pub fn fetchMaster(allocator: std.mem.Allocator, zigd_path: []const u8, allow_cache: bool) ![]u8 {
+    const cache_path: ?[]const u8 = if (allow_cache)
+        try getCachePath(allocator, zigd_path)
+    else
+        null;
+    defer if (cache_path) |cp| allocator.free(cp);
+
+    const cache_file: ?std.fs.File = if (allow_cache) try getCacheFile(cache_path orelse unreachable) else null;
+    defer if (cache_file) |cf| cf.close();
+
+    if (allow_cache) {
+        const file_stat = try (cache_file orelse unreachable).stat();
+
+        // If last modified less than 12 hours ago
+        if (file_stat.mtime > std.time.nanoTimestamp() - (12 * std.time.ns_per_hour)) {
+            const ver = try (cache_file orelse unreachable).readToEndAlloc(allocator, std.math.maxInt(usize));
+
+            if (!std.meta.isError(std.SemanticVersion.parse(ver)))
+                return ver;
+
+            allocator.free(ver);
+        }
+    }
+
     var client = std.http.Client{ .allocator = allocator };
     defer client.deinit();
 
@@ -121,6 +160,9 @@ pub fn masterFromIndex(allocator: std.mem.Allocator) ![]const u8 {
         return error.VersionNotString;
     }
 
+    if (allow_cache)
+        try (cache_file orelse unreachable).writer().writeAll(version.string);
+
     return try allocator.dupe(u8, version.string);
 }
 
@@ -146,7 +188,7 @@ pub const ZigVersion = struct {
     };
 
     // Handles the "master" case
-    pub fn parse(allocator: std.mem.Allocator, str: []const u8, source: *Source, free_instant_if_zigver: bool) !@This() {
+    pub fn parse(allocator: std.mem.Allocator, str: []const u8, source: *Source, free_instant_if_zigver: bool, zigd_path: []const u8, allow_cache: bool) !@This() {
         var zig_version: @This() = .{
             .as_string = str,
             .source = source.*,
@@ -157,7 +199,7 @@ pub const ZigVersion = struct {
                 allocator.free(str);
 
             zig_version = .{
-                .as_string = try masterFromIndex(allocator),
+                .as_string = try fetchMaster(allocator, zigd_path, allow_cache),
                 .source = .{ .Master = source },
             };
         }

src/zigdemu.zig

@@ -22,15 +22,15 @@ pub fn main() !void {
     defer config.deinit();
 
     var zig_version: zigdcore.ZigVersion = v: {
-        if (try utils.existsReadFileCwd(allocator, "zig.ver")) |zig_ver| {
+        if (try utils.existsReadFile(allocator, "zig.ver")) |zig_ver| {
             // Can't error so no need for errdefer in this scope
             break :v zigdcore.ZigVersion{
                 .as_string = zig_ver,
                 .source = .Zigver,
             };
         }
 
-        if (try utils.existsReadFileCwdSentinel(allocator, "build.zig.zon")) |build_zig_zon| {
+        if (try utils.existsReadFileSentinel(allocator, "build.zig.zon")) |build_zig_zon| {
             defer allocator.free(build_zig_zon);
 
             if (try zon_minimum_version(allocator, build_zig_zon)) |zonver| {
@@ -62,7 +62,7 @@ pub fn main() !void {
         return;
     };
 
-    zig_version = try zigdcore.ZigVersion.parse(allocator, zig_version.as_string, &zig_version.source, true);
+    zig_version = try zigdcore.ZigVersion.parse(allocator, zig_version.as_string, &zig_version.source, true, zigd_path, true);
     defer zig_version.deinitIfMasterOrZigverOrZonver(allocator);
 
     const zig_binary_path = try std.fs.path.join(allocator, &.{ zigd_path, "versions", zig_version.as_string, "zig" ++ utils.binary_ext });