fix: use the new Io interface introduced in ziglang/zig/pull/25592

Author: AMythicDev

src/common/overrides.zig

@@ -4,6 +4,7 @@ const StringArrayHashMap = std.StringArrayHashMap;
 const json = std.json;
 const CommonPaths = @import("paths.zig").CommonPaths;
 const File = std.fs.File;
+const Io = std.Io;
 
 pub const OverrideMap = struct {
     backing_map: json.ObjectMap,
@@ -51,9 +52,9 @@ pub const OverrideMap = struct {
     }
 };
 
-pub fn read_overrides(alloc: Allocator, cp: CommonPaths) !OverrideMap {
+pub fn read_overrides(alloc: Allocator, io: Io, cp: CommonPaths) !OverrideMap {
     var buf: [4096]u8 = undefined;
-    var file_bufreader = File.Reader.init(cp.overrides, &buf);
+    var file_bufreader = cp.overrides.reader(io, &buf);
     const file_reader = &file_bufreader.interface;
 
     var overrides = OverrideMap{ .backing_map = json.ObjectMap.init(alloc), .allocator = alloc };

src/install.zig

@@ -15,6 +15,7 @@ const release_name = common.release_name;
 const AtomicOrder = std.builtin.AtomicOrder;
 const time = std.time;
 const File = std.fs.File;
+const Io = std.Io;
 
 const default_os = builtin.target.os.tag;
 const default_arch = builtin.target.cpu.arch;
@@ -30,7 +31,7 @@ const InstallError = error{
     TargetNotAvailable,
 };
 
-pub fn install_release(alloc: Allocator, client: *Client, releases: json.Value, rel: *Release, cp: CommonPaths) !void {
+pub fn install_release(alloc: Allocator, io: Io, client: *Client, releases: json.Value, rel: *Release, cp: CommonPaths) !void {
     try rel.resolve(releases);
 
     const release: json.Value = releases.object.get(try rel.actualVersion(alloc)).?;
@@ -41,11 +42,11 @@ pub fn install_release(alloc: Allocator, client: *Client, releases: json.Value,
 
     const tarball_dw_filename = try dw_tarball_name(alloc, rel.*);
 
-    var tarball = try get_correct_tarball(alloc, client, tarball_dw_filename, tarball_url, total_size, shasum, cp, 0);
+    var tarball = try get_correct_tarball(alloc, io, client, tarball_dw_filename, tarball_url, total_size, shasum, cp, 0);
     defer tarball.close();
 
     var buf: [4096]u8 = undefined;
-    var tarball_reader = tarball.reader(&buf);
+    var tarball_reader = tarball.reader(io, &buf);
     const tbl_intf = &tarball_reader.interface;
 
     std.log.info("Extracting {s}", .{tarball_dw_filename});
@@ -55,7 +56,7 @@ pub fn install_release(alloc: Allocator, client: *Client, releases: json.Value,
     try cp.download_dir.deleteFile(tarball_dw_filename);
 }
 
-fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: []const u8, tarball_url: []const u8, total_size: usize, shasum: *const [64]u8, cp: CommonPaths, tries: u8) !std.fs.File {
+fn get_correct_tarball(alloc: Allocator, io: Io, client: *Client, tarball_dw_filename: []const u8, tarball_url: []const u8, total_size: usize, shasum: *const [64]u8, cp: CommonPaths, tries: u8) !std.fs.File {
     const force_redownload = tries > 0;
     // IMPORTANT: To continue downloading if the file isn't completely downloaded AKA partial downloading, we
     // open the file with .truncate = false and then later move the file cursor to the end of the file using seekFromEnd().
@@ -70,6 +71,7 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
         var tarball_writer = tarball.writer(&buf);
         try download_tarball(
             alloc,
+            io,
             client,
             tarball_url,
             &tarball_writer,
@@ -81,14 +83,14 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
         std.log.info("Found already existing tarball, using that", .{});
     }
 
-    var tarball_reader = tarball.reader(&buf);
+    var tarball_reader = tarball.reader(io, &buf);
     const tbl_intf = &tarball_reader.interface;
     const hash_matched = try check_hash(shasum, tbl_intf);
 
     if (!hash_matched) {
         if (tries < 3) {
             std.log.warn("Hashes do match for downloaded tarball. Retrying again...", .{});
-            tarball = try get_correct_tarball(alloc, client, tarball_dw_filename, tarball_url, total_size, shasum, cp, tries + 1);
+            tarball = try get_correct_tarball(alloc, io, client, tarball_dw_filename, tarball_url, total_size, shasum, cp, tries + 1);
         } else {
             std.log.err("Hashes do match for downloaded tarball. Exitting", .{});
             return error.BadChecksum;
@@ -98,11 +100,11 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
     return tarball;
 }
 
-pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, tb_writer: *std.fs.File.Writer, tarball_size: u64, total_size: usize) !void {
+pub fn download_tarball(alloc: Allocator, io: Io, client: *Client, tb_url: []const u8, tb_writer: *std.fs.File.Writer, tarball_size: u64, total_size: usize) !void {
     std.log.info("Downloading {s}", .{tb_url});
     const tarball_uri = try std.Uri.parse(tb_url);
 
-    var req = make_request(client, tarball_uri);
+    var req = make_request(client, io, tarball_uri);
     defer req.?.deinit();
     if (req == null) {
         std.log.err("Failed fetching the install tarball. Exitting (1)...", .{});
@@ -129,7 +131,7 @@ pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, t
     const total_size_d: f64 = @floatFromInt(total_size);
     const tarball_size_d: f64 = @floatFromInt(tarball_size);
 
-    const progress_thread = try std.Thread.spawn(.{}, download_progress_bar, .{ &dlnow, tarball_size_d, total_size_d });
+    const progress_thread = try std.Thread.spawn(.{}, download_progress_bar, .{ io, &dlnow, tarball_size_d, total_size_d });
     const tbw_intf = &tb_writer.interface;
     while (tarball_size_d + dlnow.load(AtomicOrder.monotonic) <= total_size_d) {
         const len = try reader.readSliceShort(&buff);
@@ -144,7 +146,7 @@ pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, t
     try tb_writer.end();
 }
 
-pub fn download_progress_bar(dlnow: *std.atomic.Value(f32), tarball_size: f64, total_size: f64) !void {
+pub fn download_progress_bar(io: Io, dlnow: *std.atomic.Value(f32), tarball_size: f64, total_size: f64) !void {
     const stderr = std.fs.File.stderr();
     var stderrw = std.fs.File.Writer.init(stderr, &.{});
     const stderr_writer = &stderrw.interface;
@@ -165,17 +167,17 @@ pub fn download_progress_bar(dlnow: *std.atomic.Value(f32), tarball_size: f64, t
 
         if (downloaded + tarball_size >= total_size) break;
 
-        std.Thread.sleep(500 * time.ns_per_ms);
+        io.sleep(.fromMilliseconds(500), .awake) catch {};
         downloaded = dlnow.load(AtomicOrder.monotonic);
     }
     try stderr_writer.print("\n", .{});
 }
 
-pub fn get_json_dslist(client: *Client) anyerror!JsonResponse {
+pub fn get_json_dslist(io: Io, client: *Client) anyerror!JsonResponse {
     std.log.info("Fetching the latest index", .{});
     const uri = try std.Uri.parse("https://ziglang.org/download/index.json");
 
-    var req = make_request(client, uri);
+    var req = make_request(client, io, uri);
     defer req.?.deinit();
     if (req == null) {
         std.log.err("Failed fetching the index. Exitting (1)...", .{});
@@ -196,7 +198,7 @@ pub fn get_json_dslist(client: *Client) anyerror!JsonResponse {
     return JsonResponse{ .body = json_buf, .length = bytes_read };
 }
 
-pub fn make_request(client: *Client, uri: std.Uri) ?Client.Request {
+pub fn make_request(client: *Client, io: Io, uri: std.Uri) ?Client.Request {
     // TODO: REMOVE THIS IF UNUSED
     var http_header_buff: [8192]u8 = undefined;
     _ = &http_header_buff;
@@ -206,7 +208,7 @@ pub fn make_request(client: *Client, uri: std.Uri) ?Client.Request {
             return r;
         } else |err| {
             std.log.warn("{}. Retrying again [{}/5]", .{ err, i + 1 });
-            std.Thread.sleep(std.time.ns_per_ms * 500);
+            io.sleep(.fromMilliseconds(500), .awake) catch {};
         }
     }
     return null;

src/main.zig

@@ -15,12 +15,15 @@ const streql = common.streql;
 const CommonPaths = paths.CommonPaths;
 const Release = common.Release;
 const install = @import("install.zig");
+const Io = std.Io;
 
 pub const Version = "0.7.1";
 
 pub fn main() !void {
     var aa = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const alloc = aa.allocator();
+    var threaded = std.Io.Threaded.init(alloc);
+    const io = threaded.io();
 
     const command = try Cli.read_args(alloc);
 
@@ -35,36 +38,36 @@ pub fn main() !void {
                 std.process.exit(0);
             } else |_| {}
 
-            var client = Client{ .allocator = alloc };
+            var client = Client{ .allocator = alloc, .io = io };
             defer client.deinit();
 
-            const resp = try install.get_json_dslist(&client);
+            const resp = try install.get_json_dslist(io, &client);
             const releases = try json.parseFromSliceLeaky(json.Value, alloc, resp.body[0..resp.length], .{});
 
-            try install.install_release(alloc, &client, releases, &rel, cp);
+            try install.install_release(alloc, io, &client, releases, &rel, cp);
         },
         Cli.remove => |version| {
             const rel = try Release.releaseFromVersion(version);
             try remove_release(alloc, rel, cp);
         },
-        Cli.show => try show_info(alloc, cp),
-        Cli.std => |ver| try open_std(alloc, cp, ver),
-        Cli.reference => |ver| try open_reference(alloc, cp, ver),
+        Cli.show => try show_info(alloc, io, cp),
+        Cli.std => |ver| try open_std(alloc, io, cp, ver),
+        Cli.reference => |ver| try open_reference(alloc, io, cp, ver),
         Cli.override => |oa| {
             var override_args = oa;
             const rel = try Release.releaseFromVersion(override_args.version);
             if (override_args.directory != null and !streql(override_args.directory.?, "default")) {
                 override_args.directory = try std.fs.realpathAlloc(alloc, override_args.directory.?);
             }
             const directory = override_args.directory orelse try std.process.getCwdAlloc(alloc);
-            try override(alloc, cp, rel, directory);
+            try override(alloc, io, cp, rel, directory);
         },
         Cli.override_rm => |dir| {
             const directory = dir orelse try std.process.getCwdAlloc(alloc);
-            try override_rm(alloc, cp, directory);
+            try override_rm(alloc, io, cp, directory);
         },
-        Cli.update_self => try update_self.update_self(alloc, cp),
-        Cli.update => |version_possible| try update_zig_installation(alloc, cp, version_possible),
+        Cli.update_self => try update_self.update_self(alloc, io, cp),
+        Cli.update => |version_possible| try update_zig_installation(alloc, io, cp, version_possible),
     }
 }
 
@@ -79,13 +82,13 @@ fn remove_release(alloc: Allocator, rel: Release, cp: CommonPaths) !void {
     }
 }
 
-fn open_std(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
+fn open_std(alloc: Allocator, io: Io, cp: CommonPaths, ver: ?[]const u8) !void {
     var best_match: []const u8 = undefined;
     if (ver) |v| {
         best_match = v;
     } else {
         const dir_to_check = try std.process.getCwdAlloc(alloc);
-        var overrides = try common.overrides.read_overrides(alloc, cp);
+        var overrides = try common.overrides.read_overrides(alloc, io, cp);
         defer overrides.deinit();
 
         best_match = try alloc.dupe(u8, (try overrides.active_version(dir_to_check)).ver);
@@ -106,13 +109,13 @@ fn open_std(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
     std.process.exit(term.Exited);
 }
 
-fn open_reference(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
+fn open_reference(alloc: Allocator, io: Io, cp: CommonPaths, ver: ?[]const u8) !void {
     var best_match: []const u8 = undefined;
     if (ver) |v| {
         best_match = v;
     } else {
         const dir_to_check = try std.process.getCwdAlloc(alloc);
-        var overrides = try common.overrides.read_overrides(alloc, cp);
+        var overrides = try common.overrides.read_overrides(alloc, io, cp);
         defer overrides.deinit();
 
         best_match = try alloc.dupe(u8, (try overrides.active_version(dir_to_check)).ver);
@@ -139,12 +142,12 @@ fn open_reference(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
     try child.spawn();
 }
 
-fn show_info(alloc: Allocator, cp: CommonPaths) !void {
+fn show_info(alloc: Allocator, io: Io, cp: CommonPaths) !void {
     std.debug.print("zigverm root:\t{s}\n\n", .{CommonPaths.get_zigverm_root()});
     var iter = cp.install_dir.iterate();
 
     const dir_to_check = try std.process.getCwdAlloc(alloc);
-    var overrides = try common.overrides.read_overrides(alloc, cp);
+    var overrides = try common.overrides.read_overrides(alloc, io, cp);
     defer overrides.deinit();
 
     const active_version = (try overrides.active_version(dir_to_check));
@@ -162,8 +165,8 @@ fn show_info(alloc: Allocator, cp: CommonPaths) !void {
     }
 }
 
-fn override(alloc: Allocator, cp: CommonPaths, rel: Release, directory: []const u8) !void {
-    var overrides = try common.overrides.read_overrides(alloc, cp);
+fn override(alloc: Allocator, io: Io, cp: CommonPaths, rel: Release, directory: []const u8) !void {
+    var overrides = try common.overrides.read_overrides(alloc, io, cp);
     defer overrides.deinit();
     var actual_dir: []const u8 = undefined;
 
@@ -178,12 +181,12 @@ fn override(alloc: Allocator, cp: CommonPaths, rel: Release, directory: []const
     try common.overrides.write_overrides(overrides, cp);
 }
 
-fn override_rm(alloc: Allocator, cp: CommonPaths, directory: []const u8) !void {
+fn override_rm(alloc: Allocator, io: Io, cp: CommonPaths, directory: []const u8) !void {
     if (streql(directory, "default")) {
         std.log.err("cannot remove the default override", .{});
         std.process.exit(1);
     }
-    var overrides = try common.overrides.read_overrides(alloc, cp);
+    var overrides = try common.overrides.read_overrides(alloc, io, cp);
     defer overrides.deinit();
     var actual_dir: []const u8 = undefined;
     if (streql(directory, "default"))
@@ -232,17 +235,17 @@ fn get_version_from_exe(alloc: Allocator, release_name: []const u8) !std.ArrayLi
     return version;
 }
 
-fn update_zig_installation(alloc: Allocator, cp: CommonPaths, version_possible: ?[]const u8) !void {
+fn update_zig_installation(alloc: Allocator, io: Io, cp: CommonPaths, version_possible: ?[]const u8) !void {
     var versions: [][]const u8 = undefined;
     if (version_possible) |v| {
         versions = @constCast(&[1][]const u8{v});
     } else versions = try installed_versions(alloc, cp);
 
     var updated_now: std.ArrayList([]const u8) = .empty;
     var already_update: std.ArrayList([]const u8) = .empty;
-    var client = Client{ .allocator = alloc };
+    var client = Client{ .allocator = alloc, .io = io };
     defer client.deinit();
-    const resp = try install.get_json_dslist(&client);
+    const resp = try install.get_json_dslist(io, &client);
     const releases = try json.parseFromSliceLeaky(json.Value, alloc, resp.body[0..resp.length], .{});
 
     for (versions) |v| {
@@ -282,12 +285,12 @@ fn update_zig_installation(alloc: Allocator, cp: CommonPaths, version_possible:
             }
             if (to_update) {
                 try updated_now.append(alloc, v);
-                try install.install_release(alloc, &client, releases, &rel, cp);
+                try install.install_release(alloc, io, &client, releases, &rel, cp);
             } else {
                 try already_update.append(alloc, v);
             }
         } else |_| {
-            try install.install_release(alloc, &client, releases, &rel, cp);
+            try install.install_release(alloc, io, &client, releases, &rel, cp);
         }
     }
     std.debug.print("\n", .{});

src/update-self.zig

@@ -11,6 +11,7 @@ const CommonPaths = common.paths.CommonPaths;
 const Client = std.http.Client;
 const File = std.fs.File;
 const Allocator = std.mem.Allocator;
+const Io = std.Io;
 
 const DownloadTarball = struct {
     filename: []const u8,
@@ -38,12 +39,12 @@ const DownloadTarball = struct {
     }
 };
 
-pub fn update_self(alloc: Allocator, cp: CommonPaths) !void {
-    var client = Client{ .allocator = alloc };
+pub fn update_self(alloc: Allocator, io: Io, cp: CommonPaths) !void {
+    var client = Client{ .allocator = alloc, .io = io };
     defer client.deinit();
 
     std.log.info("getting latest index from github releases", .{});
-    const parsed = try read_github_releases_data(alloc, &client);
+    const parsed = try read_github_releases_data(alloc, io, &client);
 
     defer parsed.deinit();
 
@@ -70,11 +71,11 @@ pub fn update_self(alloc: Allocator, cp: CommonPaths) !void {
     try download_tarball.createDownloadFile(cp);
     defer download_tarball.deinit() catch {};
     if (download_tarball.file_size < download_tarball.actual_size)
-        try install.download_tarball(alloc, &client, download_tarball.url, &download_tarball.writer.?, download_tarball.file_size, download_tarball.actual_size);
+        try install.download_tarball(alloc, io, &client, download_tarball.url, &download_tarball.writer.?, download_tarball.file_size, download_tarball.actual_size);
     try download_tarball.file_handle.?.seekTo(0);
 
     var buf: [4096]u8 = undefined;
-    var src = File.Reader.init(download_tarball.file_handle.?, &buf);
+    var src = download_tarball.file_handle.?.reader(io, &buf);
 
     var zipfile = try ZipArchive.openFromFileReader(alloc, &src);
     defer zipfile.close();
@@ -109,9 +110,9 @@ fn writeZipMember(zipfile: ZipArchive, path: []const u8, cp: CommonPaths) !void
     }
 }
 
-fn read_github_releases_data(alloc: Allocator, client: *Client) !json.Parsed(json.Value) {
+fn read_github_releases_data(alloc: Allocator, io: Io, client: *Client) !json.Parsed(json.Value) {
     const uri = try std.Uri.parse("https://api.github.com/repos/AMythicDev/zigverm/releases/latest");
-    var req = install.make_request(client, uri);
+    var req = install.make_request(client, io, uri);
     defer req.?.deinit();
 
     if (req == null) {