mirror of
https://github.com/oven-sh/bun
synced 2026-02-10 10:58:56 +00:00
73a55cf075
* run-eval.test.ts * transpiler-cache.test.ts * node net * some open things * a * a * yikes * incredible * run it back * a * this code is what i like to call, incorrect * ok its all worng * remove an assertion that is wrong again * update test things and rebase * performance test * mark filesink with mkfifo as todo. see #8166 * hehe * not done * awa * fs test pass --------- Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com> Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
6728 lines
248 KiB
Zig
6728 lines
248 KiB
Zig
// This file contains the underlying implementation for sync & async functions
|
|
// for interacting with the filesystem from JavaScript.
|
|
// The top-level functions assume the arguments are already validated
|
|
const std = @import("std");
|
|
const bun = @import("root").bun;
|
|
const strings = bun.strings;
|
|
const windows = bun.windows;
|
|
const string = bun.string;
|
|
const JSC = @import("root").bun.JSC;
|
|
const PathString = JSC.PathString;
|
|
const Environment = bun.Environment;
|
|
const C = bun.C;
|
|
const Flavor = JSC.Node.Flavor;
|
|
const system = std.os.system;
|
|
const Maybe = JSC.Maybe;
|
|
const Encoding = JSC.Node.Encoding;
|
|
const PosixToWinNormalizer = bun.path.PosixToWinNormalizer;
|
|
|
|
const FileDescriptor = bun.FileDescriptor;
|
|
const FDImpl = bun.FDImpl;
|
|
|
|
const Syscall = if (Environment.isWindows) bun.sys.sys_uv else bun.sys;
|
|
|
|
const Constants = @import("./node_fs_constant.zig").Constants;
|
|
const builtin = @import("builtin");
|
|
const os = @import("std").os;
|
|
const darwin = os.darwin;
|
|
const linux = os.linux;
|
|
const PathLike = JSC.Node.PathLike;
|
|
const PathOrFileDescriptor = JSC.Node.PathOrFileDescriptor;
|
|
const DirIterator = @import("./dir_iterator.zig");
|
|
const Path = @import("../../resolver/resolve_path.zig");
|
|
const FileSystem = @import("../../fs.zig").FileSystem;
|
|
const ArgumentsSlice = JSC.Node.ArgumentsSlice;
|
|
const TimeLike = JSC.Node.TimeLike;
|
|
const Mode = bun.Mode;
|
|
const uv = bun.windows.libuv;
|
|
const E = C.E;
|
|
const uid_t = if (Environment.isPosix) std.os.uid_t else bun.windows.libuv.uv_uid_t;
|
|
const gid_t = if (Environment.isPosix) std.os.gid_t else bun.windows.libuv.uv_gid_t;
|
|
/// u63 to allow one null bit
|
|
const ReadPosition = i64;
|
|
|
|
const Stats = JSC.Node.Stats;
|
|
const Dirent = JSC.Node.Dirent;
|
|
|
|
pub const default_permission = if (Environment.isPosix)
|
|
Syscall.S.IRUSR |
|
|
Syscall.S.IWUSR |
|
|
Syscall.S.IRGRP |
|
|
Syscall.S.IWGRP |
|
|
Syscall.S.IROTH |
|
|
Syscall.S.IWOTH
|
|
else
|
|
// TODO:
|
|
0;
|
|
|
|
const StringOrBuffer = JSC.Node.StringOrBuffer;
|
|
const ArrayBuffer = JSC.MarkedArrayBuffer;
|
|
const Buffer = JSC.Buffer;
|
|
const FileSystemFlags = JSC.Node.FileSystemFlags;
|
|
pub const Async = struct {
|
|
pub const access = NewAsyncFSTask(Return.Access, Arguments.Access, NodeFS.access);
|
|
pub const appendFile = NewAsyncFSTask(Return.AppendFile, Arguments.AppendFile, NodeFS.appendFile);
|
|
pub const chmod = NewAsyncFSTask(Return.Chmod, Arguments.Chmod, NodeFS.chmod);
|
|
pub const chown = NewAsyncFSTask(Return.Chown, Arguments.Chown, NodeFS.chown);
|
|
pub const close = NewAsyncFSTask(Return.Close, Arguments.Close, NodeFS.close);
|
|
pub const copyFile = NewAsyncFSTask(Return.CopyFile, Arguments.CopyFile, NodeFS.copyFile);
|
|
pub const exists = NewAsyncFSTask(Return.Exists, Arguments.Exists, NodeFS.exists);
|
|
pub const fchmod = NewAsyncFSTask(Return.Fchmod, Arguments.FChmod, NodeFS.fchmod);
|
|
pub const fchown = NewAsyncFSTask(Return.Fchown, Arguments.Fchown, NodeFS.fchown);
|
|
pub const fdatasync = NewAsyncFSTask(Return.Fdatasync, Arguments.FdataSync, NodeFS.fdatasync);
|
|
pub const fstat = NewAsyncFSTask(Return.Fstat, Arguments.Fstat, NodeFS.fstat);
|
|
pub const fsync = NewAsyncFSTask(Return.Fsync, Arguments.Fsync, NodeFS.fsync);
|
|
pub const ftruncate = NewAsyncFSTask(Return.Ftruncate, Arguments.FTruncate, NodeFS.ftruncate);
|
|
pub const futimes = NewAsyncFSTask(Return.Futimes, Arguments.Futimes, NodeFS.futimes);
|
|
pub const lchmod = NewAsyncFSTask(Return.Lchmod, Arguments.LCHmod, NodeFS.lchmod);
|
|
pub const lchown = NewAsyncFSTask(Return.Lchown, Arguments.LChown, NodeFS.lchown);
|
|
pub const link = NewAsyncFSTask(Return.Link, Arguments.Link, NodeFS.link);
|
|
pub const lstat = NewAsyncFSTask(Return.Stat, Arguments.Stat, NodeFS.lstat);
|
|
pub const lutimes = NewAsyncFSTask(Return.Lutimes, Arguments.Lutimes, NodeFS.lutimes);
|
|
pub const mkdir = NewAsyncFSTask(Return.Mkdir, Arguments.Mkdir, NodeFS.mkdir);
|
|
pub const mkdtemp = NewAsyncFSTask(Return.Mkdtemp, Arguments.MkdirTemp, NodeFS.mkdtemp);
|
|
pub const open = NewAsyncFSTask(Return.Open, Arguments.Open, NodeFS.open);
|
|
pub const read = NewAsyncFSTask(Return.Read, Arguments.Read, NodeFS.read);
|
|
pub const readdir = NewAsyncFSTask(Return.Readdir, Arguments.Readdir, NodeFS.readdir);
|
|
pub const readFile = NewAsyncFSTask(Return.ReadFile, Arguments.ReadFile, NodeFS.readFile);
|
|
pub const readlink = NewAsyncFSTask(Return.Readlink, Arguments.Readlink, NodeFS.readlink);
|
|
pub const readv = NewAsyncFSTask(Return.Readv, Arguments.Readv, NodeFS.readv);
|
|
pub const realpath = NewAsyncFSTask(Return.Realpath, Arguments.Realpath, NodeFS.realpath);
|
|
pub const rename = NewAsyncFSTask(Return.Rename, Arguments.Rename, NodeFS.rename);
|
|
pub const rm = NewAsyncFSTask(Return.Rm, Arguments.Rm, NodeFS.rm);
|
|
pub const rmdir = NewAsyncFSTask(Return.Rmdir, Arguments.RmDir, NodeFS.rmdir);
|
|
pub const stat = NewAsyncFSTask(Return.Stat, Arguments.Stat, NodeFS.stat);
|
|
pub const symlink = NewAsyncFSTask(Return.Symlink, Arguments.Symlink, NodeFS.symlink);
|
|
pub const truncate = NewAsyncFSTask(Return.Truncate, Arguments.Truncate, NodeFS.truncate);
|
|
pub const unlink = NewAsyncFSTask(Return.Unlink, Arguments.Unlink, NodeFS.unlink);
|
|
pub const utimes = NewAsyncFSTask(Return.Utimes, Arguments.Utimes, NodeFS.utimes);
|
|
pub const write = NewAsyncFSTask(Return.Write, Arguments.Write, NodeFS.write);
|
|
pub const writeFile = NewAsyncFSTask(Return.WriteFile, Arguments.WriteFile, NodeFS.writeFile);
|
|
pub const writev = NewAsyncFSTask(Return.Writev, Arguments.Writev, NodeFS.writev);
|
|
|
|
pub const cp = AsyncCpTask;
|
|
|
|
pub const readdir_recursive = AsyncReaddirRecursiveTask;
|
|
|
|
/// Used internally. Not from JavaScript.
|
|
pub const AsyncMkdirp = struct {
|
|
completion_ctx: *anyopaque,
|
|
completion: *const fn (*anyopaque, JSC.Maybe(void)) void,
|
|
|
|
/// Memory is not owned by this struct
|
|
path: []const u8,
|
|
|
|
task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
|
|
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub fn workPoolCallback(task: *JSC.WorkPoolTask) void {
|
|
var this: *AsyncMkdirp = @fieldParentPtr(AsyncMkdirp, "task", task);
|
|
|
|
var node_fs = NodeFS{};
|
|
const result = node_fs.mkdirRecursive(
|
|
Arguments.Mkdir{
|
|
.path = PathLike{ .string = PathString.init(this.path) },
|
|
.recursive = true,
|
|
},
|
|
.sync,
|
|
);
|
|
switch (result) {
|
|
.err => |err| {
|
|
this.completion(this.completion_ctx, .{ .err = err.withPath(bun.default_allocator.dupe(u8, err.path) catch bun.outOfMemory()) });
|
|
},
|
|
.result => {
|
|
this.completion(this.completion_ctx, JSC.Maybe(void).success);
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn schedule(this: *AsyncMkdirp) void {
|
|
JSC.WorkPool.schedule(&this.task);
|
|
}
|
|
};
|
|
|
|
fn NewAsyncFSTask(comptime ReturnType: type, comptime ArgumentType: type, comptime Function: anytype) type {
|
|
return struct {
|
|
promise: JSC.JSPromise.Strong,
|
|
args: ArgumentType,
|
|
globalObject: *JSC.JSGlobalObject,
|
|
task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
|
|
result: JSC.Maybe(ReturnType),
|
|
ref: bun.Async.KeepAlive = .{},
|
|
tracker: JSC.AsyncTaskTracker,
|
|
|
|
pub const Task = @This();
|
|
|
|
pub const heap_label = "Async" ++ bun.meta.typeBaseName(@typeName(ArgumentType)) ++ "Task";
|
|
|
|
pub fn create(
|
|
globalObject: *JSC.JSGlobalObject,
|
|
args: ArgumentType,
|
|
vm: *JSC.VirtualMachine,
|
|
) JSC.JSValue {
|
|
var task = bun.new(
|
|
Task,
|
|
Task{
|
|
.promise = JSC.JSPromise.Strong.init(globalObject),
|
|
.args = args,
|
|
.result = undefined,
|
|
.globalObject = globalObject,
|
|
.tracker = JSC.AsyncTaskTracker.init(vm),
|
|
},
|
|
);
|
|
task.ref.ref(vm);
|
|
task.args.toThreadSafe();
|
|
task.tracker.didSchedule(globalObject);
|
|
JSC.WorkPool.schedule(&task.task);
|
|
|
|
return task.promise.value();
|
|
}
|
|
|
|
fn workPoolCallback(task: *JSC.WorkPoolTask) void {
|
|
var this: *Task = @fieldParentPtr(Task, "task", task);
|
|
|
|
var node_fs = NodeFS{};
|
|
this.result = Function(&node_fs, this.args, .promise);
|
|
|
|
if (this.result == .err) {
|
|
this.result.err.path = bun.default_allocator.dupe(u8, this.result.err.path) catch "";
|
|
std.mem.doNotOptimizeAway(&node_fs);
|
|
}
|
|
|
|
this.globalObject.bunVMConcurrently().eventLoop().enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this)));
|
|
}
|
|
|
|
pub fn runFromJSThread(this: *Task) void {
|
|
const globalObject = this.globalObject;
|
|
var success = @as(JSC.Maybe(ReturnType).Tag, this.result) == .result;
|
|
const result = switch (this.result) {
|
|
.err => |err| err.toJSC(globalObject),
|
|
.result => |*res| brk: {
|
|
const out = globalObject.toJS(res, .temporary);
|
|
success = out != .zero;
|
|
|
|
break :brk out;
|
|
},
|
|
};
|
|
var promise_value = this.promise.value();
|
|
var promise = this.promise.get();
|
|
promise_value.ensureStillAlive();
|
|
|
|
const tracker = this.tracker;
|
|
tracker.willDispatch(globalObject);
|
|
defer tracker.didDispatch(globalObject);
|
|
|
|
this.deinit();
|
|
switch (success) {
|
|
false => {
|
|
promise.reject(globalObject, result);
|
|
},
|
|
true => {
|
|
promise.resolve(globalObject, result);
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn deinit(this: *Task) void {
|
|
if (this.result == .err) {
|
|
bun.default_allocator.free(this.result.err.path);
|
|
}
|
|
|
|
this.ref.unref(this.globalObject.bunVM());
|
|
if (@hasDecl(ArgumentType, "deinitAndUnprotect")) {
|
|
this.args.deinitAndUnprotect();
|
|
} else {
|
|
this.args.deinit();
|
|
}
|
|
this.promise.strong.deinit();
|
|
bun.destroy(this);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const AsyncCpTask = struct {
|
|
promise: JSC.JSPromise.Strong,
|
|
args: Arguments.Cp,
|
|
globalObject: *JSC.JSGlobalObject,
|
|
task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
|
|
result: JSC.Maybe(Return.Cp),
|
|
ref: bun.Async.KeepAlive = .{},
|
|
arena: bun.ArenaAllocator,
|
|
tracker: JSC.AsyncTaskTracker,
|
|
has_result: std.atomic.Value(bool),
|
|
/// On each creation of a `AsyncCpSingleFileTask`, this is incremented.
|
|
/// When each task is finished, decrement.
|
|
/// The maintask thread starts this at 1 and decrements it at the end, to avoid the promise being resolved while new tasks may be added.
|
|
subtask_count: std.atomic.Value(usize),
|
|
|
|
pub fn create(
|
|
globalObject: *JSC.JSGlobalObject,
|
|
cp_args: Arguments.Cp,
|
|
vm: *JSC.VirtualMachine,
|
|
arena: bun.ArenaAllocator,
|
|
) JSC.JSValue {
|
|
var task = bun.new(
|
|
AsyncCpTask,
|
|
AsyncCpTask{
|
|
.promise = JSC.JSPromise.Strong.init(globalObject),
|
|
.args = cp_args,
|
|
.has_result = .{ .raw = false },
|
|
.result = undefined,
|
|
.globalObject = globalObject,
|
|
.tracker = JSC.AsyncTaskTracker.init(vm),
|
|
.arena = arena,
|
|
.subtask_count = .{ .raw = 1 },
|
|
},
|
|
);
|
|
task.ref.ref(vm);
|
|
task.args.src.toThreadSafe();
|
|
task.args.dest.toThreadSafe();
|
|
task.tracker.didSchedule(globalObject);
|
|
|
|
JSC.WorkPool.schedule(&task.task);
|
|
|
|
return task.promise.value();
|
|
}
|
|
|
|
fn workPoolCallback(task: *JSC.WorkPoolTask) void {
|
|
const this: *AsyncCpTask = @fieldParentPtr(AsyncCpTask, "task", task);
|
|
|
|
var node_fs = NodeFS{};
|
|
node_fs.cpAsync(this);
|
|
}
|
|
|
|
/// May be called from any thread (the subtasks)
|
|
fn finishConcurrently(this: *AsyncCpTask, result: Maybe(Return.Cp)) void {
|
|
if (this.has_result.cmpxchgStrong(false, true, .Monotonic, .Monotonic)) |_| {
|
|
return;
|
|
}
|
|
|
|
this.result = result;
|
|
|
|
if (this.result == .err) {
|
|
this.result.err.path = bun.default_allocator.dupe(u8, this.result.err.path) catch "";
|
|
}
|
|
|
|
this.globalObject.bunVMConcurrently().eventLoop().enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(this, runFromJSThread));
|
|
}
|
|
|
|
fn runFromJSThread(this: *AsyncCpTask) void {
|
|
const globalObject = this.globalObject;
|
|
var success = @as(JSC.Maybe(Return.Cp).Tag, this.result) == .result;
|
|
const result = switch (this.result) {
|
|
.err => |err| err.toJSC(globalObject),
|
|
.result => |*res| brk: {
|
|
const out = globalObject.toJS(res, .temporary);
|
|
success = out != .zero;
|
|
|
|
break :brk out;
|
|
},
|
|
};
|
|
var promise_value = this.promise.value();
|
|
var promise = this.promise.get();
|
|
promise_value.ensureStillAlive();
|
|
|
|
const tracker = this.tracker;
|
|
tracker.willDispatch(globalObject);
|
|
defer tracker.didDispatch(globalObject);
|
|
|
|
this.deinit();
|
|
switch (success) {
|
|
false => {
|
|
promise.reject(globalObject, result);
|
|
},
|
|
true => {
|
|
promise.resolve(globalObject, result);
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn deinit(this: *AsyncCpTask) void {
|
|
this.ref.unref(this.globalObject.bunVM());
|
|
this.args.deinit();
|
|
this.promise.strong.deinit();
|
|
this.arena.deinit();
|
|
bun.destroy(this);
|
|
}
|
|
};
|
|
|
|
pub const AsyncReaddirRecursiveTask = struct {
|
|
promise: JSC.JSPromise.Strong,
|
|
args: Arguments.Readdir,
|
|
globalObject: *JSC.JSGlobalObject,
|
|
task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
|
|
ref: bun.Async.KeepAlive = .{},
|
|
tracker: JSC.AsyncTaskTracker,
|
|
|
|
// It's not 100% clear this one is necessary
|
|
has_result: std.atomic.Value(bool),
|
|
|
|
subtask_count: std.atomic.Value(usize),
|
|
|
|
/// The final result list
|
|
result_list: ResultListEntry.Value = undefined,
|
|
|
|
/// When joining the result list, we use this to preallocate the joined array.
|
|
result_list_count: std.atomic.Value(usize) = std.atomic.Value(usize).init(0),
|
|
|
|
/// A lockless queue of result lists.
|
|
///
|
|
/// Using a lockless queue instead of mutex + joining the lists as we go was a meaningful performance improvement
|
|
result_list_queue: ResultListEntry.Queue = ResultListEntry.Queue{},
|
|
|
|
/// All the subtasks will use this fd to open files
|
|
root_fd: FileDescriptor = bun.invalid_fd,
|
|
|
|
/// This isued when joining the file paths for error messages
|
|
root_path: PathString = PathString.empty,
|
|
|
|
pending_err: ?Syscall.Error = null,
|
|
pending_err_mutex: bun.Lock = bun.Lock.init(),
|
|
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub const ResultListEntry = struct {
|
|
pub const Value = union(Return.Readdir.Tag) {
|
|
with_file_types: std.ArrayList(Dirent),
|
|
buffers: std.ArrayList(Buffer),
|
|
files: std.ArrayList(bun.String),
|
|
|
|
pub fn deinit(this: *@This()) void {
|
|
switch (this.*) {
|
|
.with_file_types => |*res| {
|
|
for (res.items) |item| {
|
|
item.name.deref();
|
|
}
|
|
res.clearAndFree();
|
|
},
|
|
.buffers => |*res| {
|
|
for (res.items) |item| {
|
|
bun.default_allocator.free(item.buffer.byteSlice());
|
|
}
|
|
res.clearAndFree();
|
|
},
|
|
.files => |*res| {
|
|
for (res.items) |item| {
|
|
item.deref();
|
|
}
|
|
|
|
res.clearAndFree();
|
|
},
|
|
}
|
|
}
|
|
};
|
|
next: ?*ResultListEntry = null,
|
|
value: Value,
|
|
|
|
pub const Queue = bun.UnboundedQueue(ResultListEntry, .next);
|
|
};
|
|
|
|
pub const Subtask = struct {
|
|
readdir_task: *AsyncReaddirRecursiveTask,
|
|
basename: bun.PathString = bun.PathString.empty,
|
|
task: JSC.WorkPoolTask = .{ .callback = call },
|
|
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub fn call(task: *JSC.WorkPoolTask) void {
|
|
var this: *Subtask = @fieldParentPtr(Subtask, "task", task);
|
|
defer {
|
|
bun.default_allocator.free(this.basename.sliceAssumeZ());
|
|
this.destroy();
|
|
}
|
|
var buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
this.readdir_task.performWork(this.basename.sliceAssumeZ(), &buf, false);
|
|
}
|
|
};
|
|
|
|
pub fn enqueue(
|
|
readdir_task: *AsyncReaddirRecursiveTask,
|
|
basename: [:0]const u8,
|
|
) void {
|
|
var task = Subtask.new(
|
|
.{
|
|
.readdir_task = readdir_task,
|
|
.basename = bun.PathString.init(bun.default_allocator.dupeZ(u8, basename) catch bun.outOfMemory()),
|
|
},
|
|
);
|
|
std.debug.assert(readdir_task.subtask_count.fetchAdd(1, .Monotonic) > 0);
|
|
JSC.WorkPool.schedule(&task.task);
|
|
}
|
|
|
|
pub fn create(
|
|
globalObject: *JSC.JSGlobalObject,
|
|
args: Arguments.Readdir,
|
|
vm: *JSC.VirtualMachine,
|
|
) JSC.JSValue {
|
|
var task = AsyncReaddirRecursiveTask.new(.{
|
|
.promise = JSC.JSPromise.Strong.init(globalObject),
|
|
.args = args,
|
|
.has_result = .{ .raw = false },
|
|
.globalObject = globalObject,
|
|
.tracker = JSC.AsyncTaskTracker.init(vm),
|
|
.subtask_count = .{ .raw = 1 },
|
|
.root_path = PathString.init(bun.default_allocator.dupeZ(u8, args.path.slice()) catch bun.outOfMemory()),
|
|
.result_list = switch (args.tag()) {
|
|
.files => .{ .files = std.ArrayList(bun.String).init(bun.default_allocator) },
|
|
.with_file_types => .{ .with_file_types = std.ArrayList(Dirent).init(bun.default_allocator) },
|
|
.buffers => .{ .buffers = std.ArrayList(Buffer).init(bun.default_allocator) },
|
|
},
|
|
});
|
|
task.ref.ref(vm);
|
|
task.args.toThreadSafe();
|
|
task.tracker.didSchedule(globalObject);
|
|
|
|
JSC.WorkPool.schedule(&task.task);
|
|
|
|
return task.promise.value();
|
|
}
|
|
|
|
pub fn performWork(this: *AsyncReaddirRecursiveTask, basename: [:0]const u8, buf: *[bun.MAX_PATH_BYTES]u8, comptime is_root: bool) void {
|
|
switch (this.args.tag()) {
|
|
inline else => |tag| {
|
|
const ResultType = comptime switch (tag) {
|
|
.files => bun.String,
|
|
.with_file_types => Dirent,
|
|
.buffers => Buffer,
|
|
};
|
|
var stack = std.heap.stackFallback(8192, bun.default_allocator);
|
|
|
|
// This is a stack-local copy to avoid resizing heap-allocated arrays in the common case of a small directory
|
|
var entries = std.ArrayList(ResultType).init(stack.get());
|
|
|
|
defer entries.deinit();
|
|
|
|
switch (NodeFS.readdirWithEntriesRecursiveAsync(
|
|
buf,
|
|
this.args,
|
|
this,
|
|
basename,
|
|
ResultType,
|
|
&entries,
|
|
is_root,
|
|
)) {
|
|
.err => |err| {
|
|
for (entries.items) |*item| {
|
|
switch (ResultType) {
|
|
bun.String => item.deref(),
|
|
Dirent => item.name.deref(),
|
|
Buffer => bun.default_allocator.free(item.buffer.byteSlice()),
|
|
else => @compileError("unreachable"),
|
|
}
|
|
}
|
|
|
|
{
|
|
this.pending_err_mutex.lock();
|
|
defer this.pending_err_mutex.unlock();
|
|
if (this.pending_err == null) {
|
|
const err_path = if (err.path.len > 0) err.path else this.args.path.slice();
|
|
this.pending_err = err.withPath(bun.default_allocator.dupe(u8, err_path) catch "");
|
|
}
|
|
}
|
|
|
|
if (this.subtask_count.fetchSub(1, .Monotonic) == 1) {
|
|
this.finishConcurrently();
|
|
}
|
|
},
|
|
.result => {
|
|
this.writeResults(ResultType, &entries);
|
|
},
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
fn workPoolCallback(task: *JSC.WorkPoolTask) void {
|
|
var this: *AsyncReaddirRecursiveTask = @fieldParentPtr(AsyncReaddirRecursiveTask, "task", task);
|
|
var buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
this.performWork(this.root_path.sliceAssumeZ(), &buf, true);
|
|
}
|
|
|
|
pub fn writeResults(this: *AsyncReaddirRecursiveTask, comptime ResultType: type, result: *std.ArrayList(ResultType)) void {
|
|
if (result.items.len > 0) {
|
|
const Field = switch (ResultType) {
|
|
bun.String => .files,
|
|
Dirent => .with_file_types,
|
|
Buffer => .buffers,
|
|
else => @compileError("unreachable"),
|
|
};
|
|
const list = bun.default_allocator.create(ResultListEntry) catch bun.outOfMemory();
|
|
errdefer {
|
|
bun.default_allocator.destroy(list);
|
|
}
|
|
var clone = std.ArrayList(ResultType).initCapacity(bun.default_allocator, result.items.len) catch bun.outOfMemory();
|
|
clone.appendSliceAssumeCapacity(result.items);
|
|
_ = this.result_list_count.fetchAdd(clone.items.len, .Monotonic);
|
|
list.* = ResultListEntry{ .next = null, .value = @unionInit(ResultListEntry.Value, @tagName(Field), clone) };
|
|
this.result_list_queue.push(list);
|
|
}
|
|
|
|
if (this.subtask_count.fetchSub(1, .Monotonic) == 1) {
|
|
this.finishConcurrently();
|
|
}
|
|
}
|
|
|
|
/// May be called from any thread (the subtasks)
|
|
pub fn finishConcurrently(this: *AsyncReaddirRecursiveTask) void {
|
|
if (this.has_result.cmpxchgStrong(false, true, .Monotonic, .Monotonic)) |_| {
|
|
return;
|
|
}
|
|
|
|
std.debug.assert(this.subtask_count.load(.Monotonic) == 0);
|
|
|
|
const root_fd = this.root_fd;
|
|
if (root_fd != bun.invalid_fd) {
|
|
this.root_fd = bun.invalid_fd;
|
|
_ = Syscall.close(root_fd);
|
|
bun.default_allocator.free(this.root_path.slice());
|
|
this.root_path = PathString.empty;
|
|
}
|
|
|
|
if (this.pending_err != null) {
|
|
this.clearResultList();
|
|
}
|
|
|
|
{
|
|
var list = this.result_list_queue.popBatch();
|
|
var iter = list.iterator();
|
|
|
|
// we have to free only the previous one because the next value will
|
|
// be read by the iterator.
|
|
var to_destroy: ?*ResultListEntry = null;
|
|
|
|
switch (this.args.tag()) {
|
|
inline else => |tag| {
|
|
var results = &@field(this.result_list, @tagName(tag));
|
|
results.ensureTotalCapacityPrecise(this.result_list_count.swap(0, .Monotonic)) catch bun.outOfMemory();
|
|
while (iter.next()) |val| {
|
|
if (to_destroy) |dest| {
|
|
bun.default_allocator.destroy(dest);
|
|
}
|
|
to_destroy = val;
|
|
|
|
var to_copy = &@field(val.value, @tagName(tag));
|
|
results.appendSliceAssumeCapacity(to_copy.items);
|
|
to_copy.clearAndFree();
|
|
}
|
|
|
|
if (to_destroy) |dest| {
|
|
bun.default_allocator.destroy(dest);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
this.globalObject.bunVMConcurrently().enqueueTaskConcurrent(JSC.ConcurrentTask.create(JSC.Task.init(this)));
|
|
}
|
|
|
|
fn clearResultList(this: *AsyncReaddirRecursiveTask) void {
|
|
this.result_list.deinit();
|
|
var batch = this.result_list_queue.popBatch();
|
|
var iter = batch.iterator();
|
|
var to_destroy: ?*ResultListEntry = null;
|
|
|
|
while (iter.next()) |val| {
|
|
val.value.deinit();
|
|
if (to_destroy) |dest| {
|
|
bun.default_allocator.destroy(dest);
|
|
}
|
|
to_destroy = val;
|
|
}
|
|
if (to_destroy) |dest| {
|
|
bun.default_allocator.destroy(dest);
|
|
}
|
|
this.result_list_count.store(0, .Monotonic);
|
|
}
|
|
|
|
pub fn runFromJSThread(this: *AsyncReaddirRecursiveTask) void {
|
|
const globalObject = this.globalObject;
|
|
var success = this.pending_err == null;
|
|
const result = if (this.pending_err) |*err| err.toJSC(globalObject) else brk: {
|
|
const res = switch (this.result_list) {
|
|
.with_file_types => |*res| Return.Readdir{ .with_file_types = res.moveToUnmanaged().items },
|
|
.buffers => |*res| Return.Readdir{ .buffers = res.moveToUnmanaged().items },
|
|
.files => |*res| Return.Readdir{ .files = res.moveToUnmanaged().items },
|
|
};
|
|
const out = res.toJS(globalObject);
|
|
if (out == .zero) {
|
|
success = false;
|
|
}
|
|
|
|
break :brk out;
|
|
};
|
|
var promise_value = this.promise.value();
|
|
var promise = this.promise.get();
|
|
promise_value.ensureStillAlive();
|
|
|
|
const tracker = this.tracker;
|
|
tracker.willDispatch(globalObject);
|
|
defer tracker.didDispatch(globalObject);
|
|
|
|
this.deinit();
|
|
switch (success) {
|
|
false => {
|
|
promise.reject(globalObject, result);
|
|
},
|
|
true => {
|
|
promise.resolve(globalObject, result);
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn deinit(this: *AsyncReaddirRecursiveTask) void {
|
|
std.debug.assert(this.root_fd == bun.invalid_fd); // should already have closed it
|
|
if (this.pending_err) |*err| {
|
|
bun.default_allocator.free(err.path);
|
|
}
|
|
|
|
this.ref.unref(this.globalObject.bunVM());
|
|
this.args.deinit();
|
|
bun.default_allocator.free(this.root_path.slice());
|
|
this.clearResultList();
|
|
this.promise.strong.deinit();
|
|
this.destroy();
|
|
}
|
|
};
|
|
|
|
/// This task is used by `AsyncCpTask/fs.promises.cp` to copy a single file.
|
|
/// When clonefile cannot be used, this task is started once per file.
|
|
pub const AsyncCpSingleFileTask = struct {
|
|
cp_task: *AsyncCpTask,
|
|
src: bun.OSPathSliceZ,
|
|
dest: bun.OSPathSliceZ,
|
|
task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
|
|
|
|
pub fn create(
|
|
parent: *AsyncCpTask,
|
|
src: bun.OSPathSliceZ,
|
|
dest: bun.OSPathSliceZ,
|
|
) void {
|
|
var task = bun.new(AsyncCpSingleFileTask, .{
|
|
.cp_task = parent,
|
|
.src = src,
|
|
.dest = dest,
|
|
});
|
|
|
|
JSC.WorkPool.schedule(&task.task);
|
|
}
|
|
|
|
fn workPoolCallback(task: *JSC.WorkPoolTask) void {
|
|
var this: *AsyncCpSingleFileTask = @fieldParentPtr(AsyncCpSingleFileTask, "task", task);
|
|
|
|
// TODO: error strings on node_fs will die
|
|
var node_fs = NodeFS{};
|
|
|
|
const args = this.cp_task.args;
|
|
const result = node_fs._copySingleFileSync(
|
|
this.src,
|
|
this.dest,
|
|
@enumFromInt((if (args.flags.errorOnExist or !args.flags.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
null,
|
|
);
|
|
|
|
brk: {
|
|
switch (result) {
|
|
.err => |err| {
|
|
if (err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
|
|
break :brk;
|
|
}
|
|
this.cp_task.finishConcurrently(result);
|
|
this.deinit();
|
|
return;
|
|
},
|
|
.result => {},
|
|
}
|
|
}
|
|
|
|
const old_count = this.cp_task.subtask_count.fetchSub(1, .Monotonic);
|
|
if (old_count == 1) {
|
|
this.cp_task.finishConcurrently(Maybe(Return.Cp).success);
|
|
}
|
|
|
|
this.deinit();
|
|
}
|
|
|
|
pub fn deinit(this: *AsyncCpSingleFileTask) void {
|
|
// There is only one path buffer for both paths. 2 extra bytes are the nulls at the end of each
|
|
bun.default_allocator.free(this.src.ptr[0 .. this.src.len + this.dest.len + 2]);
|
|
|
|
bun.destroy(this);
|
|
}
|
|
};
|
|
|
|
// TODO: to improve performance for all of these
|
|
// The tagged unions for each type should become regular unions
|
|
// and the tags should be passed in as comptime arguments to the functions performing the syscalls
|
|
// This would reduce stack size, at the cost of instruction cache misses
|
|
pub const Arguments = struct {
|
|
pub const Rename = struct {
|
|
old_path: PathLike,
|
|
new_path: PathLike,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.old_path.deinit();
|
|
this.new_path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: @This()) void {
|
|
this.old_path.deinitAndUnprotect();
|
|
this.new_path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.old_path.toThreadSafe();
|
|
this.new_path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Rename {
|
|
const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"oldPath must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"newPath must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
return Rename{ .old_path = old_path, .new_path = new_path };
|
|
}
|
|
};
|
|
|
|
pub const Truncate = struct {
|
|
/// Passing a file descriptor is deprecated and may result in an error being thrown in the future.
|
|
path: PathOrFileDescriptor,
|
|
len: JSC.WebCore.Blob.SizeType = 0,
|
|
flags: i32 = 0,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Truncate {
|
|
const path = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const len: JSC.WebCore.Blob.SizeType = brk: {
|
|
const len_value = arguments.next() orelse break :brk 0;
|
|
|
|
if (len_value.isNumber()) {
|
|
arguments.eat();
|
|
break :brk len_value.to(JSC.WebCore.Blob.SizeType);
|
|
}
|
|
|
|
break :brk 0;
|
|
};
|
|
|
|
return Truncate{ .path = path, .len = len };
|
|
}
|
|
};
|
|
|
|
pub const Writev = struct {
|
|
fd: FileDescriptor,
|
|
buffers: JSC.Node.VectorArrayBuffer,
|
|
position: ?u52 = 0,
|
|
|
|
pub fn deinit(_: *const @This()) void {}
|
|
|
|
pub fn deinitAndUnprotect(this: *const @This()) void {
|
|
this.buffers.value.unprotect();
|
|
this.buffers.buffers.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.buffers.value.protect();
|
|
|
|
const clone = bun.default_allocator.dupe(bun.PlatformIOVec, this.buffers.buffers.items) catch @panic("out of memory");
|
|
this.buffers.buffers.deinit();
|
|
this.buffers.buffers.items = clone;
|
|
this.buffers.buffers.capacity = clone.len;
|
|
this.buffers.buffers.allocator = bun.default_allocator;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Writev {
|
|
const fd_value = arguments.nextEat() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const buffers = JSC.Node.VectorArrayBuffer.fromJS(
|
|
ctx,
|
|
arguments.protectEatNext() orelse {
|
|
JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
|
|
return null;
|
|
},
|
|
exception,
|
|
arguments.arena.allocator(),
|
|
) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"buffers must be an array of TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
var position: ?u52 = null;
|
|
|
|
if (arguments.nextEat()) |pos_value| {
|
|
if (!pos_value.isUndefinedOrNull()) {
|
|
if (pos_value.isNumber()) {
|
|
position = pos_value.to(u52);
|
|
} else {
|
|
JSC.throwInvalidArguments(
|
|
"position must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Writev{ .fd = fd, .buffers = buffers, .position = position };
|
|
}
|
|
};
|
|
|
|
pub const Readv = struct {
|
|
fd: FileDescriptor,
|
|
buffers: JSC.Node.VectorArrayBuffer,
|
|
position: ?u52 = 0,
|
|
|
|
pub fn deinit(this: *const @This()) void {
|
|
_ = this;
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *const @This()) void {
|
|
this.buffers.value.unprotect();
|
|
this.buffers.buffers.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.buffers.value.protect();
|
|
|
|
const clone = bun.default_allocator.dupe(bun.PlatformIOVec, this.buffers.buffers.items) catch @panic("out of memory");
|
|
this.buffers.buffers.deinit();
|
|
this.buffers.buffers.items = clone;
|
|
this.buffers.buffers.capacity = clone.len;
|
|
this.buffers.buffers.allocator = bun.default_allocator;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readv {
|
|
const fd_value = arguments.nextEat() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const buffers = JSC.Node.VectorArrayBuffer.fromJS(
|
|
ctx,
|
|
arguments.protectEatNext() orelse {
|
|
JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
|
|
return null;
|
|
},
|
|
exception,
|
|
arguments.arena.allocator(),
|
|
) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"buffers must be an array of TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
var position: ?u52 = null;
|
|
|
|
if (arguments.nextEat()) |pos_value| {
|
|
if (!pos_value.isUndefinedOrNull()) {
|
|
if (pos_value.isNumber()) {
|
|
position = pos_value.to(u52);
|
|
} else {
|
|
JSC.throwInvalidArguments(
|
|
"position must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Readv{ .fd = fd, .buffers = buffers, .position = position };
|
|
}
|
|
};
|
|
|
|
pub const FTruncate = struct {
|
|
fd: FileDescriptor,
|
|
len: ?JSC.WebCore.Blob.SizeType = null,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
_ = this;
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
_ = this;
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *const @This()) void {
|
|
_ = this;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FTruncate {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const len: JSC.WebCore.Blob.SizeType = brk: {
|
|
const len_value = arguments.next() orelse break :brk 0;
|
|
if (len_value.isNumber()) {
|
|
arguments.eat();
|
|
break :brk len_value.to(JSC.WebCore.Blob.SizeType);
|
|
}
|
|
|
|
break :brk 0;
|
|
};
|
|
|
|
return FTruncate{ .fd = fd, .len = len };
|
|
}
|
|
};
|
|
|
|
pub const Chown = struct {
|
|
path: PathLike,
|
|
uid: uid_t = 0,
|
|
gid: gid_t = 0,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Chown {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const uid: uid_t = brk: {
|
|
const uid_value = arguments.next() orelse break :brk {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"uid is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
break :brk @as(uid_t, @intCast(uid_value.toInt32()));
|
|
};
|
|
|
|
const gid: gid_t = brk: {
|
|
const gid_value = arguments.next() orelse break :brk {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"gid is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
break :brk @as(gid_t, @intCast(gid_value.toInt32()));
|
|
};
|
|
|
|
return Chown{ .path = path, .uid = uid, .gid = gid };
|
|
}
|
|
};
|
|
|
|
pub const Fchown = struct {
|
|
fd: FileDescriptor,
|
|
uid: uid_t,
|
|
gid: gid_t,
|
|
|
|
pub fn deinit(_: @This()) void {}
|
|
|
|
pub fn toThreadSafe(_: *const @This()) void {}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fchown {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const uid: uid_t = brk: {
|
|
const uid_value = arguments.next() orelse break :brk {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"uid is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
break :brk @as(uid_t, @intCast(uid_value.toInt32()));
|
|
};
|
|
|
|
const gid: gid_t = brk: {
|
|
const gid_value = arguments.next() orelse break :brk {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"gid is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
break :brk @as(gid_t, @intCast(gid_value.toInt32()));
|
|
};
|
|
|
|
return Fchown{ .fd = fd, .uid = uid, .gid = gid };
|
|
}
|
|
};
|
|
|
|
pub const LChown = Chown;
|
|
|
|
pub const Lutimes = struct {
|
|
path: PathLike,
|
|
atime: TimeLike,
|
|
mtime: TimeLike,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Lutimes {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const atime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"atime is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"atime must be a number or a Date",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
const mtime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mtime is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mtime must be a number or a Date",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
return Lutimes{ .path = path, .atime = atime, .mtime = mtime };
|
|
}
|
|
};
|
|
|
|
pub const Chmod = struct {
|
|
path: PathLike,
|
|
mode: Mode = 0x777,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Chmod {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const mode: Mode = JSC.Node.modeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mode is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mode must be a string or integer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
return Chmod{ .path = path, .mode = mode };
|
|
}
|
|
};
|
|
|
|
pub const FChmod = struct {
|
|
fd: FileDescriptor,
|
|
mode: Mode = 0x777,
|
|
|
|
pub fn deinit(_: *const @This()) void {}
|
|
|
|
pub fn toThreadSafe(_: *const @This()) void {}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FChmod {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
arguments.eat();
|
|
|
|
const mode: Mode = JSC.Node.modeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mode is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mode must be a string or integer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
return FChmod{ .fd = fd, .mode = mode };
|
|
}
|
|
};
|
|
|
|
pub const LCHmod = Chmod;
|
|
|
|
pub const Stat = struct {
|
|
path: PathLike,
|
|
big_int: bool = false,
|
|
throw_if_no_entry: bool = true,
|
|
|
|
pub fn deinit(this: Stat) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: Stat) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Stat) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Stat {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var throw_if_no_entry = true;
|
|
|
|
const big_int = brk: {
|
|
if (arguments.next()) |next_val| {
|
|
if (next_val.isObject()) {
|
|
if (next_val.isCallable(ctx.ptr().vm())) break :brk false;
|
|
arguments.eat();
|
|
|
|
if (next_val.getOptional(ctx.ptr(), "throwIfNoEntry", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |throw_if_no_entry_val| {
|
|
throw_if_no_entry = throw_if_no_entry_val;
|
|
}
|
|
|
|
if (next_val.getOptional(ctx.ptr(), "bigint", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |big_int| {
|
|
break :brk big_int;
|
|
}
|
|
}
|
|
}
|
|
break :brk false;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Stat{ .path = path, .big_int = big_int, .throw_if_no_entry = throw_if_no_entry };
|
|
}
|
|
};
|
|
|
|
pub const Fstat = struct {
|
|
fd: FileDescriptor,
|
|
big_int: bool = false,
|
|
|
|
pub fn deinit(_: @This()) void {}
|
|
|
|
pub fn toThreadSafe(_: *@This()) void {}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fstat {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"file descriptor must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const big_int = brk: {
|
|
if (arguments.next()) |next_val| {
|
|
if (next_val.isObject()) {
|
|
if (next_val.isCallable(ctx.ptr().vm())) break :brk false;
|
|
arguments.eat();
|
|
|
|
if (next_val.getOptional(ctx.ptr(), "bigint", bool) catch false) |big_int| {
|
|
break :brk big_int;
|
|
}
|
|
}
|
|
}
|
|
break :brk false;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Fstat{ .fd = fd, .big_int = big_int };
|
|
}
|
|
};
|
|
|
|
pub const Lstat = Stat;
|
|
|
|
pub const Link = struct {
|
|
old_path: PathLike,
|
|
new_path: PathLike,
|
|
|
|
pub fn deinit(this: Link) void {
|
|
this.old_path.deinit();
|
|
this.new_path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Link) void {
|
|
this.old_path.deinitAndUnprotect();
|
|
this.new_path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Link) void {
|
|
this.old_path.toThreadSafe();
|
|
this.new_path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Link {
|
|
const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"oldPath must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"newPath must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Link{ .old_path = old_path, .new_path = new_path };
|
|
}
|
|
};
|
|
|
|
pub const Symlink = struct {
|
|
old_path: PathLike,
|
|
new_path: PathLike,
|
|
link_type: LinkType,
|
|
|
|
const LinkType = if (!Environment.isWindows)
|
|
u0
|
|
else
|
|
LinkTypeEnum;
|
|
|
|
const LinkTypeEnum = enum {
|
|
file,
|
|
dir,
|
|
junction,
|
|
};
|
|
|
|
pub fn deinit(this: Symlink) void {
|
|
this.old_path.deinit();
|
|
this.new_path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: Symlink) void {
|
|
this.old_path.deinitAndUnprotect();
|
|
this.new_path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *@This()) void {
|
|
this.old_path.toThreadSafe();
|
|
this.new_path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Symlink {
|
|
const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"target must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const link_type: LinkType = if (!Environment.isWindows)
|
|
0
|
|
else link_type: {
|
|
if (arguments.next()) |next_val| {
|
|
// The type argument is only available on Windows and
|
|
// ignored on other platforms. It can be set to 'dir',
|
|
// 'file', or 'junction'. If the type argument is not set,
|
|
// Node.js will autodetect target type and use 'file' or
|
|
// 'dir'. If the target does not exist, 'file' will be used.
|
|
// Windows junction points require the destination path to
|
|
// be absolute. When using 'junction', the target argument
|
|
// will automatically be normalized to absolute path.
|
|
if (next_val.isString()) {
|
|
arguments.eat();
|
|
var str = next_val.toBunString(ctx.ptr());
|
|
defer str.deref();
|
|
if (str.eqlComptime("dir")) break :link_type .dir;
|
|
if (str.eqlComptime("file")) break :link_type .file;
|
|
if (str.eqlComptime("junction")) break :link_type .junction;
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Symlink type must be one of \"dir\", \"file\", or \"junction\". Received \"{}\"",
|
|
.{str},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// not a string. fallthrough to auto detect.
|
|
}
|
|
|
|
var buf: bun.PathBuffer = undefined;
|
|
const stat = bun.sys.stat(old_path.sliceZ(&buf));
|
|
|
|
// if there's an error node defaults to file.
|
|
break :link_type if (stat == .result and bun.C.S.ISDIR(@intCast(stat.result.mode))) .dir else .file;
|
|
};
|
|
|
|
return Symlink{
|
|
.old_path = old_path,
|
|
.new_path = new_path,
|
|
.link_type = link_type,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Readlink = struct {
|
|
path: PathLike,
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
pub fn deinit(this: Readlink) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Readlink) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Readlink) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readlink {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
var encoding = Encoding.utf8;
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
switch (val.jsType()) {
|
|
JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
|
|
encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
|
|
},
|
|
else => {
|
|
if (val.isObject()) {
|
|
if (val.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
return Readlink{ .path = path, .encoding = encoding };
|
|
}
|
|
};
|
|
|
|
pub const Realpath = struct {
|
|
path: PathLike,
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
pub fn deinit(this: Realpath) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Realpath) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Realpath) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Realpath {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
var encoding = Encoding.utf8;
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
switch (val.jsType()) {
|
|
JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
|
|
encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
|
|
},
|
|
else => {
|
|
if (val.isObject()) {
|
|
if (val.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
return Realpath{ .path = path, .encoding = encoding };
|
|
}
|
|
};
|
|
|
|
pub const Unlink = struct {
|
|
path: PathLike,
|
|
|
|
pub fn deinit(this: Unlink) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Unlink) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Unlink) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Unlink {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Unlink{
|
|
.path = path,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Rm = RmDir;
|
|
|
|
pub const RmDir = struct {
|
|
path: PathLike,
|
|
|
|
force: bool = false,
|
|
|
|
max_retries: u32 = 0,
|
|
recursive: bool = false,
|
|
retry_delay: c_uint = 100,
|
|
|
|
pub fn deinitAndUnprotect(this: *RmDir) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *RmDir) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn deinit(this: RmDir) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?RmDir {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var recursive = false;
|
|
var force = false;
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
if (val.isObject()) {
|
|
if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |boolean| {
|
|
recursive = boolean;
|
|
}
|
|
|
|
if (val.getOptional(ctx.ptr(), "force", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |boolean| {
|
|
force = boolean;
|
|
}
|
|
}
|
|
}
|
|
|
|
return RmDir{
|
|
.path = path,
|
|
.recursive = recursive,
|
|
.force = force,
|
|
};
|
|
}
|
|
};
|
|
|
|
/// https://github.com/nodejs/node/blob/master/lib/fs.js#L1285
|
|
pub const Mkdir = struct {
|
|
path: PathLike,
|
|
/// Indicates whether parent folders should be created.
|
|
/// If a folder was created, the path to the first created folder will be returned.
|
|
/// @default false
|
|
recursive: bool = false,
|
|
/// A file mode. If a string is passed, it is parsed as an octal integer. If not specified
|
|
mode: Mode = DefaultMode,
|
|
/// If set to true, the return value is never set to a string
|
|
always_return_none: bool = false,
|
|
|
|
pub const DefaultMode = 0o777;
|
|
|
|
pub fn deinit(this: Mkdir) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Mkdir) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Mkdir) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: *JSC.JSGlobalObject, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Mkdir {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var recursive = false;
|
|
var mode: Mode = 0o777;
|
|
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
if (val.isObject()) {
|
|
if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |boolean| {
|
|
recursive = boolean;
|
|
}
|
|
|
|
if (val.getIfPropertyExists(ctx.ptr(), "mode")) |mode_| {
|
|
mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse mode;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Mkdir{
|
|
.path = path,
|
|
.recursive = recursive,
|
|
.mode = mode,
|
|
};
|
|
}
|
|
};
|
|
|
|
const MkdirTemp = struct {
|
|
prefix: JSC.Node.StringOrBuffer = .{ .buffer = .{ .buffer = JSC.ArrayBuffer.empty } },
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
pub fn deinit(this: MkdirTemp) void {
|
|
this.prefix.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *MkdirTemp) void {
|
|
this.prefix.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *MkdirTemp) void {
|
|
this.prefix.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?MkdirTemp {
|
|
const prefix_value = arguments.next() orelse return MkdirTemp{};
|
|
|
|
const prefix = JSC.Node.StringOrBuffer.fromJS(ctx, bun.default_allocator, prefix_value) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"prefix must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
arguments.eat();
|
|
|
|
var encoding = Encoding.utf8;
|
|
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
switch (val.jsType()) {
|
|
JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
|
|
encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
|
|
},
|
|
else => {
|
|
if (val.isObject()) {
|
|
if (val.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
return MkdirTemp{
|
|
.prefix = prefix,
|
|
.encoding = encoding,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Readdir = struct {
|
|
path: PathLike,
|
|
encoding: Encoding = Encoding.utf8,
|
|
with_file_types: bool = false,
|
|
recursive: bool = false,
|
|
|
|
pub fn deinit(this: Readdir) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: Readdir) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Readdir) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn tag(this: *const Readdir) Return.Readdir.Tag {
|
|
return switch (this.encoding) {
|
|
.buffer => .buffers,
|
|
else => if (this.with_file_types)
|
|
.with_file_types
|
|
else
|
|
.files,
|
|
};
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readdir {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var encoding = Encoding.utf8;
|
|
var with_file_types = false;
|
|
var recursive = false;
|
|
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
switch (val.jsType()) {
|
|
JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
|
|
encoding = Encoding.fromJS(val, ctx.ptr()) orelse Encoding.utf8;
|
|
},
|
|
else => {
|
|
if (val.isObject()) {
|
|
if (val.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse Encoding.utf8;
|
|
}
|
|
|
|
if (val.getOptional(ctx.ptr(), "recursive", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |recursive_| {
|
|
recursive = recursive_;
|
|
}
|
|
|
|
if (val.getOptional(ctx.ptr(), "withFileTypes", bool) catch {
|
|
path.deinit();
|
|
return null;
|
|
}) |with_file_types_| {
|
|
with_file_types = with_file_types_;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
return Readdir{
|
|
.path = path,
|
|
.encoding = encoding,
|
|
.with_file_types = with_file_types,
|
|
.recursive = recursive,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Close = struct {
|
|
fd: FileDescriptor,
|
|
|
|
pub fn deinit(_: Close) void {}
|
|
pub fn toThreadSafe(_: Close) void {}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Close {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Close{ .fd = fd };
|
|
}
|
|
};
|
|
|
|
pub const Open = struct {
|
|
path: PathLike,
|
|
flags: FileSystemFlags = FileSystemFlags.r,
|
|
mode: Mode = default_permission,
|
|
|
|
pub fn deinit(this: Open) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: Open) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Open) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Open {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var flags = FileSystemFlags.r;
|
|
var mode: Mode = default_permission;
|
|
|
|
if (arguments.next()) |val| {
|
|
arguments.eat();
|
|
|
|
if (val.isObject()) {
|
|
if (val.getTruthy(ctx.ptr(), "flags")) |flags_| {
|
|
flags = FileSystemFlags.fromJS(ctx, flags_, exception) orelse flags;
|
|
}
|
|
|
|
if (val.getTruthy(ctx.ptr(), "mode")) |mode_| {
|
|
mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse mode;
|
|
}
|
|
} else if (!val.isEmpty()) {
|
|
if (!val.isUndefinedOrNull())
|
|
// error is handled below
|
|
flags = FileSystemFlags.fromJS(ctx, val, exception) orelse flags;
|
|
|
|
if (arguments.nextEat()) |next| {
|
|
mode = JSC.Node.modeFromJS(ctx, next, exception) orelse mode;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Open{
|
|
.path = path,
|
|
.flags = flags,
|
|
.mode = mode,
|
|
};
|
|
}
|
|
};
|
|
|
|
/// Change the file system timestamps of the object referenced by `path`.
|
|
///
|
|
/// The `atime` and `mtime` arguments follow these rules:
|
|
///
|
|
/// * Values can be either numbers representing Unix epoch time in seconds,`Date`s, or a numeric string like `'123456789.0'`.
|
|
/// * If the value can not be converted to a number, or is `NaN`, `Infinity` or`-Infinity`, an `Error` will be thrown.
|
|
/// @since v0.4.2
|
|
pub const Utimes = Lutimes;
|
|
|
|
pub const Futimes = struct {
|
|
fd: FileDescriptor,
|
|
atime: TimeLike,
|
|
mtime: TimeLike,
|
|
|
|
pub fn deinit(_: Futimes) void {}
|
|
|
|
pub fn toThreadSafe(self: *const @This()) void {
|
|
_ = self;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Futimes {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
arguments.eat();
|
|
if (exception.* != null) return null;
|
|
|
|
const atime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"atime is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"atime must be a number, Date or string",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const mtime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mtime is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"mtime must be a number, Date or string",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Futimes{
|
|
.fd = fd,
|
|
.atime = atime,
|
|
.mtime = mtime,
|
|
};
|
|
}
|
|
};
|
|
|
|
/// Write `buffer` to the file specified by `fd`. If `buffer` is a normal object, it
|
|
/// must have an own `toString` function property.
|
|
///
|
|
/// `offset` determines the part of the buffer to be written, and `length` is
|
|
/// an integer specifying the number of bytes to write.
|
|
///
|
|
/// `position` refers to the offset from the beginning of the file where this data
|
|
/// should be written. If `typeof position !== 'number'`, the data will be written
|
|
/// at the current position. See [`pwrite(2)`](http://man7.org/linux/man-pages/man2/pwrite.2.html).
|
|
///
|
|
/// The callback will be given three arguments `(err, bytesWritten, buffer)` where`bytesWritten` specifies how many _bytes_ were written from `buffer`.
|
|
///
|
|
/// If this method is invoked as its `util.promisify()` ed version, it returns
|
|
/// a promise for an `Object` with `bytesWritten` and `buffer` properties.
|
|
///
|
|
/// It is unsafe to use `fs.write()` multiple times on the same file without waiting
|
|
/// for the callback. For this scenario, {@link createWriteStream} is
|
|
/// recommended.
|
|
///
|
|
/// On Linux, positional writes don't work when the file is opened in append mode.
|
|
/// The kernel ignores the position argument and always appends the data to
|
|
/// the end of the file.
|
|
/// @since v0.0.2
|
|
///
|
|
pub const Write = struct {
|
|
fd: FileDescriptor,
|
|
buffer: JSC.Node.StringOrBuffer,
|
|
// buffer_val: JSC.JSValue = JSC.JSValue.zero,
|
|
offset: u64 = 0,
|
|
length: u64 = std.math.maxInt(u64),
|
|
position: ?ReadPosition = null,
|
|
encoding: Encoding = Encoding.buffer,
|
|
|
|
pub fn deinit(this: *const @This()) void {
|
|
this.buffer.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *@This()) void {
|
|
this.buffer.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(self: *@This()) void {
|
|
self.buffer.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Write {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const buffer = StringOrBuffer.fromJS(ctx.ptr(), bun.default_allocator, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"data is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"data must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
if (exception.* != null) return null;
|
|
|
|
var args = Write{
|
|
.fd = fd,
|
|
.buffer = buffer,
|
|
.encoding = switch (buffer) {
|
|
.buffer => Encoding.buffer,
|
|
inline else => Encoding.utf8,
|
|
},
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
// TODO: make this faster by passing argument count at comptime
|
|
if (arguments.next()) |current_| {
|
|
parse: {
|
|
var current = current_;
|
|
switch (buffer) {
|
|
// fs.write(fd, string[, position[, encoding]], callback)
|
|
else => {
|
|
if (current.isNumber()) {
|
|
args.position = current.to(i52);
|
|
arguments.eat();
|
|
current = arguments.next() orelse break :parse;
|
|
}
|
|
|
|
if (current.isString()) {
|
|
args.encoding = Encoding.fromJS(current, ctx.ptr()) orelse Encoding.utf8;
|
|
arguments.eat();
|
|
}
|
|
},
|
|
// fs.write(fd, buffer[, offset[, length[, position]]], callback)
|
|
.buffer => {
|
|
if (!current.isNumber()) {
|
|
break :parse;
|
|
}
|
|
|
|
if (!(current.isNumber() or current.isBigInt())) break :parse;
|
|
args.offset = current.to(u52);
|
|
arguments.eat();
|
|
current = arguments.next() orelse break :parse;
|
|
|
|
if (!(current.isNumber() or current.isBigInt())) break :parse;
|
|
args.length = current.to(u52);
|
|
arguments.eat();
|
|
current = arguments.next() orelse break :parse;
|
|
|
|
if (!(current.isNumber() or current.isBigInt())) break :parse;
|
|
args.position = current.to(i52);
|
|
arguments.eat();
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
return args;
|
|
}
|
|
};
|
|
|
|
pub const Read = struct {
|
|
fd: FileDescriptor,
|
|
buffer: Buffer,
|
|
offset: u64 = 0,
|
|
length: u64 = std.math.maxInt(u64),
|
|
position: ?ReadPosition = null,
|
|
|
|
pub fn deinit(_: Read) void {}
|
|
|
|
pub fn toThreadSafe(this: Read) void {
|
|
this.buffer.buffer.value.protect();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Read) void {
|
|
this.buffer.buffer.value.unprotect();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Read {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
arguments.eat();
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const buffer = Buffer.fromJS(ctx.ptr(), arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"buffer is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"buffer must be a TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
arguments.eat();
|
|
|
|
var args = Read{
|
|
.fd = fd,
|
|
.buffer = buffer,
|
|
};
|
|
|
|
if (arguments.next()) |current| {
|
|
arguments.eat();
|
|
if (current.isNumber() or current.isBigInt()) {
|
|
args.offset = current.to(u52);
|
|
|
|
if (arguments.remaining.len < 2) {
|
|
JSC.throwInvalidArguments(
|
|
"length and position are required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
|
|
return null;
|
|
}
|
|
if (arguments.remaining[0].isNumber() or arguments.remaining[0].isBigInt())
|
|
args.length = arguments.remaining[0].to(u52);
|
|
|
|
if (args.length == 0) {
|
|
JSC.throwInvalidArguments(
|
|
"length must be greater than 0",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
|
|
return null;
|
|
}
|
|
|
|
if (arguments.remaining[1].isNumber() or arguments.remaining[1].isBigInt())
|
|
args.position = @as(ReadPosition, @intCast(arguments.remaining[1].to(i52)));
|
|
|
|
arguments.remaining = arguments.remaining[2..];
|
|
} else if (current.isObject()) {
|
|
if (current.getTruthy(ctx.ptr(), "offset")) |num| {
|
|
if (num.isNumber() or num.isBigInt()) {
|
|
args.offset = num.to(u52);
|
|
}
|
|
}
|
|
|
|
if (current.getTruthy(ctx.ptr(), "length")) |num| {
|
|
if (num.isNumber() or num.isBigInt()) {
|
|
args.length = num.to(u52);
|
|
}
|
|
}
|
|
|
|
if (current.getTruthy(ctx.ptr(), "position")) |num| {
|
|
if (num.isNumber() or num.isBigInt()) {
|
|
args.position = num.to(i52);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return args;
|
|
}
|
|
};
|
|
|
|
/// Asynchronously reads the entire contents of a file.
|
|
/// @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
|
|
/// If a file descriptor is provided, the underlying file will _not_ be closed automatically.
|
|
/// @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
|
|
/// If a flag is not provided, it defaults to `'r'`.
|
|
pub const ReadFile = struct {
|
|
path: PathOrFileDescriptor,
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
offset: JSC.WebCore.Blob.SizeType = 0,
|
|
max_size: ?JSC.WebCore.Blob.SizeType = null,
|
|
|
|
flag: FileSystemFlags = FileSystemFlags.r,
|
|
|
|
pub fn deinit(self: ReadFile) void {
|
|
self.path.deinit();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(self: ReadFile) void {
|
|
self.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn toThreadSafe(self: *ReadFile) void {
|
|
self.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?ReadFile {
|
|
const path = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or a file descriptor",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var encoding = Encoding.buffer;
|
|
var flag = FileSystemFlags.r;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
} else if (arg.isObject()) {
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
if (!encoding_.isUndefinedOrNull()) {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
if (arg.getTruthy(ctx.ptr(), "flag")) |flag_| {
|
|
flag = FileSystemFlags.fromJS(ctx, flag_, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid flag",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// Note: Signal is not implemented
|
|
return ReadFile{
|
|
.path = path,
|
|
.encoding = encoding,
|
|
.flag = flag,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const WriteFile = struct {
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
flag: FileSystemFlags = FileSystemFlags.w,
|
|
mode: Mode = 0o666,
|
|
file: PathOrFileDescriptor,
|
|
|
|
/// Encoded at the time of construction.
|
|
data: StringOrBuffer,
|
|
|
|
dirfd: FileDescriptor,
|
|
|
|
pub fn deinit(self: WriteFile) void {
|
|
self.file.deinit();
|
|
self.data.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(self: *WriteFile) void {
|
|
self.file.toThreadSafe();
|
|
self.data.toThreadSafe();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(self: *WriteFile) void {
|
|
self.file.deinitAndUnprotect();
|
|
self.data.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?WriteFile {
|
|
const file = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or a file descriptor",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const data_value = arguments.nextEat() orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"data is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
var encoding = Encoding.buffer;
|
|
var flag = FileSystemFlags.w;
|
|
var mode: Mode = default_permission;
|
|
|
|
if (data_value.isString()) {
|
|
encoding = Encoding.utf8;
|
|
}
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
} else if (arg.isObject()) {
|
|
if (arg.getTruthy(ctx.ptr(), "encoding")) |encoding_| {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getTruthy(ctx.ptr(), "flag")) |flag_| {
|
|
flag = FileSystemFlags.fromJS(ctx, flag_, exception) orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid flag",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getTruthy(ctx.ptr(), "mode")) |mode_| {
|
|
mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid flag",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
const data = StringOrBuffer.fromJSWithEncodingMaybeAsync(ctx.ptr(), bun.default_allocator, data_value, encoding, arguments.will_be_async) orelse {
|
|
defer file.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"data must be a string or TypedArray",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
// Note: Signal is not implemented
|
|
return WriteFile{
|
|
.file = file,
|
|
.encoding = encoding,
|
|
.flag = flag,
|
|
.mode = mode,
|
|
.data = data,
|
|
.dirfd = bun.toFD(std.fs.cwd().fd),
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const AppendFile = WriteFile;
|
|
|
|
pub const OpenDir = struct {
|
|
path: PathLike,
|
|
encoding: Encoding = Encoding.utf8,
|
|
|
|
/// Number of directory entries that are buffered internally when reading from the directory. Higher values lead to better performance but higher memory usage. Default: 32
|
|
buffer_size: c_int = 32,
|
|
|
|
pub fn deinit(self: OpenDir) void {
|
|
self.path.deinit();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?OpenDir {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or a file descriptor",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var encoding = Encoding.buffer;
|
|
var buffer_size: c_int = 32;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
} else if (arg.isObject()) {
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding_| {
|
|
if (!encoding_.isUndefinedOrNull()) {
|
|
encoding = Encoding.fromJS(encoding_, ctx.ptr()) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "bufferSize")) |buffer_size_| {
|
|
buffer_size = buffer_size_.toInt32();
|
|
if (buffer_size < 0) {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"bufferSize must be > 0",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return OpenDir{
|
|
.path = path,
|
|
.encoding = encoding,
|
|
.buffer_size = buffer_size,
|
|
};
|
|
}
|
|
};
|
|
pub const Exists = struct {
|
|
path: ?PathLike,
|
|
|
|
pub fn deinit(this: Exists) void {
|
|
if (this.path) |path| {
|
|
path.deinit();
|
|
}
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Exists) void {
|
|
if (this.path) |*path| {
|
|
path.toThreadSafe();
|
|
}
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Exists) void {
|
|
if (this.path) |*path| {
|
|
path.deinitAndUnprotect();
|
|
}
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Exists {
|
|
return Exists{
|
|
.path = PathLike.fromJS(ctx, arguments, exception),
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Access = struct {
|
|
path: PathLike,
|
|
mode: FileSystemFlags = FileSystemFlags.r,
|
|
|
|
pub fn deinit(this: Access) void {
|
|
this.path.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *Access) void {
|
|
this.path.toThreadSafe();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *Access) void {
|
|
this.path.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Access {
|
|
const path = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"path must be a string or buffer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var mode = FileSystemFlags.r;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
mode = FileSystemFlags.fromJS(ctx, arg, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid mode",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
return Access{
|
|
.path = path,
|
|
.mode = mode,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const CreateReadStream = struct {
|
|
file: PathOrFileDescriptor,
|
|
flags: FileSystemFlags = FileSystemFlags.r,
|
|
encoding: Encoding = Encoding.utf8,
|
|
mode: Mode = default_permission,
|
|
autoClose: bool = true,
|
|
emitClose: bool = true,
|
|
start: i32 = 0,
|
|
end: i32 = std.math.maxInt(i32),
|
|
highwater_mark: u32 = 64 * 1024,
|
|
global_object: *JSC.JSGlobalObject,
|
|
|
|
pub fn deinit(this: CreateReadStream) void {
|
|
this.file.deinit();
|
|
}
|
|
|
|
pub fn copyToState(this: CreateReadStream, state: *JSC.Node.Readable.State) void {
|
|
state.encoding = this.encoding;
|
|
state.highwater_mark = this.highwater_mark;
|
|
state.start = this.start;
|
|
state.end = this.end;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CreateReadStream {
|
|
const path = PathLike.fromJS(ctx, arguments, exception);
|
|
if (exception.* != null) return null;
|
|
if (path == null) arguments.eat();
|
|
|
|
var stream = CreateReadStream{
|
|
.file = undefined,
|
|
.global_object = ctx.ptr(),
|
|
};
|
|
var fd = FileDescriptor.invalid;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
stream.encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
} else if (arg.isObject()) {
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "mode")) |mode_| {
|
|
stream.mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid mode",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding| {
|
|
stream.encoding = Encoding.fromJS(encoding, ctx.ptr()) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getTruthy(ctx.ptr(), "flags")) |flags| {
|
|
stream.flags = FileSystemFlags.fromJS(ctx, flags, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid flags",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "fd")) |flags| {
|
|
fd = JSC.Node.fileDescriptorFromJS(ctx, flags, exception) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid file descriptor",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "autoClose")) |autoClose| {
|
|
stream.autoClose = autoClose.toBoolean();
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "emitClose")) |emitClose| {
|
|
stream.emitClose = emitClose.toBoolean();
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "start")) |start| {
|
|
stream.start = start.coerce(i32, ctx);
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "end")) |end| {
|
|
stream.end = end.coerce(i32, ctx);
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "highWaterMark")) |highwaterMark| {
|
|
stream.highwater_mark = highwaterMark.toU32();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fd.isValid()) {
|
|
stream.file = .{ .fd = fd };
|
|
} else if (path) |path_| {
|
|
stream.file = .{ .path = path_ };
|
|
} else {
|
|
JSC.throwInvalidArguments("Missing path or file descriptor", .{}, ctx, exception);
|
|
return null;
|
|
}
|
|
return stream;
|
|
}
|
|
};
|
|
|
|
pub const CreateWriteStream = struct {
|
|
file: PathOrFileDescriptor,
|
|
flags: FileSystemFlags = FileSystemFlags.w,
|
|
encoding: Encoding = Encoding.utf8,
|
|
mode: Mode = default_permission,
|
|
autoClose: bool = true,
|
|
emitClose: bool = true,
|
|
start: i32 = 0,
|
|
highwater_mark: u32 = 256 * 1024,
|
|
global_object: *JSC.JSGlobalObject,
|
|
|
|
pub fn deinit(this: @This()) void {
|
|
this.file.deinit();
|
|
}
|
|
|
|
pub fn copyToState(this: CreateWriteStream, state: *JSC.Node.Writable.State) void {
|
|
state.encoding = this.encoding;
|
|
state.highwater_mark = this.highwater_mark;
|
|
state.start = this.start;
|
|
state.emit_close = this.emitClose;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CreateWriteStream {
|
|
const path = PathLike.fromJS(ctx, arguments, exception);
|
|
if (exception.* != null) return null;
|
|
if (path == null) arguments.eat();
|
|
|
|
var stream = CreateWriteStream{
|
|
.file = undefined,
|
|
.global_object = ctx.ptr(),
|
|
};
|
|
var fd: FileDescriptor = bun.invalid_fd;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isString()) {
|
|
stream.encoding = Encoding.fromJS(arg, ctx.ptr()) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
} else if (arg.isObject()) {
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "mode")) |mode_| {
|
|
stream.mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid mode",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "encoding")) |encoding| {
|
|
stream.encoding = Encoding.fromJS(encoding, ctx.ptr()) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid encoding",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getTruthy(ctx.ptr(), "flags")) |flags| {
|
|
stream.flags = FileSystemFlags.fromJS(ctx, flags, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid flags",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "fd")) |flags| {
|
|
fd = JSC.Node.fileDescriptorFromJS(ctx, flags, exception) orelse {
|
|
if (exception.* != null) {
|
|
JSC.throwInvalidArguments(
|
|
"Invalid file descriptor",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "autoClose")) |autoClose| {
|
|
stream.autoClose = autoClose.toBoolean();
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "emitClose")) |emitClose| {
|
|
stream.emitClose = emitClose.toBoolean();
|
|
}
|
|
|
|
if (arg.getIfPropertyExists(ctx.ptr(), "start")) |start| {
|
|
stream.start = start.toInt32();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fd != bun.invalid_fd) {
|
|
stream.file = .{ .fd = fd };
|
|
} else if (path) |path_| {
|
|
stream.file = .{ .path = path_ };
|
|
} else {
|
|
JSC.throwInvalidArguments("Missing path or file descriptor", .{}, ctx, exception);
|
|
return null;
|
|
}
|
|
return stream;
|
|
}
|
|
};
|
|
|
|
pub const FdataSync = struct {
|
|
fd: FileDescriptor,
|
|
|
|
pub fn deinit(_: FdataSync) void {}
|
|
pub fn toThreadSafe(self: *const @This()) void {
|
|
_ = self;
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FdataSync {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return FdataSync{ .fd = fd };
|
|
}
|
|
};
|
|
|
|
pub const CopyFile = struct {
|
|
src: PathLike,
|
|
dest: PathLike,
|
|
mode: Constants.Copyfile,
|
|
|
|
pub fn deinit(this: CopyFile) void {
|
|
this.src.deinit();
|
|
this.dest.deinit();
|
|
}
|
|
|
|
pub fn toThreadSafe(this: *CopyFile) void {
|
|
this.src.toThreadSafe();
|
|
this.dest.toThreadSafe();
|
|
}
|
|
|
|
pub fn deinitAndUnprotect(this: *CopyFile) void {
|
|
this.src.deinitAndUnprotect();
|
|
this.dest.deinitAndUnprotect();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CopyFile {
|
|
const src = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"src must be a string or buffer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const dest = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
src.deinit();
|
|
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"dest must be a string or buffer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var mode: i32 = 0;
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isNumber()) {
|
|
mode = arg.coerce(i32, ctx);
|
|
}
|
|
}
|
|
|
|
return CopyFile{
|
|
.src = src,
|
|
.dest = dest,
|
|
.mode = @enumFromInt(mode),
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Cp = struct {
|
|
src: PathLike,
|
|
dest: PathLike,
|
|
flags: Flags,
|
|
|
|
const Flags = struct {
|
|
mode: Constants.Copyfile,
|
|
recursive: bool,
|
|
errorOnExist: bool,
|
|
force: bool,
|
|
};
|
|
|
|
fn deinit(this: Cp) void {
|
|
this.src.deinit();
|
|
this.dest.deinit();
|
|
}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Cp {
|
|
const src = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"src must be a string or buffer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
const dest = PathLike.fromJS(ctx, arguments, exception) orelse {
|
|
defer src.deinit();
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"dest must be a string or buffer",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
var recursive: bool = false;
|
|
var errorOnExist: bool = false;
|
|
var force: bool = true;
|
|
var mode: i32 = 0;
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
recursive = arg.toBoolean();
|
|
}
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
errorOnExist = arg.toBoolean();
|
|
}
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
force = arg.toBoolean();
|
|
}
|
|
|
|
if (arguments.next()) |arg| {
|
|
arguments.eat();
|
|
if (arg.isNumber()) {
|
|
mode = arg.coerce(i32, ctx);
|
|
}
|
|
}
|
|
|
|
return Cp{
|
|
.src = src,
|
|
.dest = dest,
|
|
.flags = .{
|
|
.mode = @enumFromInt(mode),
|
|
.recursive = recursive,
|
|
.errorOnExist = errorOnExist,
|
|
.force = force,
|
|
},
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const WriteEv = struct {
|
|
fd: FileDescriptor,
|
|
buffers: []const ArrayBuffer,
|
|
position: ReadPosition,
|
|
};
|
|
|
|
pub const ReadEv = struct {
|
|
fd: FileDescriptor,
|
|
buffers: []ArrayBuffer,
|
|
position: ReadPosition,
|
|
};
|
|
|
|
pub const UnwatchFile = void;
|
|
pub const Watch = JSC.Node.FSWatcher.Arguments;
|
|
pub const WatchFile = JSC.Node.StatWatcher.Arguments;
|
|
pub const Fsync = struct {
|
|
fd: FileDescriptor,
|
|
|
|
pub fn deinit(_: Fsync) void {}
|
|
pub fn toThreadSafe(_: *const @This()) void {}
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fsync {
|
|
const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"File descriptor is required",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
}, exception) orelse {
|
|
if (exception.* == null) {
|
|
JSC.throwInvalidArguments(
|
|
"fd must be a number",
|
|
.{},
|
|
ctx,
|
|
exception,
|
|
);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
if (exception.* != null) return null;
|
|
|
|
return Fsync{ .fd = fd };
|
|
}
|
|
};
|
|
};
|
|
|
|
pub const StatOrNotFound = union(enum) {
|
|
stats: Stats,
|
|
not_found: void,
|
|
|
|
pub fn toJS(this: *StatOrNotFound, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
return switch (this.*) {
|
|
.stats => this.stats.toJS(globalObject),
|
|
.not_found => JSC.JSValue.undefined,
|
|
};
|
|
}
|
|
|
|
pub fn toJSNewlyCreated(this: *const StatOrNotFound, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
return switch (this.*) {
|
|
.stats => this.stats.toJSNewlyCreated(globalObject),
|
|
.not_found => JSC.JSValue.undefined,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const StringOrUndefined = union(enum) {
|
|
string: bun.String,
|
|
none: void,
|
|
|
|
pub fn toJS(this: *const StringOrUndefined, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
return switch (this.*) {
|
|
.string => this.string.toJS(globalObject),
|
|
.none => JSC.JSValue.undefined,
|
|
};
|
|
}
|
|
};
|
|
|
|
const Return = struct {
|
|
pub const Access = void;
|
|
pub const AppendFile = void;
|
|
pub const Close = void;
|
|
pub const CopyFile = void;
|
|
pub const Cp = void;
|
|
pub const Exists = bool;
|
|
pub const Fchmod = void;
|
|
pub const Chmod = void;
|
|
pub const Fchown = void;
|
|
pub const Fdatasync = void;
|
|
pub const Fstat = Stats;
|
|
pub const Rm = void;
|
|
pub const Fsync = void;
|
|
pub const Ftruncate = void;
|
|
pub const Futimes = void;
|
|
pub const Lchmod = void;
|
|
pub const Lchown = void;
|
|
pub const Link = void;
|
|
pub const Lstat = StatOrNotFound;
|
|
pub const Mkdir = StringOrUndefined;
|
|
pub const Mkdtemp = JSC.ZigString;
|
|
pub const Open = FDImpl;
|
|
pub const WriteFile = void;
|
|
pub const Readv = Read;
|
|
pub const Read = struct {
|
|
bytes_read: u52,
|
|
|
|
pub fn toJS(this: Read, _: JSC.C.JSContextRef) JSC.JSValue {
|
|
return JSC.JSValue.jsNumberFromUint64(this.bytes_read);
|
|
}
|
|
};
|
|
pub const ReadPromise = struct {
|
|
bytes_read: u52,
|
|
buffer_val: JSC.JSValue = JSC.JSValue.zero,
|
|
const fields = .{
|
|
.bytesRead = JSC.ZigString.init("bytesRead"),
|
|
.buffer = JSC.ZigString.init("buffer"),
|
|
};
|
|
pub fn toJS(this: *const ReadPromise, ctx: *JSC.JSGlobalObject) JSC.JSValue {
|
|
defer if (!this.buffer_val.isEmptyOrUndefinedOrNull())
|
|
this.buffer_val.unprotect();
|
|
|
|
return JSC.JSValue.createObject2(
|
|
ctx,
|
|
&fields.bytesRead,
|
|
&fields.buffer,
|
|
JSC.JSValue.jsNumberFromUint64(@as(u52, @intCast(@min(std.math.maxInt(u52), this.bytes_read)))),
|
|
this.buffer_val,
|
|
);
|
|
}
|
|
};
|
|
|
|
pub const WritePromise = struct {
|
|
bytes_written: u52,
|
|
buffer: StringOrBuffer,
|
|
buffer_val: JSC.JSValue = JSC.JSValue.zero,
|
|
const fields = .{
|
|
.bytesWritten = JSC.ZigString.init("bytesWritten"),
|
|
.buffer = JSC.ZigString.init("buffer"),
|
|
};
|
|
|
|
// Excited for the issue that's like "cannot read file bigger than 2 GB"
|
|
pub fn toJS(this: *const WritePromise, globalObject: JSC.C.JSContextRef) JSC.C.JSValueRef {
|
|
defer if (!this.buffer_val.isEmptyOrUndefinedOrNull())
|
|
this.buffer_val.unprotect();
|
|
|
|
return JSC.JSValue.createObject2(
|
|
globalObject,
|
|
&fields.bytesWritten,
|
|
&fields.buffer,
|
|
JSC.JSValue.jsNumberFromUint64(@as(u52, @intCast(@min(std.math.maxInt(u52), this.bytes_written)))),
|
|
if (this.buffer == .buffer)
|
|
this.buffer_val
|
|
else
|
|
this.buffer.toJS(globalObject),
|
|
);
|
|
}
|
|
};
|
|
pub const Write = struct {
|
|
bytes_written: u52,
|
|
const fields = .{
|
|
.bytesWritten = JSC.ZigString.init("bytesWritten"),
|
|
};
|
|
|
|
// Excited for the issue that's like "cannot read file bigger than 2 GB"
|
|
pub fn toJS(this: *const Write, _: *JSC.JSGlobalObject) JSC.JSValue {
|
|
return JSC.JSValue.jsNumberFromUint64(this.bytes_written);
|
|
}
|
|
};
|
|
|
|
pub const Readdir = union(Tag) {
|
|
with_file_types: []Dirent,
|
|
buffers: []Buffer,
|
|
files: []const bun.String,
|
|
|
|
pub const Tag = enum {
|
|
with_file_types,
|
|
buffers,
|
|
files,
|
|
};
|
|
|
|
pub fn toJS(this: Readdir, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
|
|
switch (this) {
|
|
.with_file_types => {
|
|
defer bun.default_allocator.free(this.with_file_types);
|
|
return JSC.toJS(globalObject, []Dirent, this.with_file_types, .temporary);
|
|
},
|
|
.buffers => {
|
|
defer bun.default_allocator.free(this.buffers);
|
|
return JSC.toJS(globalObject, []Buffer, this.buffers, .temporary);
|
|
},
|
|
.files => {
|
|
// automatically freed
|
|
return JSC.toJS(globalObject, []const bun.String, this.files, .temporary);
|
|
},
|
|
}
|
|
}
|
|
};
|
|
pub const ReadFile = JSC.Node.StringOrBuffer;
|
|
pub const ReadFileWithOptions = union(enum) {
|
|
string: string,
|
|
buffer: JSC.Node.Buffer,
|
|
null_terminated: [:0]const u8,
|
|
};
|
|
pub const Readlink = JSC.Node.StringOrBuffer;
|
|
pub const Realpath = JSC.Node.StringOrBuffer;
|
|
pub const RealpathNative = Realpath;
|
|
pub const Rename = void;
|
|
pub const Rmdir = void;
|
|
pub const Stat = StatOrNotFound;
|
|
|
|
pub const Symlink = void;
|
|
pub const Truncate = void;
|
|
pub const Unlink = void;
|
|
pub const UnwatchFile = void;
|
|
pub const Watch = JSC.JSValue;
|
|
pub const WatchFile = JSC.JSValue;
|
|
pub const Utimes = void;
|
|
|
|
pub const Chown = void;
|
|
pub const Lutimes = void;
|
|
|
|
pub const Writev = Write;
|
|
};
|
|
|
|
/// Bun's implementation of the Node.js "fs" module
|
|
/// https://nodejs.org/api/fs.html
|
|
/// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/fs.d.ts
|
|
pub const NodeFS = struct {
|
|
/// Buffer to store a temporary file path that might appear in a returned error message.
|
|
///
|
|
/// We want to avoid allocating a new path buffer for every error message so that JSC can clone + GC it.
|
|
/// That means a stack-allocated buffer won't suffice. Instead, we re-use
|
|
/// the heap allocated buffer on the NodefS struct
|
|
sync_error_buf: [bun.MAX_PATH_BYTES]u8 = undefined,
|
|
vm: ?*JSC.VirtualMachine = null,
|
|
|
|
pub const ReturnType = Return;
|
|
|
|
pub fn access(this: *NodeFS, args: Arguments.Access, comptime _: Flavor) Maybe(Return.Access) {
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
if (Environment.isWindows) {
|
|
return Syscall.access(path, @intFromEnum(args.mode));
|
|
}
|
|
const rc = Syscall.system.access(path, @intFromEnum(args.mode));
|
|
return Maybe(Return.Access).errnoSysP(rc, .access, path) orelse Maybe(Return.Access).success;
|
|
}
|
|
|
|
pub fn appendFile(this: *NodeFS, args: Arguments.AppendFile, comptime flavor: Flavor) Maybe(Return.AppendFile) {
|
|
_ = flavor;
|
|
var data = args.data.slice();
|
|
|
|
switch (args.file) {
|
|
.fd => |fd| {
|
|
while (data.len > 0) {
|
|
const written = switch (Syscall.write(fd, data)) {
|
|
.result => |result| result,
|
|
.err => |err| return .{ .err = err },
|
|
};
|
|
data = data[written..];
|
|
}
|
|
|
|
return Maybe(Return.AppendFile).success;
|
|
},
|
|
.path => |path_| {
|
|
const path = path_.sliceZ(&this.sync_error_buf);
|
|
|
|
const fd = switch (Syscall.open(path, @intFromEnum(FileSystemFlags.a), 0o666)) {
|
|
.result => |result| result,
|
|
.err => |err| return .{ .err = err },
|
|
};
|
|
|
|
defer {
|
|
_ = Syscall.close(fd);
|
|
}
|
|
|
|
while (data.len > 0) {
|
|
const written = switch (Syscall.write(fd, data)) {
|
|
.result => |result| result,
|
|
.err => |err| return .{ .err = err },
|
|
};
|
|
data = data[written..];
|
|
}
|
|
|
|
return Maybe(Return.AppendFile).success;
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn close(_: *NodeFS, args: Arguments.Close, comptime flavor: Flavor) Maybe(Return.Close) {
|
|
_ = flavor;
|
|
return if (Syscall.close(args.fd)) |err| .{ .err = err } else Maybe(Return.Close).success;
|
|
}
|
|
|
|
// since we use a 64 KB stack buffer, we should not let this function get inlined
|
|
pub noinline fn copyFileUsingReadWriteLoop(src: [:0]const u8, dest: [:0]const u8, src_fd: FileDescriptor, dest_fd: FileDescriptor, stat_size: usize, wrote: *u64) Maybe(Return.CopyFile) {
|
|
var stack_buf: [64 * 1024]u8 = undefined;
|
|
var buf_to_free: []u8 = &[_]u8{};
|
|
var buf: []u8 = &stack_buf;
|
|
|
|
maybe_allocate_large_temp_buf: {
|
|
if (stat_size > stack_buf.len * 16) {
|
|
// Don't allocate more than 8 MB at a time
|
|
const clamped_size: usize = @min(stat_size, 8 * 1024 * 1024);
|
|
|
|
const buf_ = bun.default_allocator.alloc(u8, clamped_size) catch break :maybe_allocate_large_temp_buf;
|
|
buf = buf_;
|
|
buf_to_free = buf_;
|
|
}
|
|
}
|
|
|
|
defer {
|
|
if (buf_to_free.len > 0) bun.default_allocator.free(buf_to_free);
|
|
}
|
|
|
|
var remain = @as(u64, @intCast(@max(stat_size, 0)));
|
|
toplevel: while (remain > 0) {
|
|
const amt = switch (Syscall.read(src_fd, buf[0..@min(buf.len, remain)])) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = if (src.len > 0) err.withPath(src) else err },
|
|
};
|
|
// 0 == EOF
|
|
if (amt == 0) {
|
|
break :toplevel;
|
|
}
|
|
wrote.* += amt;
|
|
remain -|= amt;
|
|
|
|
var slice = buf[0..amt];
|
|
while (slice.len > 0) {
|
|
const written = switch (Syscall.write(dest_fd, slice)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = if (dest.len > 0) err.withPath(dest) else err },
|
|
};
|
|
if (written == 0) break :toplevel;
|
|
slice = slice[written..];
|
|
}
|
|
} else {
|
|
outer: while (true) {
|
|
const amt = switch (Syscall.read(src_fd, buf)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = if (src.len > 0) err.withPath(src) else err },
|
|
};
|
|
// we don't know the size
|
|
// so we just go forever until we get an EOF
|
|
if (amt == 0) {
|
|
break;
|
|
}
|
|
wrote.* += amt;
|
|
|
|
var slice = buf[0..amt];
|
|
while (slice.len > 0) {
|
|
const written = switch (Syscall.write(dest_fd, slice)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = if (dest.len > 0) err.withPath(dest) else err },
|
|
};
|
|
slice = slice[written..];
|
|
if (written == 0) break :outer;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Maybe(Return.CopyFile).success;
|
|
}
|
|
|
|
// copy_file_range() is frequently not supported across devices, such as tmpfs.
|
|
// This is relevant for `bun install`
|
|
// However, sendfile() is supported across devices.
|
|
// Only on Linux. There are constraints though. It cannot be used if the file type does not support
|
|
pub noinline fn copyFileUsingSendfileOnLinuxWithReadWriteFallback(src: [:0]const u8, dest: [:0]const u8, src_fd: FileDescriptor, dest_fd: FileDescriptor, stat_size: usize, wrote: *u64) Maybe(Return.CopyFile) {
|
|
while (true) {
|
|
const amt = switch (bun.sys.sendfile(src_fd, dest_fd, std.math.maxInt(i32) - 1)) {
|
|
.err => {
|
|
return copyFileUsingReadWriteLoop(src, dest, src_fd, dest_fd, stat_size, wrote);
|
|
},
|
|
.result => |amount| amount,
|
|
};
|
|
|
|
wrote.* += amt;
|
|
if (amt == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return Maybe(Return.CopyFile).success;
|
|
}
|
|
|
|
/// https://github.com/libuv/libuv/pull/2233
|
|
/// https://github.com/pnpm/pnpm/issues/2761
|
|
/// https://github.com/libuv/libuv/pull/2578
|
|
/// https://github.com/nodejs/node/issues/34624
|
|
pub fn copyFile(this: *NodeFS, args: Arguments.CopyFile, comptime flavor: Flavor) Maybe(Return.CopyFile) {
|
|
_ = flavor;
|
|
const ret = Maybe(Return.CopyFile);
|
|
|
|
// TODO: do we need to fchown?
|
|
if (comptime Environment.isMac) {
|
|
var src_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
var dest_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
|
|
const src = args.src.sliceZ(&src_buf);
|
|
const dest = args.dest.sliceZ(&dest_buf);
|
|
|
|
if (args.mode.isForceClone()) {
|
|
// https://www.manpagez.com/man/2/clonefile/
|
|
return ret.errnoSysP(C.clonefile(src, dest, 0), .clonefile, src) orelse ret.success;
|
|
} else {
|
|
const stat_ = switch (Syscall.stat(src)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = err.withPath(src) },
|
|
};
|
|
|
|
if (!os.S.ISREG(stat_.mode)) {
|
|
return Maybe(Return.CopyFile){ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOTSUP),
|
|
.syscall = .copyfile,
|
|
} };
|
|
}
|
|
|
|
// 64 KB is about the break-even point for clonefile() to be worth it
|
|
// at least, on an M1 with an NVME SSD.
|
|
if (stat_.size > 128 * 1024) {
|
|
if (!args.mode.shouldntOverwrite()) {
|
|
// clonefile() will fail if it already exists
|
|
_ = Syscall.unlink(dest);
|
|
}
|
|
|
|
if (ret.errnoSysP(C.clonefile(src, dest, 0), .clonefile, src) == null) {
|
|
_ = C.chmod(dest, stat_.mode);
|
|
return ret.success;
|
|
}
|
|
} else {
|
|
const src_fd = switch (Syscall.open(src, std.os.O.RDONLY, 0o644)) {
|
|
.result => |result| result,
|
|
.err => |err| return .{ .err = err.withPath(args.src.slice()) },
|
|
};
|
|
defer {
|
|
_ = Syscall.close(src_fd);
|
|
}
|
|
|
|
var flags: Mode = std.os.O.CREAT | std.os.O.WRONLY;
|
|
var wrote: usize = 0;
|
|
if (args.mode.shouldntOverwrite()) {
|
|
flags |= std.os.O.EXCL;
|
|
}
|
|
|
|
const dest_fd = switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = err.withPath(args.dest.slice()) },
|
|
};
|
|
defer {
|
|
_ = std.c.ftruncate(dest_fd.int(), @as(std.c.off_t, @intCast(@as(u63, @truncate(wrote)))));
|
|
_ = C.fchmod(dest_fd.int(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
}
|
|
|
|
return copyFileUsingReadWriteLoop(src, dest, src_fd, dest_fd, @intCast(@max(stat_.size, 0)), &wrote);
|
|
}
|
|
}
|
|
|
|
// we fallback to copyfile() when the file is > 128 KB and clonefile fails
|
|
// clonefile() isn't supported on all devices
|
|
// nor is it supported across devices
|
|
var mode: Mode = C.darwin.COPYFILE_ACL | C.darwin.COPYFILE_DATA;
|
|
if (args.mode.shouldntOverwrite()) {
|
|
mode |= C.darwin.COPYFILE_EXCL;
|
|
}
|
|
|
|
return ret.errnoSysP(C.copyfile(src, dest, null, mode), .copyfile, src) orelse ret.success;
|
|
}
|
|
|
|
if (comptime Environment.isLinux) {
|
|
var src_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
var dest_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
const src = args.src.sliceZ(&src_buf);
|
|
const dest = args.dest.sliceZ(&dest_buf);
|
|
|
|
const src_fd = switch (Syscall.open(src, std.os.O.RDONLY, 0o644)) {
|
|
.result => |result| result,
|
|
.err => |err| return .{ .err = err },
|
|
};
|
|
defer {
|
|
_ = Syscall.close(src_fd);
|
|
}
|
|
|
|
const stat_: linux.Stat = switch (Syscall.fstat(src_fd)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = err },
|
|
};
|
|
|
|
if (!os.S.ISREG(stat_.mode)) {
|
|
return Maybe(Return.CopyFile){ .err = .{ .errno = @intFromEnum(C.SystemErrno.ENOTSUP), .syscall = .copyfile } };
|
|
}
|
|
|
|
var flags: Mode = std.os.O.CREAT | std.os.O.WRONLY;
|
|
var wrote: usize = 0;
|
|
if (args.mode.shouldntOverwrite()) {
|
|
flags |= std.os.O.EXCL;
|
|
}
|
|
|
|
const dest_fd = switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = err },
|
|
};
|
|
|
|
var size: usize = @intCast(@max(stat_.size, 0));
|
|
|
|
// https://manpages.debian.org/testing/manpages-dev/ioctl_ficlone.2.en.html
|
|
if (args.mode.isForceClone()) {
|
|
if (ret.errnoSysP(bun.C.linux.ioctl_ficlone(dest_fd, src_fd), .ioctl_ficlone, dest)) |err| {
|
|
_ = Syscall.close(dest_fd);
|
|
// This is racey, but it's the best we can do
|
|
_ = bun.sys.unlink(dest);
|
|
return err;
|
|
}
|
|
_ = C.fchmod(dest_fd.cast(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
return ret.success;
|
|
}
|
|
|
|
// If we know it's a regular file and ioctl_ficlone is available, attempt to use it.
|
|
if (os.S.ISREG(stat_.mode) and bun.can_use_ioctl_ficlone()) {
|
|
const rc = bun.C.linux.ioctl_ficlone(dest_fd, src_fd);
|
|
if (rc == 0) {
|
|
_ = C.fchmod(dest_fd.cast(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
return ret.success;
|
|
}
|
|
|
|
// If this fails for any reason, we say it's disabled
|
|
// We don't want to add the system call overhead of running this function on a lot of files that don't support it
|
|
bun.disable_ioctl_ficlone();
|
|
}
|
|
|
|
defer {
|
|
_ = linux.ftruncate(dest_fd.cast(), @as(i64, @intCast(@as(u63, @truncate(wrote)))));
|
|
_ = linux.fchmod(dest_fd.cast(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
}
|
|
|
|
var off_in_copy = @as(i64, @bitCast(@as(u64, 0)));
|
|
var off_out_copy = @as(i64, @bitCast(@as(u64, 0)));
|
|
|
|
if (!bun.canUseCopyFileRangeSyscall()) {
|
|
return copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
}
|
|
|
|
if (size == 0) {
|
|
// copy until EOF
|
|
while (true) {
|
|
// Linux Kernel 5.3 or later
|
|
// Not supported in gVisor
|
|
const written = linux.copy_file_range(src_fd.cast(), &off_in_copy, dest_fd.cast(), &off_out_copy, std.mem.page_size, 0);
|
|
if (ret.errnoSysP(written, .copy_file_range, dest)) |err| {
|
|
return switch (err.getErrno()) {
|
|
.INTR => continue,
|
|
inline .XDEV, .NOSYS => |errno| brk: {
|
|
if (comptime errno == .NOSYS) {
|
|
bun.disableCopyFileRangeSyscall();
|
|
}
|
|
break :brk copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
},
|
|
else => return err,
|
|
};
|
|
}
|
|
// wrote zero bytes means EOF
|
|
if (written == 0) break;
|
|
wrote +|= written;
|
|
}
|
|
} else {
|
|
while (size > 0) {
|
|
// Linux Kernel 5.3 or later
|
|
// Not supported in gVisor
|
|
const written = linux.copy_file_range(src_fd.cast(), &off_in_copy, dest_fd.cast(), &off_out_copy, size, 0);
|
|
if (ret.errnoSysP(written, .copy_file_range, dest)) |err| {
|
|
return switch (err.getErrno()) {
|
|
.INTR => continue,
|
|
inline .XDEV, .NOSYS => |errno| brk: {
|
|
if (comptime errno == .NOSYS) {
|
|
bun.disableCopyFileRangeSyscall();
|
|
}
|
|
break :brk copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
},
|
|
else => return err,
|
|
};
|
|
}
|
|
// wrote zero bytes means EOF
|
|
if (written == 0) break;
|
|
wrote +|= written;
|
|
size -|= written;
|
|
}
|
|
}
|
|
|
|
return ret.success;
|
|
}
|
|
|
|
if (comptime Environment.isWindows) {
|
|
if (args.mode.isForceClone()) {
|
|
return Maybe(Return.CopyFile).todo();
|
|
}
|
|
|
|
var src_buf: bun.WPathBuffer = undefined;
|
|
var dest_buf: bun.WPathBuffer = undefined;
|
|
const src = strings.toWPathNormalizeAutoExtend(&src_buf, args.src.sliceZ(&this.sync_error_buf));
|
|
const dest = strings.toWPathNormalizeAutoExtend(&dest_buf, args.dest.sliceZ(&this.sync_error_buf));
|
|
if (windows.CopyFileW(src.ptr, dest.ptr, if (args.mode.shouldntOverwrite()) 1 else 0) == windows.FALSE) {
|
|
if (ret.errnoSysP(0, .copyfile, args.src.slice())) |rest| {
|
|
return rest;
|
|
}
|
|
}
|
|
|
|
return ret.success;
|
|
}
|
|
|
|
return Maybe(Return.CopyFile).todo();
|
|
}
|
|
|
|
pub fn exists(this: *NodeFS, args: Arguments.Exists, comptime flavor: Flavor) Maybe(Return.Exists) {
|
|
_ = flavor;
|
|
const Ret = Maybe(Return.Exists);
|
|
const path = args.path orelse return Ret{ .result = false };
|
|
const slice = path.sliceZ(&this.sync_error_buf);
|
|
|
|
// Use libuv access on windows
|
|
if (Environment.isWindows) {
|
|
return .{ .result = Syscall.access(slice, std.os.F_OK) != .err };
|
|
}
|
|
|
|
// access() may not work correctly on NFS file systems with UID
|
|
// mapping enabled, because UID mapping is done on the server and
|
|
// hidden from the client, which checks permissions. Similar
|
|
// problems can occur to FUSE mounts.
|
|
const rc = (system.access(slice, std.os.F_OK));
|
|
return Ret{ .result = rc == 0 };
|
|
}
|
|
|
|
pub fn chown(this: *NodeFS, args: Arguments.Chown, comptime flavor: Flavor) Maybe(Return.Chown) {
|
|
_ = flavor;
|
|
if (comptime Environment.isWindows) {
|
|
return Syscall.chown(args.path.sliceZ(&this.sync_error_buf), args.uid, args.gid);
|
|
}
|
|
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
return Syscall.chown(path, args.uid, args.gid);
|
|
}
|
|
|
|
/// This should almost never be async
|
|
pub fn chmod(this: *NodeFS, args: Arguments.Chmod, comptime flavor: Flavor) Maybe(Return.Chmod) {
|
|
_ = flavor;
|
|
if (comptime Environment.isWindows) {
|
|
return Syscall.chmod(args.path.sliceZ(&this.sync_error_buf), args.mode);
|
|
}
|
|
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
return Maybe(Return.Chmod).errnoSysP(C.chmod(path, args.mode), .chmod, path) orelse
|
|
Maybe(Return.Chmod).success;
|
|
}
|
|
|
|
/// This should almost never be async
|
|
pub fn fchmod(_: *NodeFS, args: Arguments.FChmod, comptime flavor: Flavor) Maybe(Return.Fchmod) {
|
|
_ = flavor;
|
|
return Syscall.fchmod(args.fd, args.mode);
|
|
}
|
|
|
|
pub fn fchown(_: *NodeFS, args: Arguments.Fchown, comptime flavor: Flavor) Maybe(Return.Fchown) {
|
|
_ = flavor;
|
|
if (comptime Environment.isWindows) {
|
|
return Syscall.fchown(args.fd, args.uid, args.gid);
|
|
}
|
|
|
|
return Maybe(Return.Fchown).errnoSys(C.fchown(args.fd.int(), args.uid, args.gid), .fchown) orelse
|
|
Maybe(Return.Fchown).success;
|
|
}
|
|
|
|
pub fn fdatasync(_: *NodeFS, args: Arguments.FdataSync, comptime _: Flavor) Maybe(Return.Fdatasync) {
|
|
if (Environment.isWindows) {
|
|
return Syscall.fdatasync(args.fd);
|
|
}
|
|
return Maybe(Return.Fdatasync).errnoSys(system.fdatasync(args.fd.int()), .fdatasync) orelse
|
|
Maybe(Return.Fdatasync).success;
|
|
}
|
|
|
|
pub fn fstat(_: *NodeFS, args: Arguments.Fstat, comptime _: Flavor) Maybe(Return.Fstat) {
|
|
return switch (Syscall.fstat(args.fd)) {
|
|
.result => |result| Maybe(Return.Fstat){ .result = Stats.init(result, false) },
|
|
.err => |err| Maybe(Return.Fstat){ .err = err },
|
|
};
|
|
}
|
|
|
|
pub fn fsync(_: *NodeFS, args: Arguments.Fsync, comptime _: Flavor) Maybe(Return.Fsync) {
|
|
if (Environment.isWindows) {
|
|
return Syscall.fsync(args.fd);
|
|
}
|
|
return Maybe(Return.Fsync).errnoSys(system.fsync(args.fd.int()), .fsync) orelse
|
|
Maybe(Return.Fsync).success;
|
|
}
|
|
|
|
pub fn ftruncateSync(args: Arguments.FTruncate) Maybe(Return.Ftruncate) {
|
|
return Syscall.ftruncate(args.fd, args.len orelse 0);
|
|
}
|
|
|
|
pub fn ftruncate(_: *NodeFS, args: Arguments.FTruncate, comptime flavor: Flavor) Maybe(Return.Ftruncate) {
|
|
_ = flavor;
|
|
return ftruncateSync(args);
|
|
}
|
|
|
|
pub fn futimes(_: *NodeFS, args: Arguments.Futimes, comptime _: Flavor) Maybe(Return.Futimes) {
|
|
if (comptime Environment.isWindows) {
|
|
var req: uv.fs_t = uv.fs_t.uninitialized;
|
|
defer req.deinit();
|
|
const rc = uv.uv_fs_futime(uv.Loop.get(), &req, bun.uvfdcast(args.fd), args.mtime, args.atime, null);
|
|
return if (rc.errno()) |e|
|
|
Maybe(Return.Futimes){ .err = .{ .errno = e, .syscall = .futime } }
|
|
else
|
|
Maybe(Return.Futimes).success;
|
|
}
|
|
|
|
var times = [2]std.os.timespec{
|
|
args.mtime,
|
|
args.atime,
|
|
};
|
|
|
|
return if (Maybe(Return.Futimes).errnoSys(system.futimens(args.fd.int(), ×), .futimens)) |err|
|
|
err
|
|
else
|
|
Maybe(Return.Futimes).success;
|
|
}
|
|
|
|
pub fn lchmod(this: *NodeFS, args: Arguments.LCHmod, comptime flavor: Flavor) Maybe(Return.Lchmod) {
|
|
_ = flavor;
|
|
if (comptime Environment.isWindows) {
|
|
return Maybe(Return.Lchmod).todo();
|
|
}
|
|
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
return Maybe(Return.Lchmod).errnoSysP(C.lchmod(path, args.mode), .lchmod, path) orelse
|
|
Maybe(Return.Lchmod).success;
|
|
}
|
|
|
|
pub fn lchown(this: *NodeFS, args: Arguments.LChown, comptime flavor: Flavor) Maybe(Return.Lchown) {
|
|
_ = flavor;
|
|
if (comptime Environment.isWindows) {
|
|
return Maybe(Return.Lchown).todo();
|
|
}
|
|
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
return Maybe(Return.Lchown).errnoSysP(C.lchown(path, args.uid, args.gid), .lchown, path) orelse
|
|
Maybe(Return.Lchown).success;
|
|
}
|
|
|
|
pub fn link(this: *NodeFS, args: Arguments.Link, comptime _: Flavor) Maybe(Return.Link) {
|
|
var new_path_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
const from = args.old_path.sliceZ(&this.sync_error_buf);
|
|
const to = args.new_path.sliceZ(&new_path_buf);
|
|
|
|
if (Environment.isWindows) {
|
|
return Syscall.link(from, to);
|
|
}
|
|
|
|
return Maybe(Return.Link).errnoSysP(system.link(from, to, 0), .link, from) orelse
|
|
Maybe(Return.Link).success;
|
|
}
|
|
|
|
pub fn lstat(this: *NodeFS, args: Arguments.Lstat, comptime _: Flavor) Maybe(Return.Lstat) {
|
|
return switch (Syscall.lstat(
|
|
args.path.sliceZ(
|
|
&this.sync_error_buf,
|
|
),
|
|
)) {
|
|
.result => |result| Maybe(Return.Lstat){ .result = .{ .stats = Stats.init(result, args.big_int) } },
|
|
.err => |err| brk: {
|
|
if (!args.throw_if_no_entry and err.getErrno() == .NOENT) {
|
|
return Maybe(Return.Lstat){ .result = .{ .not_found = {} } };
|
|
}
|
|
break :brk Maybe(Return.Lstat){ .err = err };
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn mkdir(this: *NodeFS, args: Arguments.Mkdir, comptime flavor: Flavor) Maybe(Return.Mkdir) {
|
|
return if (args.recursive) mkdirRecursive(this, args, flavor) else mkdirNonRecursive(this, args, flavor);
|
|
}
|
|
// Node doesn't absolute the path so we don't have to either
|
|
pub fn mkdirNonRecursive(this: *NodeFS, args: Arguments.Mkdir, comptime flavor: Flavor) Maybe(Return.Mkdir) {
|
|
_ = flavor;
|
|
|
|
const path = args.path.sliceZ(&this.sync_error_buf);
|
|
return switch (Syscall.mkdir(path, args.mode)) {
|
|
.result => Maybe(Return.Mkdir){ .result = .{ .none = {} } },
|
|
.err => |err| Maybe(Return.Mkdir){ .err = err },
|
|
};
|
|
}
|
|
|
|
pub const MkdirDummyVTable = struct {
|
|
pub fn onCreateDir(_: @This(), _: bun.OSPathSliceZ) void {
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub fn mkdirRecursive(this: *NodeFS, args: Arguments.Mkdir, comptime flavor: Flavor) Maybe(Return.Mkdir) {
|
|
return mkdirRecursiveImpl(this, args, flavor, MkdirDummyVTable, .{});
|
|
}
|
|
|
|
// TODO: verify this works correctly with unicode codepoints
|
|
pub fn mkdirRecursiveImpl(this: *NodeFS, args: Arguments.Mkdir, comptime flavor: Flavor, comptime Ctx: type, ctx: Ctx) Maybe(Return.Mkdir) {
|
|
_ = flavor;
|
|
var buf: bun.OSPathBuffer = undefined;
|
|
const path: bun.OSPathSliceZ = if (!Environment.isWindows)
|
|
args.path.osPath(&buf)
|
|
else brk: {
|
|
// TODO(@paperdave): clean this up a lot.
|
|
var joined_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
if (std.fs.path.isAbsolute(args.path.slice())) {
|
|
const utf8 = PosixToWinNormalizer.resolveCWDWithExternalBufZ(&joined_buf, args.path.slice()) catch
|
|
return .{ .err = .{ .errno = @intFromEnum(C.SystemErrno.ENOMEM), .syscall = .getcwd } };
|
|
break :brk strings.toWPath(&buf, utf8);
|
|
} else {
|
|
var cwd_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
const cwd = std.os.getcwd(&cwd_buf) catch return .{ .err = .{ .errno = @intFromEnum(C.SystemErrno.ENOMEM), .syscall = .getcwd } };
|
|
break :brk strings.toWPath(&buf, bun.path.joinAbsStringBuf(cwd, &joined_buf, &.{args.path.slice()}, .windows));
|
|
}
|
|
};
|
|
// TODO: remove and make it always a comptime argument
|
|
return switch (args.always_return_none) {
|
|
inline else => |always_return_none| this.mkdirRecursiveOSPathImpl(Ctx, ctx, path, args.mode, !always_return_none),
|
|
};
|
|
}
|
|
|
|
pub fn _isSep(char: bun.OSPathChar) bool {
|
|
return if (Environment.isWindows)
|
|
char == '/' or char == '\\'
|
|
else
|
|
char == '/';
|
|
}
|
|
|
|
pub fn mkdirRecursiveOSPath(this: *NodeFS, path: bun.OSPathSliceZ, mode: Mode, comptime return_path: bool) Maybe(Return.Mkdir) {
|
|
return mkdirRecursiveOSPathImpl(this, MkdirDummyVTable, .{}, path, mode, return_path);
|
|
}
|
|
|
|
pub fn mkdirRecursiveOSPathImpl(
|
|
this: *NodeFS,
|
|
comptime Ctx: type,
|
|
ctx: Ctx,
|
|
path: bun.OSPathSliceZ,
|
|
mode: Mode,
|
|
comptime return_path: bool,
|
|
) Maybe(Return.Mkdir) {
|
|
const VTable = struct {
|
|
pub fn onCreateDir(c: Ctx, dirpath: bun.OSPathSliceZ) void {
|
|
c.onCreateDir(dirpath);
|
|
return;
|
|
}
|
|
};
|
|
|
|
const Char = bun.OSPathChar;
|
|
const len = @as(u16, @truncate(path.len));
|
|
|
|
// First, attempt to create the desired directory
|
|
// If that fails, then walk back up the path until we have a match
|
|
switch (Syscall.mkdirOSPath(path, mode)) {
|
|
.err => |err| {
|
|
switch (err.getErrno()) {
|
|
else => {
|
|
return .{ .err = err.withPath(this.osPathIntoSyncErrorBuf(path[0..len])) };
|
|
},
|
|
.EXIST => {
|
|
return .{ .result = .{ .none = {} } };
|
|
},
|
|
// continue
|
|
.NOENT => {},
|
|
}
|
|
},
|
|
.result => {
|
|
VTable.onCreateDir(ctx, path);
|
|
if (!return_path) {
|
|
return .{ .result = .{ .none = {} } };
|
|
}
|
|
return .{
|
|
.result = .{ .string = bun.String.createFromOSPath(path) },
|
|
};
|
|
},
|
|
}
|
|
|
|
var working_mem: *bun.OSPathBuffer = @alignCast(@ptrCast(&this.sync_error_buf));
|
|
|
|
@memcpy(working_mem[0..len], path[0..len]);
|
|
|
|
var i: u16 = len - 1;
|
|
|
|
// iterate backwards until creating the directory works successfully
|
|
while (i > 0) : (i -= 1) {
|
|
if (_isSep(path[i])) {
|
|
working_mem[i] = 0;
|
|
const parent: [:0]Char = working_mem[0..i :0];
|
|
|
|
switch (Syscall.mkdirOSPath(parent, mode)) {
|
|
.err => |err| {
|
|
working_mem[i] = std.fs.path.sep;
|
|
switch (err.getErrno()) {
|
|
.EXIST => {
|
|
// Handle race condition
|
|
break;
|
|
},
|
|
.NOENT => {
|
|
continue;
|
|
},
|
|
else => return .{ .err = err.withPath(
|
|
if (Environment.isWindows)
|
|
this.osPathIntoSyncErrorBufOverlap(parent)
|
|
else
|
|
parent,
|
|
) },
|
|
}
|
|
},
|
|
.result => {
|
|
VTable.onCreateDir(ctx, parent);
|
|
// We found a parent that worked
|
|
working_mem[i] = std.fs.path.sep;
|
|
break;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
const first_match: u16 = i;
|
|
i += 1;
|
|
// after we find one that works, we go forward _after_ the first working directory
|
|
while (i < len) : (i += 1) {
|
|
if (_isSep(path[i])) {
|
|
working_mem[i] = 0;
|
|
const parent: [:0]Char = working_mem[0..i :0];
|
|
|
|
switch (Syscall.mkdirOSPath(parent, mode)) {
|
|
.err => |err| {
|
|
working_mem[i] = std.fs.path.sep;
|
|
switch (err.getErrno()) {
|
|
// handle the race condition
|
|
.EXIST => {},
|
|
|
|
// NOENT shouldn't happen here
|
|
else => return .{
|
|
.err = err.withPath(this.osPathIntoSyncErrorBuf(path)),
|
|
},
|
|
}
|
|
},
|
|
|
|
.result => {
|
|
VTable.onCreateDir(ctx, parent);
|
|
working_mem[i] = std.fs.path.sep;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
working_mem[len] = 0;
|
|
|
|
// Our final directory will not have a trailing separator
|
|
// so we have to create it once again
|
|
switch (Syscall.mkdirOSPath(working_mem[0..len :0], mode)) {
|
|
.err => |err| {
|
|
switch (err.getErrno()) {
|
|
// handle the race condition
|
|
.EXIST => {},
|
|
|
|
// NOENT shouldn't happen here
|
|
else => return .{
|
|
.err = err.withPath(this.osPathIntoSyncErrorBuf(path)),
|
|
},
|
|
}
|
|
},
|
|
.result => {},
|
|
}
|
|
|
|
VTable.onCreateDir(ctx, working_mem[0..len :0]);
|
|
if (!return_path) {
|
|
return .{ .result = .{ .none = {} } };
|
|
}
|
|
return .{
|
|
.result = .{ .string = bun.String.createFromOSPath(working_mem[0..first_match]) },
|
|
};
|
|
}
|
|
|
|
pub fn mkdtemp(this: *NodeFS, args: Arguments.MkdirTemp, comptime _: Flavor) Maybe(Return.Mkdtemp) {
|
|
var prefix_buf = &this.sync_error_buf;
|
|
const prefix_slice = args.prefix.slice();
|
|
const len = @min(prefix_slice.len, prefix_buf.len -| 7);
|
|
if (len > 0) {
|
|
@memcpy(prefix_buf[0..len], prefix_slice[0..len]);
|
|
}
|
|
prefix_buf[len..][0..6].* = "XXXXXX".*;
|
|
prefix_buf[len..][6] = 0;
|
|
|
|
// The mkdtemp() function returns a pointer to the modified template
|
|
// string on success, and NULL on failure, in which case errno is set to
|
|
// indicate the error
|
|
|
|
if (Environment.isWindows) {
|
|
var req: uv.fs_t = uv.fs_t.uninitialized;
|
|
const rc = uv.uv_fs_mkdtemp(bun.Async.Loop.get(), &req, @ptrCast(prefix_buf.ptr), null);
|
|
if (rc.errno()) |errno| {
|
|
return .{ .err = .{ .errno = errno, .syscall = .mkdtemp, .path = prefix_buf[0 .. len + 6] } };
|
|
}
|
|
return .{
|
|
.result = JSC.ZigString.dupeForJS(bun.sliceTo(req.path, 0), bun.default_allocator) catch bun.outOfMemory(),
|
|
};
|
|
}
|
|
|
|
const rc = C.mkdtemp(prefix_buf);
|
|
if (rc) |ptr| {
|
|
return .{
|
|
.result = JSC.ZigString.dupeForJS(bun.sliceTo(ptr, 0), bun.default_allocator) catch bun.outOfMemory(),
|
|
};
|
|
}
|
|
// std.c.getErrno(rc) returns SUCCESS if rc is null so we call std.c._errno() directly
|
|
const errno = @as(std.c.E, @enumFromInt(std.c._errno().*));
|
|
return .{ .err = Syscall.Error{
|
|
.errno = @as(Syscall.Error.Int, @truncate(@intFromEnum(errno))),
|
|
.syscall = .mkdtemp,
|
|
} };
|
|
}
|
|
|
|
pub fn open(this: *NodeFS, args: Arguments.Open, comptime _: Flavor) Maybe(Return.Open) {
|
|
const path = if (Environment.isWindows and bun.strings.eqlComptime(args.path.slice(), "/dev/null"))
|
|
"\\\\.\\NUL"
|
|
else
|
|
args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
return switch (Syscall.open(path, @intFromEnum(args.flags), args.mode)) {
|
|
.err => |err| .{
|
|
.err = err.withPath(args.path.slice()),
|
|
},
|
|
.result => |fd| fd: {
|
|
break :fd .{ .result = FDImpl.decode(fd) };
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn openDir(_: *NodeFS, _: Arguments.OpenDir, comptime _: Flavor) Maybe(Return.OpenDir) {
|
|
return Maybe(Return.OpenDir).todo();
|
|
}
|
|
|
|
fn _read(_: *NodeFS, args: Arguments.Read, comptime _: Flavor) Maybe(Return.Read) {
|
|
if (Environment.allow_assert) std.debug.assert(args.position == null);
|
|
var buf = args.buffer.slice();
|
|
buf = buf[@min(args.offset, buf.len)..];
|
|
buf = buf[0..@min(buf.len, args.length)];
|
|
|
|
return switch (Syscall.read(args.fd, buf)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{
|
|
.result = .{
|
|
.bytes_read = @as(u52, @truncate(amt)),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn _pread(_: *NodeFS, args: Arguments.Read, comptime flavor: Flavor) Maybe(Return.Read) {
|
|
_ = flavor;
|
|
var buf = args.buffer.slice();
|
|
buf = buf[@min(args.offset, buf.len)..];
|
|
buf = buf[0..@min(buf.len, args.length)];
|
|
|
|
return switch (Syscall.pread(args.fd, buf, args.position.?)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{
|
|
.result = .{
|
|
.bytes_read = @as(u52, @truncate(amt)),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn read(this: *NodeFS, args: Arguments.Read, comptime flavor: Flavor) Maybe(Return.Read) {
|
|
return if (args.position != null)
|
|
this._pread(
|
|
args,
|
|
comptime flavor,
|
|
)
|
|
else
|
|
this._read(
|
|
args,
|
|
comptime flavor,
|
|
);
|
|
}
|
|
|
|
pub fn readv(this: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Readv) {
|
|
return if (args.position != null) _preadv(this, args, flavor) else _readv(this, args, flavor);
|
|
}
|
|
|
|
pub fn writev(this: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Writev) {
|
|
return if (args.position != null) _pwritev(this, args, flavor) else _writev(this, args, flavor);
|
|
}
|
|
|
|
pub fn write(this: *NodeFS, args: Arguments.Write, comptime flavor: Flavor) Maybe(Return.Write) {
|
|
return if (args.position != null) _pwrite(this, args, flavor) else _write(this, args, flavor);
|
|
}
|
|
|
|
fn _write(_: *NodeFS, args: Arguments.Write, comptime flavor: Flavor) Maybe(Return.Write) {
|
|
_ = flavor;
|
|
|
|
var buf = args.buffer.slice();
|
|
buf = buf[@min(args.offset, buf.len)..];
|
|
buf = buf[0..@min(buf.len, args.length)];
|
|
|
|
return switch (Syscall.write(args.fd, buf)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{
|
|
.result = .{
|
|
.bytes_written = @as(u52, @truncate(amt)),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn _pwrite(_: *NodeFS, args: Arguments.Write, comptime flavor: Flavor) Maybe(Return.Write) {
|
|
_ = flavor;
|
|
const position = args.position.?;
|
|
|
|
var buf = args.buffer.slice();
|
|
buf = buf[@min(args.offset, buf.len)..];
|
|
buf = buf[0..@min(args.length, buf.len)];
|
|
|
|
return switch (Syscall.pwrite(args.fd, buf, position)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{ .result = .{
|
|
.bytes_written = @as(u52, @truncate(amt)),
|
|
} },
|
|
};
|
|
}
|
|
|
|
fn _preadv(_: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Readv) {
|
|
_ = flavor;
|
|
const position = args.position.?;
|
|
|
|
return switch (Syscall.preadv(args.fd, args.buffers.buffers.items, position)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{ .result = .{
|
|
.bytes_read = @as(u52, @truncate(amt)),
|
|
} },
|
|
};
|
|
}
|
|
|
|
fn _readv(_: *NodeFS, args: Arguments.Readv, comptime flavor: Flavor) Maybe(Return.Readv) {
|
|
_ = flavor;
|
|
return switch (Syscall.readv(args.fd, args.buffers.buffers.items)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{ .result = .{
|
|
.bytes_read = @as(u52, @truncate(amt)),
|
|
} },
|
|
};
|
|
}
|
|
|
|
fn _pwritev(_: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Write) {
|
|
_ = flavor;
|
|
const position = args.position.?;
|
|
return switch (Syscall.pwritev(args.fd, @ptrCast(args.buffers.buffers.items), position)) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{ .result = .{
|
|
.bytes_written = @as(u52, @truncate(amt)),
|
|
} },
|
|
};
|
|
}
|
|
|
|
fn _writev(_: *NodeFS, args: Arguments.Writev, comptime flavor: Flavor) Maybe(Return.Write) {
|
|
_ = flavor;
|
|
return switch (Syscall.writev(args.fd, @ptrCast(args.buffers.buffers.items))) {
|
|
.err => |err| .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| .{ .result = .{
|
|
.bytes_written = @as(u52, @truncate(amt)),
|
|
} },
|
|
};
|
|
}
|
|
|
|
pub fn readdir(this: *NodeFS, args: Arguments.Readdir, comptime flavor: Flavor) Maybe(Return.Readdir) {
|
|
if (comptime flavor != .sync) {
|
|
if (args.recursive) {
|
|
@panic("Assertion failure: this code path should never be reached.");
|
|
}
|
|
}
|
|
|
|
return switch (args.recursive) {
|
|
inline else => |recursive| switch (args.tag()) {
|
|
.buffers => _readdir(&this.sync_error_buf, args, Buffer, recursive, flavor),
|
|
.with_file_types => _readdir(&this.sync_error_buf, args, Dirent, recursive, flavor),
|
|
.files => _readdir(&this.sync_error_buf, args, bun.String, recursive, flavor),
|
|
},
|
|
};
|
|
}
|
|
|
|
fn readdirWithEntries(
|
|
args: Arguments.Readdir,
|
|
fd: bun.FileDescriptor,
|
|
comptime ExpectedType: type,
|
|
entries: *std.ArrayList(ExpectedType),
|
|
) Maybe(void) {
|
|
const dir = fd.asDir();
|
|
const is_u16 = comptime Environment.isWindows and (ExpectedType == bun.String or ExpectedType == Dirent);
|
|
var iterator = DirIterator.iterate(
|
|
dir,
|
|
comptime if (is_u16) .u16 else .u8,
|
|
);
|
|
var entry = iterator.next();
|
|
|
|
while (switch (entry) {
|
|
.err => |err| {
|
|
for (entries.items) |*item| {
|
|
switch (ExpectedType) {
|
|
Dirent => {
|
|
item.name.deref();
|
|
},
|
|
Buffer => {
|
|
item.destroy();
|
|
},
|
|
bun.String => {
|
|
item.deref();
|
|
},
|
|
else => @compileError("unreachable"),
|
|
}
|
|
}
|
|
|
|
entries.deinit();
|
|
|
|
return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
};
|
|
},
|
|
.result => |ent| ent,
|
|
}) |current| : (entry = iterator.next()) {
|
|
if (comptime !is_u16) {
|
|
const utf8_name = current.name.slice();
|
|
switch (ExpectedType) {
|
|
Dirent => {
|
|
entries.append(.{
|
|
.name = bun.String.createUTF8(utf8_name),
|
|
.kind = current.kind,
|
|
}) catch bun.outOfMemory();
|
|
},
|
|
Buffer => {
|
|
entries.append(Buffer.fromString(utf8_name, bun.default_allocator) catch bun.outOfMemory()) catch bun.outOfMemory();
|
|
},
|
|
bun.String => {
|
|
entries.append(bun.String.createUTF8(utf8_name)) catch bun.outOfMemory();
|
|
},
|
|
else => @compileError("unreachable"),
|
|
}
|
|
} else {
|
|
const utf16_name = current.name.slice();
|
|
switch (ExpectedType) {
|
|
Dirent => {
|
|
entries.append(.{
|
|
.name = bun.String.createUTF16(utf16_name),
|
|
.kind = current.kind,
|
|
}) catch bun.outOfMemory();
|
|
},
|
|
bun.String => {
|
|
entries.append(bun.String.createUTF16(utf16_name)) catch bun.outOfMemory();
|
|
},
|
|
else => @compileError("unreachable"),
|
|
}
|
|
}
|
|
}
|
|
|
|
return Maybe(void).success;
|
|
}
|
|
|
|
pub fn readdirWithEntriesRecursiveAsync(
|
|
buf: *[bun.MAX_PATH_BYTES]u8,
|
|
args: Arguments.Readdir,
|
|
async_task: *AsyncReaddirRecursiveTask,
|
|
basename: [:0]const u8,
|
|
comptime ExpectedType: type,
|
|
entries: *std.ArrayList(ExpectedType),
|
|
comptime is_root: bool,
|
|
) Maybe(void) {
|
|
const flags = os.O.DIRECTORY | os.O.RDONLY;
|
|
|
|
const atfd = if (comptime is_root) bun.toFD(std.fs.cwd().fd) else async_task.root_fd;
|
|
const fd = switch (switch (Environment.os) {
|
|
else => Syscall.openat(atfd, basename, flags, 0),
|
|
// windows bun.sys.open does not pass iterable=true,
|
|
.windows => bun.sys.openDirAtWindowsA(atfd, basename, true, false),
|
|
}) {
|
|
.err => |err| {
|
|
if (comptime !is_root) {
|
|
switch (err.getErrno()) {
|
|
// These things can happen and there's nothing we can do about it.
|
|
//
|
|
// This is different than what Node does, at the time of writing.
|
|
// Node doesn't gracefully handle errors like these. It fails the entire operation.
|
|
.NOENT, .NOTDIR, .PERM => {
|
|
return Maybe(void).success;
|
|
},
|
|
else => {},
|
|
}
|
|
|
|
const path_parts = [_]string{ async_task.root_path.slice(), basename };
|
|
return .{
|
|
.err = err.withPath(bun.path.joinZBuf(buf, &path_parts, .auto)),
|
|
};
|
|
}
|
|
return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
};
|
|
},
|
|
.result => |fd_| fd_,
|
|
};
|
|
|
|
if (comptime is_root) {
|
|
async_task.root_fd = fd;
|
|
}
|
|
|
|
defer {
|
|
if (comptime !is_root) {
|
|
_ = Syscall.close(fd);
|
|
}
|
|
}
|
|
|
|
var iterator = DirIterator.iterate(fd.asDir(), .u8);
|
|
var entry = iterator.next();
|
|
|
|
while (switch (entry) {
|
|
.err => |err| {
|
|
if (comptime !is_root) {
|
|
const path_parts = [_]string{ async_task.root_path.slice(), basename };
|
|
return .{
|
|
.err = err.withPath(bun.path.joinZBuf(buf, &path_parts, .auto)),
|
|
};
|
|
}
|
|
|
|
return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
};
|
|
},
|
|
.result => |ent| ent,
|
|
}) |current| : (entry = iterator.next()) {
|
|
const utf8_name = current.name.slice();
|
|
|
|
const name_to_copy: [:0]const u8 = brk: {
|
|
if (async_task.root_path.sliceAssumeZ().ptr == basename.ptr) {
|
|
break :brk @ptrCast(utf8_name);
|
|
}
|
|
|
|
const path_parts = [_]string{ basename, utf8_name };
|
|
break :brk bun.path.joinZBuf(buf, &path_parts, .auto);
|
|
};
|
|
|
|
enqueue: {
|
|
switch (current.kind) {
|
|
// a symlink might be a directory or might not be
|
|
// if it's not a directory, the task will fail at that point.
|
|
.sym_link,
|
|
|
|
// we know for sure it's a directory
|
|
.directory,
|
|
=> {
|
|
// if the name is too long, we can't enqueue it regardless
|
|
// the operating system would just return ENAMETOOLONG
|
|
//
|
|
// Technically, we could work around that due to the
|
|
// usage of openat, but then we risk leaving too many
|
|
// file descriptors open.
|
|
if (current.name.len + 1 + name_to_copy.len > bun.MAX_PATH_BYTES) break :enqueue;
|
|
|
|
async_task.enqueue(name_to_copy);
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
switch (comptime ExpectedType) {
|
|
Dirent => {
|
|
entries.append(.{
|
|
.name = bun.String.createUTF8(name_to_copy),
|
|
.kind = current.kind,
|
|
}) catch bun.outOfMemory();
|
|
},
|
|
Buffer => {
|
|
entries.append(Buffer.fromString(name_to_copy, bun.default_allocator) catch bun.outOfMemory()) catch bun.outOfMemory();
|
|
},
|
|
bun.String => {
|
|
entries.append(bun.String.createUTF8(name_to_copy)) catch bun.outOfMemory();
|
|
},
|
|
else => bun.outOfMemory(),
|
|
}
|
|
}
|
|
|
|
return Maybe(void).success;
|
|
}
|
|
|
|
fn readdirWithEntriesRecursiveSync(
|
|
buf: *[bun.MAX_PATH_BYTES]u8,
|
|
args: Arguments.Readdir,
|
|
root_basename: [:0]const u8,
|
|
comptime ExpectedType: type,
|
|
entries: *std.ArrayList(ExpectedType),
|
|
) Maybe(void) {
|
|
var iterator_stack = std.heap.stackFallback(128, bun.default_allocator);
|
|
var stack = std.fifo.LinearFifo([:0]const u8, .{ .Dynamic = {} }).init(iterator_stack.get());
|
|
var basename_stack = std.heap.stackFallback(8192 * 2, bun.default_allocator);
|
|
const basename_allocator = basename_stack.get();
|
|
defer {
|
|
while (stack.readItem()) |name| {
|
|
basename_allocator.free(name);
|
|
}
|
|
stack.deinit();
|
|
}
|
|
|
|
stack.writeItem(root_basename) catch unreachable;
|
|
var root_fd: bun.FileDescriptor = bun.invalid_fd;
|
|
|
|
defer {
|
|
// all other paths are relative to the root directory
|
|
// so we can only close it once we're 100% done
|
|
if (root_fd != bun.invalid_fd) {
|
|
_ = Syscall.close(root_fd);
|
|
}
|
|
}
|
|
|
|
while (stack.readItem()) |basename| {
|
|
defer {
|
|
if (root_basename.ptr != basename.ptr) {
|
|
basename_allocator.free(basename);
|
|
}
|
|
}
|
|
|
|
const flags = os.O.DIRECTORY | os.O.RDONLY;
|
|
const fd = switch (Syscall.openat(if (root_fd == bun.invalid_fd) bun.toFD(std.fs.cwd().fd) else root_fd, basename, flags, 0)) {
|
|
.err => |err| {
|
|
if (root_fd == bun.invalid_fd) {
|
|
return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
};
|
|
}
|
|
|
|
switch (err.getErrno()) {
|
|
// These things can happen and there's nothing we can do about it.
|
|
//
|
|
// This is different than what Node does, at the time of writing.
|
|
// Node doesn't gracefully handle errors like these. It fails the entire operation.
|
|
.NOENT, .NOTDIR, .PERM => continue,
|
|
else => {
|
|
const path_parts = [_]string{ args.path.slice(), basename };
|
|
return .{
|
|
.err = err.withPath(bun.default_allocator.dupe(u8, bun.path.joinZBuf(buf, &path_parts, .auto)) catch ""),
|
|
};
|
|
},
|
|
}
|
|
},
|
|
.result => |fd_| fd_,
|
|
};
|
|
if (root_fd == bun.invalid_fd) {
|
|
root_fd = fd;
|
|
}
|
|
|
|
defer {
|
|
if (fd != root_fd) {
|
|
_ = Syscall.close(fd);
|
|
}
|
|
}
|
|
|
|
var iterator = DirIterator.iterate(fd.asDir(), .u8);
|
|
var entry = iterator.next();
|
|
|
|
while (switch (entry) {
|
|
.err => |err| {
|
|
return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
};
|
|
},
|
|
.result => |ent| ent,
|
|
}) |current| : (entry = iterator.next()) {
|
|
const utf8_name = current.name.slice();
|
|
|
|
const name_to_copy = brk: {
|
|
if (root_basename.ptr == basename.ptr) {
|
|
break :brk utf8_name;
|
|
}
|
|
|
|
const path_parts = [_]string{ basename, utf8_name };
|
|
break :brk bun.path.joinZBuf(buf, &path_parts, .auto);
|
|
};
|
|
|
|
enqueue: {
|
|
switch (current.kind) {
|
|
// a symlink might be a directory or might not be
|
|
// if it's not a directory, the task will fail at that point.
|
|
.sym_link,
|
|
|
|
// we know for sure it's a directory
|
|
.directory,
|
|
=> {
|
|
if (current.name.len + 1 + name_to_copy.len > bun.MAX_PATH_BYTES) break :enqueue;
|
|
stack.writeItem(basename_allocator.dupeZ(u8, name_to_copy) catch break :enqueue) catch break :enqueue;
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
switch (comptime ExpectedType) {
|
|
Dirent => {
|
|
entries.append(.{
|
|
.name = bun.String.createUTF8(name_to_copy),
|
|
.kind = current.kind,
|
|
}) catch bun.outOfMemory();
|
|
},
|
|
Buffer => {
|
|
entries.append(Buffer.fromString(name_to_copy, bun.default_allocator) catch bun.outOfMemory()) catch bun.outOfMemory();
|
|
},
|
|
bun.String => {
|
|
entries.append(bun.String.createUTF8(name_to_copy)) catch bun.outOfMemory();
|
|
},
|
|
else => @compileError("Impossible"),
|
|
}
|
|
}
|
|
}
|
|
|
|
return Maybe(void).success;
|
|
}
|
|
|
|
fn _readdir(
|
|
buf: *[bun.MAX_PATH_BYTES]u8,
|
|
args: Arguments.Readdir,
|
|
comptime ExpectedType: type,
|
|
comptime recursive: bool,
|
|
comptime flavor: Flavor,
|
|
) Maybe(Return.Readdir) {
|
|
const file_type = switch (ExpectedType) {
|
|
Dirent => "with_file_types",
|
|
bun.String => "files",
|
|
Buffer => "buffers",
|
|
else => @compileError("unreachable"),
|
|
};
|
|
|
|
const path = args.path.sliceZ(buf);
|
|
|
|
if (comptime recursive and flavor == .sync) {
|
|
var buf_to_pass: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
|
|
var entries = std.ArrayList(ExpectedType).init(bun.default_allocator);
|
|
return switch (readdirWithEntriesRecursiveSync(&buf_to_pass, args, path, ExpectedType, &entries)) {
|
|
.err => |err| {
|
|
for (entries.items) |*result| {
|
|
switch (ExpectedType) {
|
|
Dirent => {
|
|
result.name.deref();
|
|
},
|
|
Buffer => {
|
|
result.destroy();
|
|
},
|
|
bun.String => {
|
|
result.deref();
|
|
},
|
|
else => @compileError("unreachable"),
|
|
}
|
|
}
|
|
|
|
entries.deinit();
|
|
|
|
return .{
|
|
.err = err,
|
|
};
|
|
},
|
|
.result => .{ .result = @unionInit(Return.Readdir, file_type, entries.items) },
|
|
};
|
|
}
|
|
|
|
if (comptime recursive) {
|
|
@panic("This code path should never be reached. It should only go through readdirWithEntriesRecursiveAsync.");
|
|
}
|
|
|
|
const flags = os.O.DIRECTORY | os.O.RDONLY;
|
|
const fd = switch (switch (Environment.os) {
|
|
else => Syscall.open(path, flags, 0),
|
|
// windows bun.sys.open does not pass iterable=true,
|
|
.windows => bun.sys.openDirAtWindowsA(bun.toFD(std.fs.cwd().fd), path, true, false),
|
|
}) {
|
|
.err => |err| return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
},
|
|
.result => |fd_| fd_,
|
|
};
|
|
|
|
defer _ = Syscall.close(fd);
|
|
|
|
var entries = std.ArrayList(ExpectedType).init(bun.default_allocator);
|
|
return switch (readdirWithEntries(args, fd, ExpectedType, &entries)) {
|
|
.err => |err| return .{
|
|
.err = err,
|
|
},
|
|
.result => .{ .result = @unionInit(Return.Readdir, file_type, entries.items) },
|
|
};
|
|
}
|
|
|
|
pub const StringType = enum {
|
|
default,
|
|
null_terminated,
|
|
};
|
|
|
|
pub fn readFile(this: *NodeFS, args: Arguments.ReadFile, comptime flavor: Flavor) Maybe(Return.ReadFile) {
|
|
const ret = readFileWithOptions(this, args, flavor, .default);
|
|
return switch (ret) {
|
|
.err => .{ .err = ret.err },
|
|
.result => switch (ret.result) {
|
|
.buffer => .{
|
|
.result = .{
|
|
.buffer = ret.result.buffer,
|
|
},
|
|
},
|
|
.string => .{ .result = .{ .string = bun.SliceWithUnderlyingString.transcodeFromOwnedSlice(@constCast(ret.result.string), args.encoding) } },
|
|
else => unreachable,
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn readFileWithOptions(this: *NodeFS, args: Arguments.ReadFile, comptime _: Flavor, comptime string_type: StringType) Maybe(Return.ReadFileWithOptions) {
|
|
var path: [:0]const u8 = undefined;
|
|
const fd_maybe_windows: FileDescriptor = switch (args.path) {
|
|
.path => brk: {
|
|
path = args.path.path.sliceZ(&this.sync_error_buf);
|
|
if (this.vm) |vm| {
|
|
if (vm.standalone_module_graph) |graph| {
|
|
if (graph.find(path)) |file| {
|
|
if (args.encoding == .buffer) {
|
|
return .{
|
|
.result = .{
|
|
.buffer = Buffer.fromBytes(
|
|
bun.default_allocator.dupe(u8, file.contents) catch @panic("out of memory"),
|
|
bun.default_allocator,
|
|
.Uint8Array,
|
|
),
|
|
},
|
|
};
|
|
} else if (comptime string_type == .default)
|
|
return .{
|
|
.result = .{
|
|
.string = bun.default_allocator.dupe(u8, file.contents) catch @panic("out of memory"),
|
|
},
|
|
}
|
|
else
|
|
return .{
|
|
.result = .{
|
|
.null_terminated = bun.default_allocator.dupeZ(u8, file.contents) catch @panic("out of memory"),
|
|
},
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
break :brk switch (bun.sys.open(
|
|
path,
|
|
os.O.RDONLY | os.O.NOCTTY,
|
|
0,
|
|
)) {
|
|
.err => |err| return .{
|
|
.err = err.withPath(if (args.path == .path) args.path.path.slice() else ""),
|
|
},
|
|
.result => |fd| fd,
|
|
};
|
|
},
|
|
.fd => |fd| fd,
|
|
};
|
|
const fd = bun.toLibUVOwnedFD(fd_maybe_windows) catch {
|
|
if (args.path == .path)
|
|
_ = Syscall.close(fd_maybe_windows);
|
|
|
|
return .{
|
|
.err = .{
|
|
.errno = @intFromEnum(os.E.MFILE),
|
|
.syscall = .open,
|
|
},
|
|
};
|
|
};
|
|
|
|
defer {
|
|
if (args.path == .path)
|
|
_ = Syscall.close(fd);
|
|
}
|
|
|
|
const stat_ = switch (Syscall.fstat(fd)) {
|
|
.err => |err| return .{
|
|
.err = err,
|
|
},
|
|
.result => |stat_| stat_,
|
|
};
|
|
|
|
// Only used in DOMFormData
|
|
if (args.offset > 0) {
|
|
_ = Syscall.setFileOffset(fd, args.offset);
|
|
}
|
|
// For certain files, the size might be 0 but the file might still have contents.
|
|
// https://github.com/oven-sh/bun/issues/1220
|
|
const size = @as(
|
|
u64,
|
|
@max(
|
|
@min(
|
|
stat_.size,
|
|
// Only used in DOMFormData
|
|
args.max_size orelse std.math.maxInt(JSC.WebCore.Blob.SizeType),
|
|
),
|
|
0,
|
|
),
|
|
) + @intFromBool(comptime string_type == .null_terminated);
|
|
|
|
var buf = std.ArrayList(u8).init(bun.default_allocator);
|
|
buf.ensureTotalCapacityPrecise(size + 16) catch unreachable;
|
|
buf.expandToCapacity();
|
|
var total: usize = 0;
|
|
|
|
while (total < size) {
|
|
switch (Syscall.read(fd, buf.items.ptr[total..buf.capacity])) {
|
|
.err => |err| return .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| {
|
|
total += amt;
|
|
// There are cases where stat()'s size is wrong or out of date
|
|
if (total > size and amt != 0) {
|
|
buf.ensureUnusedCapacity(8192) catch unreachable;
|
|
buf.expandToCapacity();
|
|
continue;
|
|
}
|
|
|
|
if (amt == 0) {
|
|
break;
|
|
}
|
|
},
|
|
}
|
|
} else {
|
|
while (true) {
|
|
switch (Syscall.read(fd, buf.items.ptr[total..buf.capacity])) {
|
|
.err => |err| return .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| {
|
|
total += amt;
|
|
// There are cases where stat()'s size is wrong or out of date
|
|
if (total > size and amt != 0) {
|
|
buf.ensureUnusedCapacity(8192) catch unreachable;
|
|
buf.expandToCapacity();
|
|
continue;
|
|
}
|
|
|
|
if (amt == 0) {
|
|
break;
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
buf.items.len = if (comptime string_type == .null_terminated) total + 1 else total;
|
|
if (total == 0) {
|
|
buf.deinit();
|
|
return switch (args.encoding) {
|
|
.buffer => .{
|
|
.result = .{
|
|
.buffer = Buffer.empty,
|
|
},
|
|
},
|
|
else => brk: {
|
|
if (comptime string_type == .default) {
|
|
break :brk .{
|
|
.result = .{
|
|
.string = "",
|
|
},
|
|
};
|
|
} else {
|
|
break :brk .{
|
|
.result = .{
|
|
.null_terminated = "",
|
|
},
|
|
};
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
return switch (args.encoding) {
|
|
.buffer => .{
|
|
.result = .{
|
|
.buffer = Buffer.fromBytes(buf.items, bun.default_allocator, .Uint8Array),
|
|
},
|
|
},
|
|
else => brk: {
|
|
if (comptime string_type == .default) {
|
|
break :brk .{
|
|
.result = .{
|
|
.string = buf.items,
|
|
},
|
|
};
|
|
} else {
|
|
break :brk .{
|
|
.result = .{
|
|
.null_terminated = buf.toOwnedSliceSentinel(0) catch unreachable,
|
|
},
|
|
};
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn writeFileWithPathBuffer(pathbuf: *[bun.MAX_PATH_BYTES]u8, args: Arguments.WriteFile) Maybe(Return.WriteFile) {
|
|
var path: [:0]const u8 = undefined;
|
|
var pathbuf2: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
|
|
const fd = switch (args.file) {
|
|
.path => brk: {
|
|
// On Windows, we potentially mutate the path in posixToPlatformInPlace
|
|
// We cannot mutate JavaScript strings in-place. That will break many things.
|
|
// So we must always copy the path string on Windows.
|
|
path = path: {
|
|
const temp_path = args.file.path.sliceZWithForceCopy(pathbuf, Environment.isWindows);
|
|
if (Environment.isWindows) {
|
|
bun.path.posixToPlatformInPlace(u8, temp_path);
|
|
}
|
|
break :path temp_path;
|
|
};
|
|
|
|
var is_dirfd_different = false;
|
|
var dirfd = args.dirfd;
|
|
if (Environment.isWindows) {
|
|
while (std.mem.startsWith(u8, path, "..\\")) {
|
|
is_dirfd_different = true;
|
|
var buffer: bun.WPathBuffer = undefined;
|
|
const dirfd_path_len = std.os.windows.kernel32.GetFinalPathNameByHandleW(args.dirfd.cast(), &buffer, buffer.len, 0);
|
|
const dirfd_path = buffer[0..dirfd_path_len];
|
|
const parent_path = bun.Dirname.dirname(u16, dirfd_path).?;
|
|
if (std.mem.startsWith(u16, parent_path, &bun.windows.nt_maxpath_prefix)) @constCast(parent_path)[1] = '?';
|
|
const newdirfd = switch (bun.sys.openDirAtWindows(bun.invalid_fd, parent_path, false, true)) {
|
|
.result => |fd| fd,
|
|
.err => |err| {
|
|
return .{ .err = err.withPath(path) };
|
|
},
|
|
};
|
|
path = path[3..];
|
|
dirfd = newdirfd;
|
|
}
|
|
}
|
|
defer if (is_dirfd_different) {
|
|
var d = dirfd.asDir();
|
|
d.close();
|
|
};
|
|
if (Environment.isWindows) {
|
|
// windows openat does not support path traversal, fix it here.
|
|
// use pathbuf2 here since without it 'panic: @memcpy arguments alias' triggers
|
|
if (std.mem.indexOf(u8, path, "\\.\\") != null or std.mem.indexOf(u8, path, "\\..\\") != null) {
|
|
const fixed_path = bun.path.normalizeStringWindows(path, &pathbuf2, false, false);
|
|
pathbuf2[fixed_path.len] = 0;
|
|
path = pathbuf2[0..fixed_path.len :0];
|
|
}
|
|
}
|
|
|
|
const open_result = Syscall.openat(
|
|
dirfd,
|
|
path,
|
|
@intFromEnum(args.flag) | os.O.NOCTTY,
|
|
args.mode,
|
|
);
|
|
|
|
break :brk switch (open_result) {
|
|
.err => |err| return .{
|
|
.err = err.withPath(path),
|
|
},
|
|
.result => |fd| fd,
|
|
};
|
|
},
|
|
.fd => |fd| fd,
|
|
};
|
|
|
|
defer {
|
|
if (args.file == .path)
|
|
_ = bun.sys.close(fd);
|
|
}
|
|
|
|
var buf = args.data.slice();
|
|
var written: usize = 0;
|
|
|
|
// Attempt to pre-allocate large files
|
|
if (Environment.isLinux) {
|
|
preallocate: {
|
|
// Worthwhile after 6 MB at least on ext4 linux
|
|
if (buf.len >= bun.C.preallocate_length) {
|
|
const offset: usize = if (args.file == .path)
|
|
// on mac, it's relatively positioned
|
|
0
|
|
else brk: {
|
|
// on linux, it's absolutely positioned
|
|
const pos = bun.sys.system.lseek(
|
|
fd.cast(),
|
|
@as(std.os.off_t, @intCast(0)),
|
|
std.os.linux.SEEK.CUR,
|
|
);
|
|
|
|
switch (bun.sys.getErrno(pos)) {
|
|
.SUCCESS => break :brk @as(usize, @intCast(pos)),
|
|
else => break :preallocate,
|
|
}
|
|
};
|
|
|
|
bun.C.preallocate_file(
|
|
fd.cast(),
|
|
@as(std.os.off_t, @intCast(offset)),
|
|
@as(std.os.off_t, @intCast(buf.len)),
|
|
) catch {};
|
|
}
|
|
}
|
|
}
|
|
|
|
while (buf.len > 0) {
|
|
switch (bun.sys.write(fd, buf)) {
|
|
.err => |err| return .{
|
|
.err = err,
|
|
},
|
|
.result => |amt| {
|
|
buf = buf[amt..];
|
|
written += amt;
|
|
if (amt == 0) {
|
|
break;
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
if (Environment.isWindows) {
|
|
const rc = std.os.windows.kernel32.SetEndOfFile(fd.cast());
|
|
if (rc == 0) {
|
|
return .{
|
|
.err = Syscall.Error{
|
|
.errno = @intFromEnum(std.os.windows.kernel32.GetLastError()),
|
|
.syscall = .SetEndOfFile,
|
|
.fd = fd,
|
|
},
|
|
};
|
|
}
|
|
} else {
|
|
// https://github.com/oven-sh/bun/issues/2931
|
|
if ((@intFromEnum(args.flag) & std.os.O.APPEND) == 0) {
|
|
_ = ftruncateSync(.{ .fd = fd, .len = @as(JSC.WebCore.Blob.SizeType, @truncate(written)) });
|
|
}
|
|
}
|
|
|
|
return Maybe(Return.WriteFile).success;
|
|
}
|
|
|
|
pub fn writeFile(this: *NodeFS, args: Arguments.WriteFile, comptime _: Flavor) Maybe(Return.WriteFile) {
|
|
return writeFileWithPathBuffer(&this.sync_error_buf, args);
|
|
}
|
|
|
|
pub fn readlink(this: *NodeFS, args: Arguments.Readlink, comptime _: Flavor) Maybe(Return.Readlink) {
|
|
var outbuf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
const inbuf = &this.sync_error_buf;
|
|
|
|
const path = args.path.sliceZ(inbuf);
|
|
|
|
const len = switch (Syscall.readlink(path, &outbuf)) {
|
|
.err => |err| return .{
|
|
.err = err.withPath(args.path.slice()),
|
|
},
|
|
.result => |len| len,
|
|
};
|
|
|
|
return .{
|
|
.result = switch (args.encoding) {
|
|
.buffer => .{
|
|
.buffer = Buffer.fromString(outbuf[0..len], bun.default_allocator) catch unreachable,
|
|
},
|
|
else => if (args.path == .slice_with_underlying_string and
|
|
strings.eqlLong(args.path.slice_with_underlying_string.slice(), outbuf[0..len], true))
|
|
.{
|
|
.string = args.path.slice_with_underlying_string.dupeRef(),
|
|
}
|
|
else
|
|
.{
|
|
.string = .{ .utf8 = .{}, .underlying = bun.String.createUTF8(outbuf[0..len]) },
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn realpath(this: *NodeFS, args: Arguments.Realpath, comptime _: Flavor) Maybe(Return.Realpath) {
|
|
if (Environment.isWindows) {
|
|
var req: uv.fs_t = uv.fs_t.uninitialized;
|
|
defer req.deinit();
|
|
const rc = uv.uv_fs_realpath(
|
|
bun.Async.Loop.get(),
|
|
&req,
|
|
args.path.sliceZ(&this.sync_error_buf).ptr,
|
|
null,
|
|
);
|
|
|
|
if (rc.errno()) |errno|
|
|
return .{ .err = Syscall.Error{
|
|
.errno = errno,
|
|
.syscall = .realpath,
|
|
.path = args.path.slice(),
|
|
} };
|
|
|
|
// Seems like `rc` does not contain the errno?
|
|
std.debug.assert(rc.errEnum() == null);
|
|
const buf = bun.span(req.ptrAs([*:0]u8));
|
|
|
|
return .{
|
|
.result = switch (args.encoding) {
|
|
.buffer => .{
|
|
.buffer = Buffer.fromString(buf, bun.default_allocator) catch unreachable,
|
|
},
|
|
else => if (args.path == .slice_with_underlying_string and
|
|
strings.eqlLong(args.path.slice_with_underlying_string.slice(), buf, true))
|
|
.{
|
|
.string = args.path.slice_with_underlying_string.dupeRef(),
|
|
}
|
|
else
|
|
.{
|
|
.string = .{ .utf8 = .{}, .underlying = bun.String.createUTF8(buf) },
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
var outbuf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
var inbuf = &this.sync_error_buf;
|
|
if (comptime Environment.allow_assert) std.debug.assert(FileSystem.instance_loaded);
|
|
|
|
const path_slice = args.path.slice();
|
|
|
|
var parts = [_]string{ FileSystem.instance.top_level_dir, path_slice };
|
|
const path_ = FileSystem.instance.absBuf(&parts, inbuf);
|
|
inbuf[path_.len] = 0;
|
|
const path: [:0]u8 = inbuf[0..path_.len :0];
|
|
|
|
const flags = if (comptime Environment.isLinux)
|
|
// O_PATH is faster
|
|
std.os.O.PATH
|
|
else
|
|
std.os.O.RDONLY;
|
|
|
|
const fd = switch (bun.sys.open(path, flags, 0)) {
|
|
.err => |err| return .{ .err = err.withPath(path) },
|
|
.result => |fd_| fd_,
|
|
};
|
|
|
|
defer {
|
|
_ = Syscall.close(fd);
|
|
}
|
|
|
|
const buf = switch (Syscall.getFdPath(fd, &outbuf)) {
|
|
.err => |err| return .{ .err = err.withPath(path) },
|
|
.result => |buf_| buf_,
|
|
};
|
|
|
|
return .{
|
|
.result = switch (args.encoding) {
|
|
.buffer => .{
|
|
.buffer = Buffer.fromString(buf, bun.default_allocator) catch unreachable,
|
|
},
|
|
else => if (args.path == .slice_with_underlying_string and
|
|
strings.eqlLong(args.path.slice_with_underlying_string.slice(), buf, true))
|
|
.{
|
|
.string = args.path.slice_with_underlying_string.dupeRef(),
|
|
}
|
|
else
|
|
.{
|
|
.string = .{ .utf8 = .{}, .underlying = bun.String.createUTF8(buf) },
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
pub const realpathNative = realpath;
|
|
// pub fn realpathNative(this: *NodeFS, args: Arguments.Realpath, comptime flavor: Flavor) Maybe(Return.Realpath) {
|
|
// _ = args;
|
|
//
|
|
//
|
|
// return error.NotImplementedYet;
|
|
// }
|
|
|
|
pub fn rename(this: *NodeFS, args: Arguments.Rename, comptime flavor: Flavor) Maybe(Return.Rename) {
|
|
_ = flavor;
|
|
const from_buf = &this.sync_error_buf;
|
|
var to_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
|
|
const from = args.old_path.sliceZ(from_buf);
|
|
const to = args.new_path.sliceZ(&to_buf);
|
|
return Syscall.rename(from, to);
|
|
}
|
|
|
|
pub fn rmdir(this: *NodeFS, args: Arguments.RmDir, comptime _: Flavor) Maybe(Return.Rmdir) {
|
|
if (args.recursive) {
|
|
std.fs.cwd().deleteTree(args.path.slice()) catch |err| {
|
|
const errno: bun.C.E = switch (err) {
|
|
error.InvalidHandle => .BADF,
|
|
error.AccessDenied => .PERM,
|
|
error.FileTooBig => .FBIG,
|
|
error.SymLinkLoop => .LOOP,
|
|
error.ProcessFdQuotaExceeded => .NFILE,
|
|
error.NameTooLong => .NAMETOOLONG,
|
|
error.SystemFdQuotaExceeded => .MFILE,
|
|
error.SystemResources => .NOMEM,
|
|
error.ReadOnlyFileSystem => .ROFS,
|
|
error.FileSystem => .IO,
|
|
error.FileBusy => .BUSY,
|
|
error.DeviceBusy => .BUSY,
|
|
|
|
// One of the path components was not a directory.
|
|
// This error is unreachable if `sub_path` does not contain a path separator.
|
|
error.NotDir => .NOTDIR,
|
|
// On Windows, file paths must be valid Unicode.
|
|
error.InvalidUtf8 => .INVAL,
|
|
|
|
// On Windows, file paths cannot contain these characters:
|
|
// '/', '*', '?', '"', '<', '>', '|'
|
|
error.BadPathName => .INVAL,
|
|
|
|
else => .FAULT,
|
|
};
|
|
return Maybe(Return.Rm){
|
|
.err = bun.sys.Error.fromCode(errno, .rmdir),
|
|
};
|
|
};
|
|
|
|
return Maybe(Return.Rmdir).success;
|
|
}
|
|
|
|
if (comptime Environment.isWindows) {
|
|
return Syscall.rmdir(args.path.sliceZ(&this.sync_error_buf));
|
|
}
|
|
|
|
return Maybe(Return.Rmdir).errnoSysP(system.rmdir(args.path.sliceZ(&this.sync_error_buf)), .rmdir, args.path.slice()) orelse
|
|
Maybe(Return.Rmdir).success;
|
|
}
|
|
|
|
pub fn rm(this: *NodeFS, args: Arguments.RmDir, comptime _: Flavor) Maybe(Return.Rm) {
|
|
// We cannot use removefileat() on macOS because it does not handle write-protected files as expected.
|
|
if (args.recursive) {
|
|
// TODO: switch to an implementation which does not use any "unreachable"
|
|
std.fs.cwd().deleteTree(args.path.slice()) catch |err| {
|
|
const errno: E = switch (err) {
|
|
error.InvalidHandle => .BADF,
|
|
error.AccessDenied => .PERM,
|
|
error.FileTooBig => .FBIG,
|
|
error.SymLinkLoop => .LOOP,
|
|
error.ProcessFdQuotaExceeded => .NFILE,
|
|
error.NameTooLong => .NAMETOOLONG,
|
|
error.SystemFdQuotaExceeded => .MFILE,
|
|
error.SystemResources => .NOMEM,
|
|
error.ReadOnlyFileSystem => .ROFS,
|
|
error.FileSystem => .IO,
|
|
error.FileBusy => .BUSY,
|
|
error.DeviceBusy => .BUSY,
|
|
|
|
// One of the path components was not a directory.
|
|
// This error is unreachable if `sub_path` does not contain a path separator.
|
|
error.NotDir => .NOTDIR,
|
|
// On Windows, file paths must be valid Unicode.
|
|
error.InvalidUtf8 => .INVAL,
|
|
|
|
// On Windows, file paths cannot contain these characters:
|
|
// '/', '*', '?', '"', '<', '>', '|'
|
|
error.BadPathName => .INVAL,
|
|
|
|
else => .FAULT,
|
|
};
|
|
if (args.force) {
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
return Maybe(Return.Rm){
|
|
.err = bun.sys.Error.fromCode(errno, .unlink),
|
|
};
|
|
};
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
|
|
const dest = args.path.sliceZ(&this.sync_error_buf);
|
|
|
|
std.os.unlinkZ(dest) catch |er| {
|
|
// empircally, it seems to return AccessDenied when the
|
|
// file is actually a directory on macOS.
|
|
if (args.recursive and
|
|
(er == error.IsDir or er == error.NotDir or er == error.AccessDenied))
|
|
{
|
|
std.os.rmdirZ(dest) catch |err| {
|
|
if (args.force) {
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
|
|
const code: E = switch (err) {
|
|
error.AccessDenied => .PERM,
|
|
error.SymLinkLoop => .LOOP,
|
|
error.NameTooLong => .NAMETOOLONG,
|
|
error.SystemResources => .NOMEM,
|
|
error.ReadOnlyFileSystem => .ROFS,
|
|
error.FileBusy => .BUSY,
|
|
error.FileNotFound => .NOENT,
|
|
error.InvalidUtf8 => .INVAL,
|
|
error.BadPathName => .INVAL,
|
|
else => .FAULT,
|
|
};
|
|
|
|
return .{
|
|
.err = bun.sys.Error.fromCode(
|
|
code,
|
|
.rmdir,
|
|
),
|
|
};
|
|
};
|
|
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
|
|
if (args.force) {
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
|
|
{
|
|
const code: E = switch (er) {
|
|
error.AccessDenied => .PERM,
|
|
error.SymLinkLoop => .LOOP,
|
|
error.NameTooLong => .NAMETOOLONG,
|
|
error.SystemResources => .NOMEM,
|
|
error.ReadOnlyFileSystem => .ROFS,
|
|
error.FileBusy => .BUSY,
|
|
error.InvalidUtf8 => .INVAL,
|
|
error.BadPathName => .INVAL,
|
|
error.FileNotFound => .NOENT,
|
|
else => .FAULT,
|
|
};
|
|
|
|
return .{
|
|
.err = bun.sys.Error.fromCode(
|
|
code,
|
|
.unlink,
|
|
),
|
|
};
|
|
}
|
|
};
|
|
|
|
return Maybe(Return.Rm).success;
|
|
}
|
|
|
|
pub fn stat(this: *NodeFS, args: Arguments.Stat, comptime _: Flavor) Maybe(Return.Stat) {
|
|
return switch (Syscall.stat(args.path.sliceZ(&this.sync_error_buf))) {
|
|
.result => |result| .{
|
|
.result = .{ .stats = Stats.init(result, args.big_int) },
|
|
},
|
|
.err => |err| brk: {
|
|
if (!args.throw_if_no_entry and err.getErrno() == .NOENT) {
|
|
return .{ .result = .{ .not_found = {} } };
|
|
}
|
|
break :brk .{ .err = err };
|
|
},
|
|
};
|
|
}
|
|
|
|
pub fn symlink(this: *NodeFS, args: Arguments.Symlink, comptime _: Flavor) Maybe(Return.Symlink) {
|
|
var to_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
|
|
|
|
if (Environment.isWindows) {
|
|
const target: [:0]u8 = args.old_path.sliceZWithForceCopy(&this.sync_error_buf, true);
|
|
// UV does not normalize slashes in symlink targets, but Node does
|
|
// See https://github.com/oven-sh/bun/issues/8273
|
|
//
|
|
// TODO: investigate if simd can be easily used here
|
|
for (target) |*c| {
|
|
if (c.* == '/') {
|
|
c.* = '\\';
|
|
}
|
|
}
|
|
return Syscall.symlinkUV(
|
|
target,
|
|
args.new_path.sliceZ(&to_buf),
|
|
switch (args.link_type) {
|
|
.file => 0,
|
|
.dir => uv.UV_FS_SYMLINK_DIR,
|
|
.junction => uv.UV_FS_SYMLINK_JUNCTION,
|
|
},
|
|
);
|
|
}
|
|
|
|
return Syscall.symlink(
|
|
args.old_path.sliceZ(&this.sync_error_buf),
|
|
args.new_path.sliceZ(&to_buf),
|
|
);
|
|
}
|
|
|
|
fn _truncate(this: *NodeFS, path: PathLike, len: JSC.WebCore.Blob.SizeType, flags: i32, comptime _: Flavor) Maybe(Return.Truncate) {
|
|
if (comptime Environment.isWindows) {
|
|
const file = bun.sys.open(
|
|
path.sliceZ(&this.sync_error_buf),
|
|
os.O.WRONLY | flags,
|
|
0o644,
|
|
);
|
|
if (file == .err)
|
|
return .{ .err = file.err.withPath(path.slice()) };
|
|
defer _ = Syscall.close(file.result);
|
|
return Syscall.ftruncate(file.result, len);
|
|
}
|
|
|
|
return Maybe(Return.Truncate).errnoSys(C.truncate(path.sliceZ(&this.sync_error_buf), len), .truncate) orelse
|
|
Maybe(Return.Truncate).success;
|
|
}
|
|
|
|
pub fn truncate(this: *NodeFS, args: Arguments.Truncate, comptime flavor: Flavor) Maybe(Return.Truncate) {
|
|
return switch (args.path) {
|
|
.fd => |fd| this.ftruncate(
|
|
Arguments.FTruncate{ .fd = fd, .len = args.len },
|
|
flavor,
|
|
),
|
|
.path => this._truncate(
|
|
args.path.path,
|
|
args.len,
|
|
args.flags,
|
|
flavor,
|
|
),
|
|
};
|
|
}
|
|
|
|
pub fn unlink(this: *NodeFS, args: Arguments.Unlink, comptime _: Flavor) Maybe(Return.Unlink) {
|
|
if (Environment.isWindows) {
|
|
return Syscall.unlink(args.path.sliceZ(&this.sync_error_buf));
|
|
}
|
|
return Maybe(Return.Unlink).errnoSysP(system.unlink(args.path.sliceZ(&this.sync_error_buf)), .unlink, args.path.slice()) orelse
|
|
Maybe(Return.Unlink).success;
|
|
}
|
|
|
|
pub fn watchFile(_: *NodeFS, args: Arguments.WatchFile, comptime flavor: Flavor) Maybe(Return.WatchFile) {
|
|
std.debug.assert(flavor == .sync);
|
|
|
|
const watcher = args.createStatWatcher() catch |err| {
|
|
const buf = std.fmt.allocPrint(bun.default_allocator, "{s} watching {}", .{ @errorName(err), bun.fmt.QuotedFormatter{ .text = args.path.slice() } }) catch unreachable;
|
|
defer bun.default_allocator.free(buf);
|
|
args.global_this.throwValue((JSC.SystemError{
|
|
.message = bun.String.init(buf),
|
|
.code = bun.String.init(@errorName(err)),
|
|
.path = bun.String.init(args.path.slice()),
|
|
}).toErrorInstance(args.global_this));
|
|
return Maybe(Return.Watch){ .result = JSC.JSValue.undefined };
|
|
};
|
|
return Maybe(Return.Watch){ .result = watcher };
|
|
}
|
|
|
|
pub fn unwatchFile(_: *NodeFS, _: Arguments.UnwatchFile, comptime _: Flavor) Maybe(Return.UnwatchFile) {
|
|
return Maybe(Return.UnwatchFile).todo();
|
|
}
|
|
|
|
pub fn utimes(this: *NodeFS, args: Arguments.Utimes, comptime _: Flavor) Maybe(Return.Utimes) {
|
|
if (comptime Environment.isWindows) {
|
|
var req: uv.fs_t = uv.fs_t.uninitialized;
|
|
defer req.deinit();
|
|
const rc = uv.uv_fs_utime(
|
|
bun.Async.Loop.get(),
|
|
&req,
|
|
args.path.sliceZ(&this.sync_error_buf).ptr,
|
|
args.atime,
|
|
args.mtime,
|
|
null,
|
|
);
|
|
return if (rc.errno()) |errno|
|
|
.{ .err = Syscall.Error{
|
|
.errno = errno,
|
|
.syscall = .utimes,
|
|
} }
|
|
else
|
|
Maybe(Return.Utimes).success;
|
|
}
|
|
|
|
std.debug.assert(args.mtime.tv_nsec <= 1e9);
|
|
std.debug.assert(args.atime.tv_nsec <= 1e9);
|
|
var times = [2]std.c.timeval{
|
|
.{
|
|
.tv_sec = args.atime.tv_sec,
|
|
.tv_usec = @intCast(@divTrunc(args.atime.tv_nsec, std.time.ns_per_us)),
|
|
},
|
|
.{
|
|
.tv_sec = args.mtime.tv_sec,
|
|
.tv_usec = @intCast(@divTrunc(args.mtime.tv_nsec, std.time.ns_per_us)),
|
|
},
|
|
};
|
|
|
|
return if (Maybe(Return.Utimes).errnoSysP(std.c.utimes(args.path.sliceZ(&this.sync_error_buf), ×), .utimes, args.path.slice())) |err|
|
|
err
|
|
else
|
|
Maybe(Return.Utimes).success;
|
|
}
|
|
|
|
pub fn lutimes(this: *NodeFS, args: Arguments.Lutimes, comptime _: Flavor) Maybe(Return.Lutimes) {
|
|
if (comptime Environment.isWindows) {
|
|
var req: uv.fs_t = uv.fs_t.uninitialized;
|
|
defer req.deinit();
|
|
const rc = uv.uv_fs_lutime(
|
|
bun.Async.Loop.get(),
|
|
&req,
|
|
args.path.sliceZ(&this.sync_error_buf).ptr,
|
|
args.atime,
|
|
args.mtime,
|
|
null,
|
|
);
|
|
return if (rc.errno()) |errno|
|
|
.{ .err = Syscall.Error{
|
|
.errno = errno,
|
|
.syscall = .utimes,
|
|
} }
|
|
else
|
|
Maybe(Return.Utimes).success;
|
|
}
|
|
|
|
std.debug.assert(args.mtime.tv_nsec <= 1e9);
|
|
std.debug.assert(args.atime.tv_nsec <= 1e9);
|
|
var times = [2]std.c.timeval{
|
|
.{
|
|
.tv_sec = args.atime.tv_sec,
|
|
.tv_usec = @intCast(@divTrunc(args.atime.tv_nsec, std.time.ns_per_us)),
|
|
},
|
|
.{
|
|
.tv_sec = args.mtime.tv_sec,
|
|
.tv_usec = @intCast(@divTrunc(args.mtime.tv_nsec, std.time.ns_per_us)),
|
|
},
|
|
};
|
|
|
|
return if (Maybe(Return.Lutimes).errnoSysP(C.lutimes(args.path.sliceZ(&this.sync_error_buf), ×), .lutimes, args.path.slice())) |err|
|
|
err
|
|
else
|
|
Maybe(Return.Lutimes).success;
|
|
}
|
|
|
|
pub fn watch(_: *NodeFS, args: Arguments.Watch, comptime _: Flavor) Maybe(Return.Watch) {
|
|
const watcher = args.createFSWatcher() catch |err| {
|
|
const buf = std.fmt.allocPrint(bun.default_allocator, "{s} watching {}", .{ @errorName(err), bun.fmt.QuotedFormatter{ .text = args.path.slice() } }) catch unreachable;
|
|
defer bun.default_allocator.free(buf);
|
|
args.global_this.throwValue((JSC.SystemError{
|
|
.message = bun.String.init(buf),
|
|
.code = bun.String.init(@errorName(err)),
|
|
.syscall = bun.String.static("watch"),
|
|
.path = bun.String.init(args.path.slice()),
|
|
}).toErrorInstance(args.global_this));
|
|
return Maybe(Return.Watch){ .result = JSC.JSValue.undefined };
|
|
};
|
|
return Maybe(Return.Watch){ .result = watcher };
|
|
}
|
|
|
|
pub fn createReadStream(_: *NodeFS, _: Arguments.CreateReadStream, comptime _: Flavor) Maybe(Return.CreateReadStream) {
|
|
return Maybe(Return.CreateReadStream).todo();
|
|
}
|
|
|
|
pub fn createWriteStream(_: *NodeFS, _: Arguments.CreateWriteStream, comptime _: Flavor) Maybe(Return.CreateWriteStream) {
|
|
return Maybe(Return.CreateWriteStream).todo();
|
|
}
|
|
|
|
/// This function is `cpSync`, but only if you pass `{ recursive: ..., force: ..., errorOnExist: ..., mode: ... }'
|
|
/// The other options like `filter` use a JS fallback, see `src/js/internal/fs/cp.ts`
|
|
pub fn cp(this: *NodeFS, args: Arguments.Cp, comptime flavor: Flavor) Maybe(Return.Cp) {
|
|
comptime std.debug.assert(flavor == .sync);
|
|
|
|
var src_buf: bun.PathBuffer = undefined;
|
|
var dest_buf: bun.PathBuffer = undefined;
|
|
|
|
const src = args.src.osPath(&src_buf);
|
|
const dest = args.dest.osPath(&dest_buf);
|
|
|
|
return this._cpSync(
|
|
@as(*bun.OSPathBuffer, @alignCast(@ptrCast(&src_buf))),
|
|
@intCast(src.len),
|
|
@as(*bun.OSPathBuffer, @alignCast(@ptrCast(&dest_buf))),
|
|
@intCast(dest.len),
|
|
args.flags,
|
|
);
|
|
}
|
|
|
|
pub fn osPathIntoSyncErrorBuf(this: *NodeFS, slice: anytype) []const u8 {
|
|
if (Environment.isWindows) {
|
|
return bun.strings.fromWPath(&this.sync_error_buf, slice);
|
|
} else {
|
|
@memcpy(this.sync_error_buf[0..slice.len], slice);
|
|
return this.sync_error_buf[0..slice.len];
|
|
}
|
|
}
|
|
|
|
pub fn osPathIntoSyncErrorBufOverlap(this: *NodeFS, slice: anytype) []const u8 {
|
|
if (Environment.isWindows) {
|
|
var tmp: bun.WPathBuffer = undefined;
|
|
@memcpy(tmp[0..slice.len], slice);
|
|
return bun.strings.fromWPath(&this.sync_error_buf, tmp[0..slice.len]);
|
|
} else {}
|
|
}
|
|
|
|
fn _cpSync(
|
|
this: *NodeFS,
|
|
src_buf: *bun.OSPathBuffer,
|
|
src_dir_len: PathString.PathInt,
|
|
dest_buf: *bun.OSPathBuffer,
|
|
dest_dir_len: PathString.PathInt,
|
|
args: Arguments.Cp.Flags,
|
|
) Maybe(Return.Cp) {
|
|
const src = src_buf[0..src_dir_len :0];
|
|
const dest = dest_buf[0..dest_dir_len :0];
|
|
|
|
if (Environment.isWindows) {
|
|
const attributes = windows.GetFileAttributesW(src);
|
|
if (attributes == windows.INVALID_FILE_ATTRIBUTES) {
|
|
return .{ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
} };
|
|
}
|
|
|
|
if ((attributes & windows.FILE_ATTRIBUTE_DIRECTORY) == 0) {
|
|
const r = this._copySingleFileSync(
|
|
src,
|
|
dest,
|
|
@enumFromInt((if (args.errorOnExist or !args.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
attributes,
|
|
);
|
|
if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.errorOnExist) {
|
|
return Maybe(Return.Cp).success;
|
|
}
|
|
return r;
|
|
}
|
|
} else {
|
|
const stat_ = switch (Syscall.lstat(src)) {
|
|
.result => |result| result,
|
|
.err => |err| {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
return .{ .err = err.withPath(this.sync_error_buf[0..src.len]) };
|
|
},
|
|
};
|
|
|
|
if (!os.S.ISDIR(stat_.mode)) {
|
|
const r = this._copySingleFileSync(
|
|
src,
|
|
dest,
|
|
@enumFromInt((if (args.errorOnExist or !args.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
stat_,
|
|
);
|
|
if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.errorOnExist) {
|
|
return Maybe(Return.Cp).success;
|
|
}
|
|
return r;
|
|
}
|
|
}
|
|
|
|
if (!args.recursive) {
|
|
return .{
|
|
.err = .{
|
|
.errno = @intFromEnum(E.ISDIR),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
},
|
|
};
|
|
}
|
|
|
|
if (comptime Environment.isMac) {
|
|
if (Maybe(Return.Cp).errnoSysP(C.clonefile(src, dest, 0), .clonefile, src)) |err| {
|
|
switch (err.getErrno()) {
|
|
.ACCES,
|
|
.NAMETOOLONG,
|
|
.ROFS,
|
|
.PERM,
|
|
.INVAL,
|
|
=> {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
return .{ .err = err.err.withPath(this.sync_error_buf[0..src.len]) };
|
|
},
|
|
// Other errors may be due to clonefile() not being supported
|
|
// We'll fall back to other implementations
|
|
else => {},
|
|
}
|
|
} else {
|
|
return Maybe(Return.Cp).success;
|
|
}
|
|
}
|
|
|
|
const flags = os.O.DIRECTORY | os.O.RDONLY;
|
|
const fd = switch (Syscall.openatOSPath(
|
|
bun.toFD((std.fs.cwd().fd)),
|
|
src,
|
|
flags,
|
|
0,
|
|
)) {
|
|
.err => |err| {
|
|
return .{ .err = err.withPath(this.osPathIntoSyncErrorBuf(src)) };
|
|
},
|
|
.result => |fd_| fd_,
|
|
};
|
|
defer _ = Syscall.close(fd);
|
|
|
|
switch (this.mkdirRecursiveOSPath(dest, Arguments.Mkdir.DefaultMode, false)) {
|
|
.err => |err| return Maybe(Return.Cp){ .err = err },
|
|
.result => {},
|
|
}
|
|
|
|
var iterator = iterator: {
|
|
const dir = fd.asDir();
|
|
break :iterator DirIterator.iterate(dir, if (Environment.isWindows) .u16 else .u8);
|
|
};
|
|
var entry = iterator.next();
|
|
while (switch (entry) {
|
|
.err => |err| {
|
|
return .{ .err = err.withPath(this.osPathIntoSyncErrorBuf(src)) };
|
|
},
|
|
.result => |ent| ent,
|
|
}) |current| : (entry = iterator.next()) {
|
|
const name_slice = current.name.slice();
|
|
|
|
@memcpy(src_buf[src_dir_len + 1 .. src_dir_len + 1 + name_slice.len], name_slice);
|
|
src_buf[src_dir_len] = std.fs.path.sep;
|
|
src_buf[src_dir_len + 1 + name_slice.len] = 0;
|
|
|
|
@memcpy(dest_buf[dest_dir_len + 1 .. dest_dir_len + 1 + name_slice.len], name_slice);
|
|
dest_buf[dest_dir_len] = std.fs.path.sep;
|
|
dest_buf[dest_dir_len + 1 + name_slice.len] = 0;
|
|
|
|
switch (current.kind) {
|
|
.directory => {
|
|
const r = this._cpSync(
|
|
src_buf,
|
|
src_dir_len + @as(PathString.PathInt, @intCast(1 + name_slice.len)),
|
|
dest_buf,
|
|
dest_dir_len + @as(PathString.PathInt, @intCast(1 + name_slice.len)),
|
|
args,
|
|
);
|
|
switch (r) {
|
|
.err => return r,
|
|
.result => {},
|
|
}
|
|
},
|
|
else => {
|
|
const r = this._copySingleFileSync(
|
|
src_buf[0 .. src_dir_len + 1 + name_slice.len :0],
|
|
dest_buf[0 .. dest_dir_len + 1 + name_slice.len :0],
|
|
@enumFromInt((if (args.errorOnExist or !args.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
null,
|
|
);
|
|
switch (r) {
|
|
.err => {
|
|
if (r.err.errno == @intFromEnum(E.EXIST) and !args.errorOnExist) {
|
|
continue;
|
|
}
|
|
return r;
|
|
},
|
|
.result => {},
|
|
}
|
|
},
|
|
}
|
|
}
|
|
return Maybe(Return.Cp).success;
|
|
}
|
|
|
|
/// This is `copyFile`, but it copies symlinks as-is
|
|
pub fn _copySingleFileSync(
|
|
this: *NodeFS,
|
|
src: bun.OSPathSliceZ,
|
|
dest: bun.OSPathSliceZ,
|
|
mode: Constants.Copyfile,
|
|
/// Stat on posix, file attributes on windows
|
|
reuse_stat: ?if (Environment.isWindows) windows.DWORD else std.os.Stat,
|
|
) Maybe(Return.CopyFile) {
|
|
const ret = Maybe(Return.CopyFile);
|
|
|
|
// TODO: do we need to fchown?
|
|
if (Environment.isMac) {
|
|
if (mode.isForceClone()) {
|
|
// https://www.manpagez.com/man/2/clonefile/
|
|
return ret.errnoSysP(C.clonefile(src, dest, 0), .clonefile, src) orelse ret.success;
|
|
} else {
|
|
const stat_ = reuse_stat orelse switch (Syscall.lstat(src)) {
|
|
.result => |result| result,
|
|
.err => |err| {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
return .{ .err = err.withPath(this.sync_error_buf[0..src.len]) };
|
|
},
|
|
};
|
|
|
|
if (!os.S.ISREG(stat_.mode)) {
|
|
if (os.S.ISLNK(stat_.mode)) {
|
|
var mode_: Mode = C.darwin.COPYFILE_ACL | C.darwin.COPYFILE_DATA | C.darwin.COPYFILE_NOFOLLOW_SRC;
|
|
if (mode.shouldntOverwrite()) {
|
|
mode_ |= C.darwin.COPYFILE_EXCL;
|
|
}
|
|
|
|
return ret.errnoSysP(C.copyfile(src, dest, null, mode_), .copyfile, src) orelse ret.success;
|
|
}
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
return Maybe(Return.CopyFile){ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOTSUP),
|
|
.path = this.sync_error_buf[0..src.len],
|
|
.syscall = .copyfile,
|
|
} };
|
|
}
|
|
|
|
// 64 KB is about the break-even point for clonefile() to be worth it
|
|
// at least, on an M1 with an NVME SSD.
|
|
if (stat_.size > 128 * 1024) {
|
|
if (!mode.shouldntOverwrite()) {
|
|
// clonefile() will fail if it already exists
|
|
_ = Syscall.unlink(dest);
|
|
}
|
|
|
|
if (ret.errnoSysP(C.clonefile(src, dest, 0), .clonefile, src) == null) {
|
|
_ = C.chmod(dest, stat_.mode);
|
|
return ret.success;
|
|
}
|
|
} else {
|
|
const src_fd = switch (Syscall.open(src, std.os.O.RDONLY, 0o644)) {
|
|
.result => |result| result,
|
|
.err => |err| {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
return .{ .err = err.withPath(this.sync_error_buf[0..src.len]) };
|
|
},
|
|
};
|
|
defer {
|
|
_ = Syscall.close(src_fd);
|
|
}
|
|
|
|
var flags: Mode = std.os.O.CREAT | std.os.O.WRONLY;
|
|
var wrote: usize = 0;
|
|
if (mode.shouldntOverwrite()) {
|
|
flags |= std.os.O.EXCL;
|
|
}
|
|
|
|
const dest_fd = dest_fd: {
|
|
switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| break :dest_fd result,
|
|
.err => |err| {
|
|
if (err.getErrno() == .NOENT) {
|
|
// Create the parent directory if it doesn't exist
|
|
var len = dest.len;
|
|
while (len > 0 and dest[len - 1] != std.fs.path.sep) {
|
|
len -= 1;
|
|
}
|
|
const mkdirResult = this.mkdirRecursive(.{
|
|
.path = PathLike{ .string = PathString.init(dest[0..len]) },
|
|
.recursive = true,
|
|
}, .sync);
|
|
if (mkdirResult == .err) {
|
|
return Maybe(Return.CopyFile){ .err = mkdirResult.err };
|
|
}
|
|
|
|
switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| break :dest_fd result,
|
|
.err => {},
|
|
}
|
|
}
|
|
|
|
@memcpy(this.sync_error_buf[0..dest.len], dest);
|
|
return Maybe(Return.CopyFile){ .err = err.withPath(this.sync_error_buf[0..dest.len]) };
|
|
},
|
|
}
|
|
};
|
|
defer {
|
|
_ = std.c.ftruncate(dest_fd.int(), @as(std.c.off_t, @intCast(@as(u63, @truncate(wrote)))));
|
|
_ = C.fchmod(dest_fd.int(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
}
|
|
|
|
return copyFileUsingReadWriteLoop(src, dest, src_fd, dest_fd, @intCast(@max(stat_.size, 0)), &wrote);
|
|
}
|
|
}
|
|
|
|
// we fallback to copyfile() when the file is > 128 KB and clonefile fails
|
|
// clonefile() isn't supported on all devices
|
|
// nor is it supported across devices
|
|
var mode_: Mode = C.darwin.COPYFILE_ACL | C.darwin.COPYFILE_DATA | C.darwin.COPYFILE_NOFOLLOW_SRC;
|
|
if (mode.shouldntOverwrite()) {
|
|
mode_ |= C.darwin.COPYFILE_EXCL;
|
|
}
|
|
|
|
return ret.errnoSysP(C.copyfile(src, dest, null, mode_), .copyfile, src) orelse ret.success;
|
|
}
|
|
|
|
if (Environment.isLinux) {
|
|
// https://manpages.debian.org/testing/manpages-dev/ioctl_ficlone.2.en.html
|
|
if (mode.isForceClone()) {
|
|
return Maybe(Return.CopyFile).todo();
|
|
}
|
|
|
|
const src_fd = switch (Syscall.open(src, std.os.O.RDONLY | std.os.O.NOFOLLOW, 0o644)) {
|
|
.result => |result| result,
|
|
.err => |err| {
|
|
if (err.getErrno() == .LOOP) {
|
|
// ELOOP is returned when you open a symlink with NOFOLLOW.
|
|
// as in, it does not actually let you open it.
|
|
return Syscall.symlink(src, dest);
|
|
}
|
|
|
|
return .{ .err = err };
|
|
},
|
|
};
|
|
defer {
|
|
_ = Syscall.close(src_fd);
|
|
}
|
|
|
|
const stat_: linux.Stat = switch (Syscall.fstat(src_fd)) {
|
|
.result => |result| result,
|
|
.err => |err| return Maybe(Return.CopyFile){ .err = err },
|
|
};
|
|
|
|
if (!os.S.ISREG(stat_.mode)) {
|
|
return Maybe(Return.CopyFile){ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOTSUP),
|
|
.syscall = .copyfile,
|
|
} };
|
|
}
|
|
|
|
var flags: Mode = std.os.O.CREAT | std.os.O.WRONLY;
|
|
var wrote: usize = 0;
|
|
if (mode.shouldntOverwrite()) {
|
|
flags |= std.os.O.EXCL;
|
|
}
|
|
|
|
const dest_fd = dest_fd: {
|
|
switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| break :dest_fd result,
|
|
.err => |err| {
|
|
if (err.getErrno() == .NOENT) {
|
|
// Create the parent directory if it doesn't exist
|
|
var len = dest.len;
|
|
while (len > 0 and dest[len - 1] != std.fs.path.sep) {
|
|
len -= 1;
|
|
}
|
|
const mkdirResult = this.mkdirRecursive(.{
|
|
.path = PathLike{ .string = PathString.init(dest[0..len]) },
|
|
.recursive = true,
|
|
}, .sync);
|
|
if (mkdirResult == .err) {
|
|
return Maybe(Return.CopyFile){ .err = mkdirResult.err };
|
|
}
|
|
|
|
switch (Syscall.open(dest, flags, JSC.Node.default_permission)) {
|
|
.result => |result| break :dest_fd result,
|
|
.err => {},
|
|
}
|
|
}
|
|
|
|
@memcpy(this.sync_error_buf[0..dest.len], dest);
|
|
return Maybe(Return.CopyFile){ .err = err.withPath(this.sync_error_buf[0..dest.len]) };
|
|
},
|
|
}
|
|
};
|
|
|
|
var size: usize = @intCast(@max(stat_.size, 0));
|
|
|
|
if (os.S.ISREG(stat_.mode) and bun.can_use_ioctl_ficlone()) {
|
|
const rc = bun.C.linux.ioctl_ficlone(dest_fd, src_fd);
|
|
if (rc == 0) {
|
|
_ = C.fchmod(dest_fd.cast(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
return ret.success;
|
|
}
|
|
|
|
bun.disable_ioctl_ficlone();
|
|
}
|
|
|
|
defer {
|
|
_ = linux.ftruncate(dest_fd.cast(), @as(i64, @intCast(@as(u63, @truncate(wrote)))));
|
|
_ = linux.fchmod(dest_fd.cast(), stat_.mode);
|
|
_ = Syscall.close(dest_fd);
|
|
}
|
|
|
|
var off_in_copy = @as(i64, @bitCast(@as(u64, 0)));
|
|
var off_out_copy = @as(i64, @bitCast(@as(u64, 0)));
|
|
|
|
if (!bun.canUseCopyFileRangeSyscall()) {
|
|
return copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
}
|
|
|
|
if (size == 0) {
|
|
// copy until EOF
|
|
while (true) {
|
|
// Linux Kernel 5.3 or later
|
|
// Not supported in gVisor
|
|
const written = linux.copy_file_range(src_fd.cast(), &off_in_copy, dest_fd.cast(), &off_out_copy, std.mem.page_size, 0);
|
|
if (ret.errnoSysP(written, .copy_file_range, dest)) |err| {
|
|
return switch (err.getErrno()) {
|
|
inline .XDEV, .NOSYS => |errno| brk: {
|
|
if (comptime errno == .NOSYS) {
|
|
bun.disableCopyFileRangeSyscall();
|
|
}
|
|
break :brk copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
},
|
|
else => return err,
|
|
};
|
|
}
|
|
// wrote zero bytes means EOF
|
|
if (written == 0) break;
|
|
wrote +|= written;
|
|
}
|
|
} else {
|
|
while (size > 0) {
|
|
// Linux Kernel 5.3 or later
|
|
// Not supported in gVisor
|
|
const written = linux.copy_file_range(src_fd.cast(), &off_in_copy, dest_fd.cast(), &off_out_copy, size, 0);
|
|
if (ret.errnoSysP(written, .copy_file_range, dest)) |err| {
|
|
return switch (err.getErrno()) {
|
|
inline .XDEV, .NOSYS => |errno| brk: {
|
|
if (comptime errno == .NOSYS) {
|
|
bun.disableCopyFileRangeSyscall();
|
|
}
|
|
break :brk copyFileUsingSendfileOnLinuxWithReadWriteFallback(src, dest, src_fd, dest_fd, size, &wrote);
|
|
},
|
|
else => return err,
|
|
};
|
|
}
|
|
// wrote zero bytes means EOF
|
|
if (written == 0) break;
|
|
wrote +|= written;
|
|
size -|= written;
|
|
}
|
|
}
|
|
|
|
return ret.success;
|
|
}
|
|
|
|
if (Environment.isWindows) {
|
|
const stat_ = reuse_stat orelse switch (windows.GetFileAttributesW(src)) {
|
|
windows.INVALID_FILE_ATTRIBUTES => return .{ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
} },
|
|
else => |result| result,
|
|
};
|
|
if (stat_ & windows.FILE_ATTRIBUTE_REPARSE_POINT == 0) {
|
|
if (windows.CopyFileW(src, dest, @intFromBool(mode.shouldntOverwrite())) == 0) {
|
|
const err = windows.GetLastError();
|
|
const errpath = switch (err) {
|
|
.FILE_EXISTS, .ALREADY_EXISTS => dest,
|
|
else => src,
|
|
};
|
|
return Maybe(Return.CopyFile).errnoSysP(0, .copyfile, this.osPathIntoSyncErrorBuf(errpath)) orelse .{ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
} };
|
|
}
|
|
return ret.success;
|
|
} else {
|
|
const handle = switch (bun.sys.openatWindows(bun.invalid_fd, src, os.O.RDONLY)) {
|
|
.err => |err| return .{ .err = err },
|
|
.result => |src_fd| src_fd,
|
|
};
|
|
var wbuf: bun.WPathBuffer = undefined;
|
|
const len = bun.windows.GetFinalPathNameByHandleW(handle.cast(), &wbuf, wbuf.len, 0);
|
|
if (len == 0) {
|
|
return Maybe(Return.CopyFile).errnoSysP(0, .copyfile, this.osPathIntoSyncErrorBuf(dest)) orelse .{ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(dest),
|
|
} };
|
|
}
|
|
const flags = if (stat_ & windows.FILE_ATTRIBUTE_DIRECTORY != 0)
|
|
std.os.windows.SYMBOLIC_LINK_FLAG_DIRECTORY
|
|
else
|
|
0;
|
|
if (windows.CreateSymbolicLinkW(dest, wbuf[0..len :0], flags) == 0) {
|
|
return Maybe(Return.CopyFile).errnoSysP(0, .copyfile, this.osPathIntoSyncErrorBuf(dest)) orelse .{
|
|
.err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(dest),
|
|
},
|
|
};
|
|
}
|
|
return ret.success;
|
|
}
|
|
}
|
|
|
|
return ret.todo();
|
|
}
|
|
|
|
/// Directory scanning + clonefile will block this thread, then each individual file copy (what the sync version
|
|
/// calls "_copySingleFileSync") will be dispatched as a separate task.
|
|
pub fn cpAsync(this: *NodeFS, task: *AsyncCpTask) void {
|
|
const args = task.args;
|
|
var src_buf: bun.OSPathBuffer = undefined;
|
|
var dest_buf: bun.OSPathBuffer = undefined;
|
|
const src = args.src.osPath(@ptrCast(&src_buf));
|
|
const dest = args.dest.osPath(@ptrCast(&dest_buf));
|
|
|
|
if (Environment.isWindows) {
|
|
const attributes = windows.GetFileAttributesW(src);
|
|
if (attributes == windows.INVALID_FILE_ATTRIBUTES) {
|
|
task.finishConcurrently(.{ .err = .{
|
|
.errno = @intFromEnum(C.SystemErrno.ENOENT),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
} });
|
|
return;
|
|
}
|
|
const file_or_symlink = (attributes & windows.FILE_ATTRIBUTE_DIRECTORY) == 0 or (attributes & windows.FILE_ATTRIBUTE_REPARSE_POINT) != 0;
|
|
if (file_or_symlink) {
|
|
const r = this._copySingleFileSync(
|
|
src,
|
|
dest,
|
|
@enumFromInt((if (args.flags.errorOnExist or !args.flags.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
attributes,
|
|
);
|
|
if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
|
|
task.finishConcurrently(Maybe(Return.Cp).success);
|
|
return;
|
|
}
|
|
task.finishConcurrently(r);
|
|
return;
|
|
}
|
|
} else {
|
|
const stat_ = switch (Syscall.lstat(src)) {
|
|
.result => |result| result,
|
|
.err => |err| {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
task.finishConcurrently(.{ .err = err.withPath(this.sync_error_buf[0..src.len]) });
|
|
return;
|
|
},
|
|
};
|
|
|
|
if (!os.S.ISDIR(stat_.mode)) {
|
|
// This is the only file, there is no point in dispatching subtasks
|
|
const r = this._copySingleFileSync(
|
|
src,
|
|
dest,
|
|
@enumFromInt((if (args.flags.errorOnExist or !args.flags.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
|
|
stat_,
|
|
);
|
|
if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
|
|
task.finishConcurrently(Maybe(Return.Cp).success);
|
|
return;
|
|
}
|
|
task.finishConcurrently(r);
|
|
return;
|
|
}
|
|
}
|
|
if (!args.flags.recursive) {
|
|
task.finishConcurrently(.{ .err = .{
|
|
.errno = @intFromEnum(E.ISDIR),
|
|
.syscall = .copyfile,
|
|
.path = this.osPathIntoSyncErrorBuf(src),
|
|
} });
|
|
return;
|
|
}
|
|
|
|
const success = this._cpAsyncDirectory(args.flags, task, &src_buf, @intCast(src.len), &dest_buf, @intCast(dest.len));
|
|
const old_count = task.subtask_count.fetchSub(1, .Monotonic);
|
|
if (success and old_count == 1) {
|
|
task.finishConcurrently(Maybe(Return.Cp).success);
|
|
}
|
|
}
|
|
|
|
// returns boolean `should_continue`
|
|
fn _cpAsyncDirectory(
|
|
this: *NodeFS,
|
|
args: Arguments.Cp.Flags,
|
|
task: *AsyncCpTask,
|
|
src_buf: *bun.OSPathBuffer,
|
|
src_dir_len: PathString.PathInt,
|
|
dest_buf: *bun.OSPathBuffer,
|
|
dest_dir_len: PathString.PathInt,
|
|
) bool {
|
|
const src = src_buf[0..src_dir_len :0];
|
|
const dest = dest_buf[0..dest_dir_len :0];
|
|
|
|
if (comptime Environment.isMac) {
|
|
if (Maybe(Return.Cp).errnoSysP(C.clonefile(src, dest, 0), .clonefile, src)) |err| {
|
|
switch (err.getErrno()) {
|
|
.ACCES,
|
|
.NAMETOOLONG,
|
|
.ROFS,
|
|
.PERM,
|
|
.INVAL,
|
|
=> {
|
|
@memcpy(this.sync_error_buf[0..src.len], src);
|
|
task.finishConcurrently(.{ .err = err.err.withPath(this.sync_error_buf[0..src.len]) });
|
|
return false;
|
|
},
|
|
// Other errors may be due to clonefile() not being supported
|
|
// We'll fall back to other implementations
|
|
else => {},
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
const open_flags = os.O.DIRECTORY | os.O.RDONLY;
|
|
const fd = switch (Syscall.openatOSPath(bun.toFD(std.fs.cwd().fd), src, open_flags, 0)) {
|
|
.err => |err| {
|
|
task.finishConcurrently(.{ .err = err.withPath(this.osPathIntoSyncErrorBuf(src)) });
|
|
return false;
|
|
},
|
|
.result => |fd_| fd_,
|
|
};
|
|
defer _ = Syscall.close(fd);
|
|
|
|
var buf: bun.OSPathBuffer = undefined;
|
|
|
|
// const normdest = bun.path.normalizeStringGenericTZ(bun.OSPathChar, dest, &buf, true, std.fs.path.sep, bun.path.isSepAnyT, false, true);
|
|
const normdest: bun.OSPathSliceZ = if (Environment.isWindows)
|
|
switch (bun.sys.normalizePathWindows(u16, bun.invalid_fd, dest, &buf)) {
|
|
.err => |err| {
|
|
task.finishConcurrently(.{ .err = err });
|
|
return false;
|
|
},
|
|
.result => |normdest| normdest,
|
|
}
|
|
else
|
|
dest;
|
|
|
|
const mkdir_ = this.mkdirRecursiveOSPath(normdest, Arguments.Mkdir.DefaultMode, false);
|
|
switch (mkdir_) {
|
|
.err => |err| {
|
|
task.finishConcurrently(.{ .err = err });
|
|
return false;
|
|
},
|
|
.result => {},
|
|
}
|
|
|
|
const dir = fd.asDir();
|
|
var iterator = DirIterator.iterate(dir, if (Environment.isWindows) .u16 else .u8);
|
|
var entry = iterator.next();
|
|
while (switch (entry) {
|
|
.err => |err| {
|
|
// @memcpy(this.sync_error_buf[0..src.len], src);
|
|
task.finishConcurrently(.{ .err = err.withPath(this.osPathIntoSyncErrorBuf(src)) });
|
|
return false;
|
|
},
|
|
.result => |ent| ent,
|
|
}) |current| : (entry = iterator.next()) {
|
|
switch (current.kind) {
|
|
.directory => {
|
|
const cname = current.name.slice();
|
|
@memcpy(src_buf[src_dir_len + 1 .. src_dir_len + 1 + cname.len], cname);
|
|
src_buf[src_dir_len] = std.fs.path.sep;
|
|
src_buf[src_dir_len + 1 + cname.len] = 0;
|
|
|
|
@memcpy(dest_buf[dest_dir_len + 1 .. dest_dir_len + 1 + cname.len], cname);
|
|
dest_buf[dest_dir_len] = std.fs.path.sep;
|
|
dest_buf[dest_dir_len + 1 + cname.len] = 0;
|
|
|
|
const should_continue = this._cpAsyncDirectory(
|
|
args,
|
|
task,
|
|
src_buf,
|
|
@truncate(src_dir_len + 1 + cname.len),
|
|
dest_buf,
|
|
@truncate(dest_dir_len + 1 + cname.len),
|
|
);
|
|
if (!should_continue) return false;
|
|
},
|
|
else => {
|
|
_ = task.subtask_count.fetchAdd(1, .Monotonic);
|
|
|
|
const cname = current.name.slice();
|
|
|
|
// Allocate a path buffer for the path data
|
|
var path_buf = bun.default_allocator.alloc(
|
|
bun.OSPathChar,
|
|
src_dir_len + 1 + cname.len + 1 + dest_dir_len + 1 + cname.len + 1,
|
|
) catch bun.outOfMemory();
|
|
|
|
@memcpy(path_buf[0..src_dir_len], src_buf[0..src_dir_len]);
|
|
path_buf[src_dir_len] = std.fs.path.sep;
|
|
@memcpy(path_buf[src_dir_len + 1 .. src_dir_len + 1 + cname.len], cname);
|
|
path_buf[src_dir_len + 1 + cname.len] = 0;
|
|
|
|
@memcpy(path_buf[src_dir_len + 1 + cname.len + 1 .. src_dir_len + 1 + cname.len + 1 + dest_dir_len], dest_buf[0..dest_dir_len]);
|
|
path_buf[src_dir_len + 1 + cname.len + 1 + dest_dir_len] = std.fs.path.sep;
|
|
@memcpy(path_buf[src_dir_len + 1 + cname.len + 1 + dest_dir_len + 1 .. src_dir_len + 1 + cname.len + 1 + dest_dir_len + 1 + cname.len], cname);
|
|
path_buf[src_dir_len + 1 + cname.len + 1 + dest_dir_len + 1 + cname.len] = 0;
|
|
|
|
AsyncCpSingleFileTask.create(
|
|
task,
|
|
path_buf[0 .. src_dir_len + 1 + cname.len :0],
|
|
path_buf[src_dir_len + 1 + cname.len + 1 .. src_dir_len + 1 + cname.len + 1 + dest_dir_len + 1 + cname.len :0],
|
|
);
|
|
},
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
pub export fn Bun__mkdirp(globalThis: *JSC.JSGlobalObject, path: [*:0]const u8) bool {
|
|
return globalThis.bunVM().nodeFS().mkdirRecursive(
|
|
Arguments.Mkdir{
|
|
.path = PathLike{ .string = PathString.init(bun.span(path)) },
|
|
.recursive = true,
|
|
},
|
|
.sync,
|
|
) != .err;
|
|
}
|
|
|
|
comptime {
|
|
if (!JSC.is_bindgen)
|
|
_ = Bun__mkdirp;
|
|
}
|