tricu

io_v2_paths.zig (5821B)

---

 //! Private synchronous path operations. Observations do not pin subsequent path
 //! operations. OS process authority, no grants, sandbox or implicit rollback.
 const std = @import("std");
 const F = @import("io_v2_files.zig");
 const c = @cImport({
     @cUndef("_FORTIFY_SOURCE");
     @cDefine("_FORTIFY_SOURCE", "0");
     @cInclude("uv.h");
     @cInclude("sys/stat.h");
     @cInclude("fcntl.h");
 });
 pub const Error = F.Error || error{NotDirectory};
 pub const Info = union(enum) { regular: u64, directory, symlink, other };
 pub const Mutation = enum { create_directory, remove_directory, remove_file, rename };
 fn valid(path: [:0]const u8) Error!void {
     if (path.len == 0 or std.mem.indexOfScalar(u8, path, 0) != null or !std.unicode.utf8ValidateSlice(path)) return error.InvalidArgument;
 }
 fn checked(status: *F.Status, code: c_int) Error!void {
     if (code < 0) {
         status.code = code;
         return error.HostFailure;
     }
 }
 pub fn stat(status: *F.Status, path: [:0]const u8, follow: bool) Error!Info {
     status.* = .{};
     try valid(path);
     var req: c.uv_fs_t = undefined;
     const rc = if (follow) c.uv_fs_stat(null, &req, path.ptr, null) else c.uv_fs_lstat(null, &req, path.ptr, null);
     defer c.uv_fs_req_cleanup(&req);
     try checked(status, rc);
     return switch (req.statbuf.st_mode & c.S_IFMT) {
         c.S_IFREG => if (req.statbuf.st_size <= F.limit) .{ .regular = req.statbuf.st_size } else error.InvalidBound,
         c.S_IFDIR => .directory,
         c.S_IFLNK => .symlink,
         else => .other,
     };
 }
 pub fn mutate(status: *F.Status, op: Mutation, path: [:0]const u8, destination: ?[:0]const u8) Error!void {
     status.* = .{};
     try valid(path);
     if (op == .rename) try valid(destination orelse return error.InvalidArgument);
     var req: c.uv_fs_t = undefined;
     const rc = switch (op) {
         .create_directory => c.uv_fs_mkdir(null, &req, path.ptr, 0o777, null),
         .remove_directory => c.uv_fs_rmdir(null, &req, path.ptr, null),
         .remove_file => c.uv_fs_unlink(null, &req, path.ptr, null),
         .rename => c.uv_fs_rename(null, &req, path.ptr, destination.?.ptr, null),
     };
     defer c.uv_fs_req_cleanup(&req);
     try checked(status, rc);
 }
 pub fn syncDirectory(status: *F.Status, path: [:0]const u8) Error!void {
     status.* = .{};
     try valid(path);
     var req: c.uv_fs_t = undefined;
     // NONBLOCK plus O_DIRECTORY avoids opening a FIFO while waiting for peers.
     const fd = c.uv_fs_open(null, &req, path.ptr, c.O_RDONLY | c.O_NONBLOCK | c.O_DIRECTORY | c.O_CLOEXEC | c.O_NOCTTY, 0, null);
     c.uv_fs_req_cleanup(&req);
     if (fd == c.UV_ENOTDIR) return error.NotDirectory;
     try checked(status, fd);
     // Close exactly once on every path; retain a primary sync/fstat error.
     const rc = c.uv_fs_fstat(null, &req, fd, null);
     const is_directory = rc >= 0 and req.statbuf.st_mode & c.S_IFMT == c.S_IFDIR;
     c.uv_fs_req_cleanup(&req);
     const synced = if (is_directory) blk: {
         const result = c.uv_fs_fsync(null, &req, fd, null);
         c.uv_fs_req_cleanup(&req);
         break :blk result;
     } else 0;
     const closed = c.uv_fs_close(null, &req, fd, null);
     c.uv_fs_req_cleanup(&req);
     if (closed < 0) status.cleanup_code = closed;
     try checked(status, rc);
     if (!is_directory) return error.NotDirectory;
     try checked(status, synced);
     try checked(status, closed);
 }
 
 test "path observations, explicit symlink following, rename/unlink and directory durability" {
     const t = std.testing;
     var tmp = t.tmpDir(.{});
     defer tmp.cleanup();
     const base = try tmp.dir.realPathFileAlloc(t.io, ".", t.allocator);
     defer t.allocator.free(base);
     const dir = try std.fmt.allocPrintSentinel(t.allocator, "{s}/dir", .{base}, 0);
     defer t.allocator.free(dir);
     const source = try std.fmt.allocPrintSentinel(t.allocator, "{s}/file", .{base}, 0);
     defer t.allocator.free(source);
     const target = try std.fmt.allocPrintSentinel(t.allocator, "{s}/dir/file", .{base}, 0);
     defer t.allocator.free(target);
     const link = try std.fmt.allocPrintSentinel(t.allocator, "{s}/link", .{base}, 0);
     defer t.allocator.free(link);
     var status: F.Status = .{};
     try mutate(&status, .create_directory, dir, null);
     try t.expect(try stat(&status, dir, true) == .directory);
     try t.expectError(error.HostFailure, mutate(&status, .create_directory, dir, null));
     try t.expectEqualStrings("already-exists", F.errorCategory(status.code));
     var file = try F.open(&status, source, .writer);
     defer file.close(&status) catch {};
     _ = try file.write(&status, "abc");
     var req: c.uv_fs_t = undefined;
     const linked = c.uv_fs_symlink(null, &req, source.ptr, link.ptr, 0, null);
     c.uv_fs_req_cleanup(&req);
     try t.expectEqual(@as(c_int, 0), linked);
     try t.expect(try stat(&status, link, false) == .symlink);
     try t.expectEqual(@as(u64, 3), (try stat(&status, link, true)).regular);
     try mutate(&status, .rename, source, target);
     try t.expectError(error.HostFailure, stat(&status, source, true));
     try t.expectEqualStrings("not-found", F.errorCategory(status.code));
     try t.expectEqual(@as(u64, 3), (try stat(&status, target, true)).regular);
     try syncDirectory(&status, dir);
     try t.expectError(error.NotDirectory, syncDirectory(&status, target));
     try t.expectError(error.HostFailure, mutate(&status, .remove_directory, dir, null));
     try mutate(&status, .remove_file, target, null);
     try mutate(&status, .remove_directory, dir, null);
     try mutate(&status, .remove_file, link, null);
     try t.expectError(error.InvalidArgument, mutate(&status, .rename, source, null));
     try t.expectError(error.InvalidArgument, stat(&status, "x\x00y", true));
     try t.expectError(error.InvalidArgument, syncDirectory(&status, ""));
 }