DoxigAlpha
std › fs.Dir › updateFile

updateFile

Check the file size, mtime, and mode of source_path and dest_path. If they are equal, does nothing. Otherwise, atomically copies source_path to dest_path. The destination file gains the mtime, atime, and mode of the source file so that the next call to updateFile will not need a copy. Returns the previous status of the file before updating. If any of the directories do not exist for dest_path, they are created. On Windows, both paths should be encoded as WTF-8. On WASI, both paths should be encoded as valid UTF-8. On other platforms, both paths are an opaque sequence of bytes with no particular encoding.

Function parameters

Parameters

#
source_path:[]const u8
dest_path:[]const u8

Type definitions in this namespace

Types

#
SymLinkFlags
Use with `Dir.symLink`, `Dir.atomicSymLink`, and `symLinkAbsolute` to

Functions in this namespace

Functions

#
iterateAssumeFirstIteration
Like `iterate`, but will not reset the directory cursor before the first
walk
Recursively iterates over a directory.
openFile
Opens a file for reading or writing, without attempting to create a new file.
openFileZ
Same as `openFile` but the path parameter is null-terminated.
openFileW
Same as `openFile` but Windows-only and the path parameter is
createFile
Creates, opens, or overwrites a file with write access.
createFileZ
Same as `createFile` but the path parameter is null-terminated.
createFileW
Same as `createFile` but Windows-only and the path parameter is
makeDir
Creates a single directory with a relative or absolute path.
makeDirZ
Same as `makeDir`, but `sub_path` is null-terminated.
makeDirW
Creates a single directory with a relative or absolute null-terminated WTF-16 LE-encoded path.
makePath
Calls makeDir iteratively to make an entire path
makePathStatus
Same as `makePath` except returns whether the path already existed or was successfully created.
makeOpenPath
This function performs `makePath`, followed by `openDir`.
realpath
This function returns the canonicalized absolute pathname of
realpathZ
Same as `Dir.realpath` except `pathname` is null-terminated.
realpathW
Windows-only.
realpathAlloc
Same as `Dir.realpath` except caller must free the returned memory.
setAsCwd
Changes the current working directory to the open directory handle.
openDir
Opens a directory at the given path.
openDirZ
Same as `openDir` except the parameter is null-terminated.
openDirW
Same as `openDir` except the path parameter is WTF-16 LE encoded, NT-prefixed.
deleteFile
Delete a file name and possibly the file it refers to, based on an open directory handle.
deleteFileZ
Same as `deleteFile` except the parameter is null-terminated.
deleteFileW
Same as `deleteFile` except the parameter is WTF-16 LE encoded.
deleteDir
Returns `error.DirNotEmpty` if the directory is not empty.
deleteDirZ
Same as `deleteDir` except the parameter is null-terminated.
deleteDirW
Same as `deleteDir` except the parameter is WTF16LE, NT prefixed.
rename
Change the name or location of a file or directory.
renameZ
Same as `rename` except the parameters are null-terminated.
renameW
Same as `rename` except the parameters are WTF16LE, NT prefixed.
symLink
Creates a symbolic link named `sym_link_path` which contains the string `target_path`.
symLinkWasi
WASI-only.
symLinkZ
Same as `symLink`, except the pathname parameters are null-terminated.
symLinkW
Windows-only.
atomicSymLink
Same as `symLink`, except tries to create the symbolic link until it
readLink
Read value of a symbolic link.
readLinkWasi
WASI-only.
readLinkZ
Same as `readLink`, except the `sub_path_c` parameter is null-terminated.
readLinkW
Windows-only.
readFile
Read all of file contents using a preallocated buffer.
readFileAlloc
On success, caller owns returned buffer.
readFileAllocOptions
On success, caller owns returned buffer.
deleteTree
Whether `sub_path` describes a symlink, file, or directory, this function
deleteTreeMinStackSize
Like `deleteTree`, but only keeps one `Iterator` active at a time to minimize the function's stack size.
writeFile
Writes content to the file system, using the file creation flags provided.
access
Test accessing `sub_path`.
accessZ
Same as `access` except the path parameter is null-terminated.
accessW
Same as `access` except asserts the target OS is Windows and the path parameter is
updateFile
Check the file size, mtime, and mode of `source_path` and `dest_path`.
copyFile
Atomically creates a new file at `dest_path` within `dest_dir` with the
atomicFile
Directly access the `.file` field, and then call `AtomicFile.finish` to
statFile
Returns metadata for a file inside the directory.
chmod
Changes the mode of the directory.
chown
Changes the owner and group of the directory.
setPermissions
Sets permissions according to the provided `Permissions` struct.

Error sets in this namespace

Error Sets

#

= posix.fd_t

Values

#
Handle
= posix.fd_t

Source

Implementation

#
pub fn updateFile(
    source_dir: Dir,
    source_path: []const u8,
    dest_dir: Dir,
    dest_path: []const u8,
    options: CopyFileOptions,
) !PrevStatus {
    var src_file = try source_dir.openFile(source_path, .{});
    defer src_file.close();

    const src_stat = try src_file.stat();
    const actual_mode = options.override_mode orelse src_stat.mode;
    check_dest_stat: {
        const dest_stat = blk: {
            var dest_file = dest_dir.openFile(dest_path, .{}) catch |err| switch (err) {
                error.FileNotFound => break :check_dest_stat,
                else => |e| return e,
            };
            defer dest_file.close();

            break :blk try dest_file.stat();
        };

        if (src_stat.size == dest_stat.size and
            src_stat.mtime == dest_stat.mtime and
            actual_mode == dest_stat.mode)
        {
            return PrevStatus.fresh;
        }
    }

    if (fs.path.dirname(dest_path)) |dirname| {
        try dest_dir.makePath(dirname);
    }

    var buffer: [1000]u8 = undefined; // Used only when direct fd-to-fd is not available.
    var atomic_file = try dest_dir.atomicFile(dest_path, .{
        .mode = actual_mode,
        .write_buffer = &buffer,
    });
    defer atomic_file.deinit();

    var src_reader: File.Reader = .initSize(src_file, &.{}, src_stat.size);
    const dest_writer = &atomic_file.file_writer.interface;

    _ = dest_writer.sendFileAll(&src_reader, .unlimited) catch |err| switch (err) {
        error.ReadFailed => return src_reader.err.?,
        error.WriteFailed => return atomic_file.file_writer.err.?,
    };
    try atomic_file.flush();
    try atomic_file.file_writer.file.updateTimes(src_stat.atime, src_stat.mtime);
    try atomic_file.renameIntoPlace();
    return .stale;
}