mirror of
https://github.com/oven-sh/bun
synced 2026-02-11 03:18:53 +00:00
715 lines
24 KiB
Zig
715 lines
24 KiB
Zig
const std = @import("std");
|
|
const JSC = bun.JSC;
|
|
const bun = @import("root").bun;
|
|
const Fs = @import("../../fs.zig");
|
|
const Path = @import("../../resolver/resolve_path.zig");
|
|
const Encoder = JSC.WebCore.Encoder;
|
|
const Mutex = @import("../../lock.zig").Lock;
|
|
|
|
const VirtualMachine = JSC.VirtualMachine;
|
|
const EventLoop = JSC.EventLoop;
|
|
const PathLike = JSC.Node.PathLike;
|
|
const ArgumentsSlice = JSC.Node.ArgumentsSlice;
|
|
const Output = bun.Output;
|
|
const string = bun.string;
|
|
const StoredFileDescriptorType = bun.StoredFileDescriptorType;
|
|
const Environment = bun.Environment;
|
|
const Async = bun.Async;
|
|
const log = Output.scoped(.@"fs.watch", true);
|
|
const PathWatcher = if (Environment.isWindows) @import("./win_watcher.zig") else @import("./path_watcher.zig");
|
|
|
|
pub const FSWatcher = struct {
|
|
ctx: *VirtualMachine,
|
|
verbose: bool = false,
|
|
|
|
mutex: Mutex,
|
|
signal: ?*JSC.AbortSignal,
|
|
persistent: bool,
|
|
path_watcher: ?*PathWatcher.PathWatcher,
|
|
poll_ref: Async.KeepAlive = .{},
|
|
globalThis: *JSC.JSGlobalObject,
|
|
js_this: JSC.JSValue,
|
|
encoding: JSC.Node.Encoding,
|
|
|
|
/// User can call close and pre-detach so we need to track this
|
|
closed: bool,
|
|
|
|
/// While it's not closed, the pending activity
|
|
pending_activity_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(1),
|
|
current_task: FSWatchTask = undefined,
|
|
|
|
pub usingnamespace JSC.Codegen.JSFSWatcher;
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub fn eventLoop(this: FSWatcher) *EventLoop {
|
|
return this.ctx.eventLoop();
|
|
}
|
|
|
|
pub fn enqueueTaskConcurrent(this: FSWatcher, task: *JSC.ConcurrentTask) void {
|
|
this.eventLoop().enqueueTaskConcurrent(task);
|
|
}
|
|
|
|
pub fn deinit(this: *FSWatcher) void {
|
|
// stop all managers and signals
|
|
this.detach();
|
|
this.destroy();
|
|
}
|
|
|
|
pub const FSWatchTask = if (Environment.isWindows) FSWatchTaskWindows else FSWatchTaskPosix;
|
|
pub const FSWatchTaskPosix = struct {
|
|
ctx: *FSWatcher,
|
|
count: u8 = 0,
|
|
|
|
entries: [8]Entry = undefined,
|
|
concurrent_task: JSC.ConcurrentTask = undefined,
|
|
|
|
pub const Entry = struct {
|
|
event: Event,
|
|
needs_free: bool,
|
|
};
|
|
|
|
pub fn append(this: *FSWatchTask, event: Event, needs_free: bool) void {
|
|
if (this.count == 8) {
|
|
this.enqueue();
|
|
const ctx = this.ctx;
|
|
this.* = .{
|
|
.ctx = ctx,
|
|
.count = 0,
|
|
};
|
|
}
|
|
|
|
this.entries[this.count] = .{
|
|
.event = event,
|
|
.needs_free = needs_free,
|
|
};
|
|
this.count += 1;
|
|
}
|
|
|
|
pub fn run(this: *FSWatchTask) void {
|
|
// this runs on JS Context Thread
|
|
|
|
for (this.entries[0..this.count]) |entry| {
|
|
switch (entry.event) {
|
|
inline .rename, .change => |file_path, t| {
|
|
this.ctx.emit(file_path, t);
|
|
},
|
|
.@"error" => |err| {
|
|
this.ctx.emitError(err);
|
|
},
|
|
.abort => {
|
|
this.ctx.emitIfAborted();
|
|
},
|
|
.close => {
|
|
this.ctx.emit("", .close);
|
|
},
|
|
}
|
|
}
|
|
|
|
this.ctx.unrefTask();
|
|
}
|
|
|
|
pub fn appendAbort(this: *FSWatchTask) void {
|
|
this.append(.abort, false);
|
|
this.enqueue();
|
|
}
|
|
|
|
pub fn enqueue(this: *FSWatchTask) void {
|
|
if (this.count == 0)
|
|
return;
|
|
|
|
// if false is closed or detached (can still contain valid refs but will not create a new one)
|
|
if (this.ctx.refTask()) {
|
|
var that = FSWatchTask.new(this.*);
|
|
this.count = 0;
|
|
that.concurrent_task.task = JSC.Task.init(that);
|
|
this.ctx.enqueueTaskConcurrent(&that.concurrent_task);
|
|
return;
|
|
}
|
|
// closed or detached so just cleanEntries
|
|
this.cleanEntries();
|
|
}
|
|
pub fn cleanEntries(this: *FSWatchTask) void {
|
|
for (this.entries[0..this.count]) |*entry| {
|
|
if (entry.needs_free) {
|
|
entry.event.deinit();
|
|
}
|
|
}
|
|
this.count = 0;
|
|
}
|
|
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub fn deinit(this: *FSWatchTask) void {
|
|
this.cleanEntries();
|
|
if (comptime Environment.allow_assert) {
|
|
bun.assert(&this.ctx.current_task != this);
|
|
}
|
|
this.destroy();
|
|
}
|
|
};
|
|
|
|
pub const EventPathString = switch (Environment.os) {
|
|
.windows => FSWatchTaskWindows.StringOrBytesToDecode,
|
|
else => []const u8,
|
|
};
|
|
|
|
pub const Event = union(EventType) {
|
|
rename: EventPathString,
|
|
change: EventPathString,
|
|
@"error": bun.sys.Error,
|
|
abort: void,
|
|
close: void,
|
|
|
|
pub fn dupe(event: Event) !Event {
|
|
return switch (event) {
|
|
inline .rename, .change => |path, t| @unionInit(Event, @tagName(t), try bun.default_allocator.dupe(u8, path)),
|
|
inline else => |value, t| @unionInit(Event, @tagName(t), value),
|
|
};
|
|
}
|
|
|
|
pub fn deinit(event: *Event) void {
|
|
switch (event.*) {
|
|
.rename, .change => |*path| switch (Environment.os) {
|
|
else => bun.default_allocator.free(path.*),
|
|
.windows => path.deinit(),
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const EventType = enum(u8) {
|
|
rename = 0,
|
|
change = 1,
|
|
@"error" = 2,
|
|
abort = 3,
|
|
close = 4,
|
|
|
|
pub fn toJS(
|
|
this: EventType,
|
|
globalObject: *JSC.JSGlobalObject,
|
|
) JSC.JSValue {
|
|
return Bun__domEventNameToJS(globalObject, this);
|
|
}
|
|
|
|
extern fn Bun__domEventNameToJS(*JSC.JSGlobalObject, EventType) JSC.JSValue;
|
|
};
|
|
|
|
pub const FSWatchTaskWindows = struct {
|
|
event: Event = .{ .@"error" = .{ .errno = @intFromEnum(bun.C.SystemErrno.EINVAL), .syscall = .watch } },
|
|
ctx: *FSWatcher,
|
|
|
|
/// Unused: To match the API of the posix version
|
|
count: u0 = 0,
|
|
|
|
pub usingnamespace bun.New(@This());
|
|
|
|
pub const StringOrBytesToDecode = union(enum) {
|
|
string: bun.String,
|
|
bytes_to_free: []const u8,
|
|
|
|
pub fn deinit(this: *StringOrBytesToDecode) void {
|
|
switch (this.*) {
|
|
.string => this.string.deref(),
|
|
.bytes_to_free => {
|
|
bun.default_allocator.free(this.bytes_to_free);
|
|
this.bytes_to_free = "";
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn format(this: *const StringOrBytesToDecode, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
|
|
switch (this.*) {
|
|
.string => |str| try writer.print("{}", .{str}),
|
|
.bytes_to_free => |utf8| try writer.print("{s}", .{utf8}),
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn appendAbort(this: *FSWatchTaskWindows) void {
|
|
const ctx = this.ctx;
|
|
const task = FSWatchTaskWindows.new(.{
|
|
.ctx = ctx,
|
|
.event = .abort,
|
|
});
|
|
|
|
ctx.eventLoop().enqueueTask(JSC.Task.init(task));
|
|
}
|
|
|
|
/// this runs on JS Context Thread
|
|
pub fn run(this: *FSWatchTaskWindows) void {
|
|
var ctx = this.ctx;
|
|
|
|
switch (this.event) {
|
|
inline .rename, .change => |*path, event_type| {
|
|
if (ctx.encoding == .utf8) {
|
|
ctx.emitWithFilename(path.string.transferToJS(ctx.globalThis), event_type);
|
|
} else {
|
|
const bytes = path.bytes_to_free;
|
|
path.bytes_to_free = "";
|
|
ctx.emit(bytes, event_type);
|
|
bun.default_allocator.free(bytes);
|
|
}
|
|
},
|
|
.@"error" => |err| {
|
|
ctx.emitError(err);
|
|
},
|
|
.abort => {
|
|
ctx.emitIfAborted();
|
|
},
|
|
.close => {
|
|
ctx.emit("", .close);
|
|
},
|
|
}
|
|
|
|
ctx.unrefTask();
|
|
}
|
|
|
|
pub fn deinit(this: *FSWatchTaskWindows) void {
|
|
this.event.deinit();
|
|
this.destroy();
|
|
}
|
|
};
|
|
|
|
pub fn onPathUpdatePosix(ctx: ?*anyopaque, event: Event, is_file: bool) void {
|
|
const this = bun.cast(*FSWatcher, ctx.?);
|
|
|
|
if (this.verbose) {
|
|
switch (event) {
|
|
.rename, .change => |value| {
|
|
if (is_file) {
|
|
Output.prettyErrorln("<r> <d>File changed: {s}<r>", .{value});
|
|
} else {
|
|
Output.prettyErrorln("<r> <d>Dir changed: {s}<r>", .{value});
|
|
}
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
const cloned = event.dupe() catch bun.outOfMemory();
|
|
this.current_task.append(cloned, true);
|
|
}
|
|
|
|
pub fn onPathUpdateWindows(ctx: ?*anyopaque, event: Event, is_file: bool) void {
|
|
const this = bun.cast(*FSWatcher, ctx.?);
|
|
|
|
if (this.verbose) {
|
|
switch (event) {
|
|
.rename, .change => |value| {
|
|
if (is_file) {
|
|
Output.prettyErrorln("<r> <d>File changed: {}<r>", .{value});
|
|
} else {
|
|
Output.prettyErrorln("<r> <d>Dir changed: {}<r>", .{value});
|
|
}
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
if (!this.refTask()) {
|
|
return;
|
|
}
|
|
|
|
const task = FSWatchTaskWindows.new(.{
|
|
.ctx = this,
|
|
.event = event,
|
|
});
|
|
this.eventLoop().enqueueTask(JSC.Task.init(task));
|
|
}
|
|
|
|
pub const onPathUpdate = if (Environment.isWindows) onPathUpdateWindows else onPathUpdatePosix;
|
|
|
|
pub fn onUpdateEnd(ctx: ?*anyopaque) void {
|
|
const this = bun.cast(*FSWatcher, ctx.?);
|
|
if (this.verbose) {
|
|
Output.flush();
|
|
}
|
|
if (comptime Environment.isPosix) {
|
|
// we only enqueue after all events are processed
|
|
this.current_task.enqueue();
|
|
}
|
|
}
|
|
|
|
pub const Arguments = struct {
|
|
path: PathLike,
|
|
listener: JSC.JSValue,
|
|
global_this: JSC.C.JSContextRef,
|
|
signal: ?*JSC.AbortSignal,
|
|
persistent: bool,
|
|
recursive: bool,
|
|
encoding: JSC.Node.Encoding,
|
|
verbose: bool,
|
|
|
|
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Arguments {
|
|
const vm = ctx.vm();
|
|
const path = try PathLike.fromJS(ctx, arguments) orelse {
|
|
return ctx.throwInvalidArguments2("filename must be a string or TypedArray", .{});
|
|
};
|
|
var should_deinit_path = true;
|
|
defer if (should_deinit_path) path.deinit();
|
|
|
|
var listener: JSC.JSValue = .zero;
|
|
var signal: ?*JSC.AbortSignal = null;
|
|
var persistent: bool = true;
|
|
var recursive: bool = false;
|
|
var encoding: JSC.Node.Encoding = .utf8;
|
|
var verbose = false;
|
|
if (arguments.nextEat()) |options_or_callable| {
|
|
|
|
// options
|
|
if (options_or_callable.isObject()) {
|
|
if (options_or_callable.getTruthy(ctx, "persistent")) |persistent_| {
|
|
if (!persistent_.isBoolean()) {
|
|
return ctx.throwInvalidArguments2("persistent must be a boolean", .{});
|
|
}
|
|
persistent = persistent_.toBoolean();
|
|
}
|
|
|
|
if (options_or_callable.getTruthy(ctx, "verbose")) |verbose_| {
|
|
if (!verbose_.isBoolean()) {
|
|
return ctx.throwInvalidArguments2("verbose must be a boolean", .{});
|
|
}
|
|
verbose = verbose_.toBoolean();
|
|
}
|
|
|
|
if (options_or_callable.fastGet(ctx, .encoding)) |encoding_| {
|
|
encoding = try JSC.Node.Encoding.assert(encoding_, ctx, encoding);
|
|
}
|
|
|
|
if (options_or_callable.getTruthy(ctx, "recursive")) |recursive_| {
|
|
if (!recursive_.isBoolean()) {
|
|
return ctx.throwInvalidArguments2("recursive must be a boolean", .{});
|
|
}
|
|
recursive = recursive_.toBoolean();
|
|
}
|
|
|
|
// abort signal
|
|
if (options_or_callable.getTruthy(ctx, "signal")) |signal_| {
|
|
if (JSC.AbortSignal.fromJS(signal_)) |signal_obj| {
|
|
//Keep it alive
|
|
signal_.ensureStillAlive();
|
|
signal = signal_obj;
|
|
} else {
|
|
return ctx.throwInvalidArguments2("signal is not of type AbortSignal", .{});
|
|
}
|
|
}
|
|
|
|
// listener
|
|
if (arguments.nextEat()) |callable| {
|
|
if (!callable.isCell() or !callable.isCallable(vm)) {
|
|
return ctx.throwInvalidArguments2("Expected \"listener\" callback to be a function", .{});
|
|
}
|
|
listener = callable;
|
|
}
|
|
} else {
|
|
if (!options_or_callable.isCell() or !options_or_callable.isCallable(vm)) {
|
|
return ctx.throwInvalidArguments2("Expected \"listener\" callback to be a function", .{});
|
|
}
|
|
listener = options_or_callable;
|
|
}
|
|
}
|
|
if (listener == .zero) {
|
|
return ctx.throwInvalidArguments2("Expected \"listener\" callback", .{});
|
|
}
|
|
|
|
should_deinit_path = false;
|
|
|
|
return Arguments{
|
|
.path = path,
|
|
.listener = listener,
|
|
.global_this = ctx,
|
|
.signal = signal,
|
|
.persistent = persistent,
|
|
.recursive = recursive,
|
|
.encoding = encoding,
|
|
.verbose = verbose,
|
|
};
|
|
}
|
|
|
|
pub fn createFSWatcher(this: Arguments) JSC.Maybe(JSC.JSValue) {
|
|
return switch (FSWatcher.init(this)) {
|
|
.result => |result| .{ .result = result.js_this },
|
|
.err => |err| .{ .err = err },
|
|
};
|
|
}
|
|
};
|
|
|
|
pub fn initJS(this: *FSWatcher, listener: JSC.JSValue) void {
|
|
if (this.persistent) {
|
|
this.poll_ref.ref(this.ctx);
|
|
_ = this.pending_activity_count.fetchAdd(1, .monotonic);
|
|
}
|
|
|
|
const js_this = FSWatcher.toJS(this, this.globalThis);
|
|
js_this.ensureStillAlive();
|
|
this.js_this = js_this;
|
|
FSWatcher.listenerSetCached(js_this, this.globalThis, listener);
|
|
|
|
if (this.signal) |s| {
|
|
// already aborted?
|
|
if (s.aborted()) {
|
|
// safely abort next tick
|
|
this.current_task = .{
|
|
.ctx = this,
|
|
};
|
|
this.current_task.appendAbort();
|
|
} else {
|
|
// watch for abortion
|
|
this.signal = s.listen(FSWatcher, this, FSWatcher.emitAbort);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn emitIfAborted(this: *FSWatcher) void {
|
|
if (this.signal) |s| {
|
|
if (s.aborted()) {
|
|
const err = s.abortReason();
|
|
this.emitAbort(err);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn emitAbort(this: *FSWatcher, err: JSC.JSValue) void {
|
|
if (this.closed) return;
|
|
_ = this.pending_activity_count.fetchAdd(1, .monotonic);
|
|
defer this.close();
|
|
defer this.unrefTask();
|
|
|
|
err.ensureStillAlive();
|
|
if (this.js_this != .zero) {
|
|
const js_this = this.js_this;
|
|
js_this.ensureStillAlive();
|
|
if (FSWatcher.listenerGetCached(js_this)) |listener| {
|
|
listener.ensureStillAlive();
|
|
var args = [_]JSC.JSValue{
|
|
EventType.@"error".toJS(this.globalThis),
|
|
if (err.isEmptyOrUndefinedOrNull()) JSC.CommonAbortReason.UserAbort.toJS(this.globalThis) else err,
|
|
};
|
|
_ = listener.callWithGlobalThis(
|
|
this.globalThis,
|
|
&args,
|
|
) catch this.globalThis.clearException();
|
|
}
|
|
}
|
|
}
|
|
pub fn emitError(this: *FSWatcher, err: bun.sys.Error) void {
|
|
if (this.closed) return;
|
|
defer this.close();
|
|
|
|
if (this.js_this != .zero) {
|
|
const js_this = this.js_this;
|
|
js_this.ensureStillAlive();
|
|
if (FSWatcher.listenerGetCached(js_this)) |listener| {
|
|
listener.ensureStillAlive();
|
|
const globalObject = this.globalThis;
|
|
var args = [_]JSC.JSValue{
|
|
EventType.@"error".toJS(globalObject),
|
|
err.toJSC(globalObject),
|
|
};
|
|
_ = listener.callWithGlobalThis(
|
|
globalObject,
|
|
&args,
|
|
) catch |e| this.globalThis.reportActiveExceptionAsUnhandled(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn emitWithFilename(this: *FSWatcher, file_name: JSC.JSValue, comptime eventType: EventType) void {
|
|
const js_this = this.js_this;
|
|
if (js_this == .zero) return;
|
|
const listener = FSWatcher.listenerGetCached(js_this) orelse return;
|
|
emitJS(listener, this.globalThis, file_name, eventType);
|
|
}
|
|
|
|
pub fn emit(this: *FSWatcher, file_name: string, comptime event_type: EventType) void {
|
|
bun.assert(event_type != .@"error");
|
|
const js_this = this.js_this;
|
|
if (js_this == .zero) return;
|
|
const listener = FSWatcher.listenerGetCached(js_this) orelse return;
|
|
const globalObject = this.globalThis;
|
|
var filename: JSC.JSValue = .undefined;
|
|
if (file_name.len > 0) {
|
|
if (this.encoding == .buffer)
|
|
filename = JSC.ArrayBuffer.createBuffer(globalObject, file_name)
|
|
else if (this.encoding == .utf8) {
|
|
filename = JSC.ZigString.fromUTF8(file_name).toJS(globalObject);
|
|
} else {
|
|
// convert to desired encoding
|
|
filename = Encoder.toStringAtRuntime(file_name.ptr, file_name.len, globalObject, this.encoding);
|
|
}
|
|
}
|
|
|
|
emitJS(listener, globalObject, filename, event_type);
|
|
}
|
|
|
|
fn emitJS(listener: JSC.JSValue, globalObject: *JSC.JSGlobalObject, filename: JSC.JSValue, comptime event_type: EventType) void {
|
|
var args = [_]JSC.JSValue{
|
|
event_type.toJS(globalObject),
|
|
filename,
|
|
};
|
|
|
|
_ = listener.callWithGlobalThis(
|
|
globalObject,
|
|
&args,
|
|
) catch |err| globalObject.reportActiveExceptionAsUnhandled(err);
|
|
}
|
|
|
|
pub fn doRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
|
|
if (!this.closed and !this.persistent) {
|
|
this.persistent = true;
|
|
this.poll_ref.ref(this.ctx);
|
|
}
|
|
return .undefined;
|
|
}
|
|
|
|
pub fn doUnref(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
|
|
if (this.persistent) {
|
|
this.persistent = false;
|
|
this.poll_ref.unref(this.ctx);
|
|
}
|
|
return .undefined;
|
|
}
|
|
|
|
pub fn hasRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
|
|
return JSC.JSValue.jsBoolean(this.persistent);
|
|
}
|
|
|
|
// this can be called from Watcher Thread or JS Context Thread
|
|
pub fn refTask(this: *FSWatcher) bool {
|
|
@fence(.acquire);
|
|
this.mutex.lock();
|
|
defer this.mutex.unlock();
|
|
if (this.closed) return false;
|
|
_ = this.pending_activity_count.fetchAdd(1, .monotonic);
|
|
|
|
return true;
|
|
}
|
|
|
|
pub fn hasPendingActivity(this: *FSWatcher) bool {
|
|
@fence(.acquire);
|
|
return this.pending_activity_count.load(.acquire) > 0;
|
|
}
|
|
|
|
pub fn unrefTask(this: *FSWatcher) void {
|
|
this.mutex.lock();
|
|
defer this.mutex.unlock();
|
|
// JSC eventually will free it
|
|
_ = this.pending_activity_count.fetchSub(1, .monotonic);
|
|
}
|
|
|
|
pub fn close(this: *FSWatcher) void {
|
|
this.mutex.lock();
|
|
if (!this.closed) {
|
|
this.closed = true;
|
|
const js_this = this.js_this;
|
|
this.mutex.unlock();
|
|
this.detach();
|
|
|
|
if (js_this != .zero) {
|
|
if (FSWatcher.listenerGetCached(js_this)) |listener| {
|
|
_ = this.refTask();
|
|
log("emit('close')", .{});
|
|
emitJS(listener, this.globalThis, .undefined, .close);
|
|
this.unrefTask();
|
|
}
|
|
}
|
|
|
|
this.unrefTask();
|
|
} else {
|
|
this.mutex.unlock();
|
|
}
|
|
}
|
|
|
|
// this can be called multiple times
|
|
pub fn detach(this: *FSWatcher) void {
|
|
if (this.path_watcher) |path_watcher| {
|
|
this.path_watcher = null;
|
|
path_watcher.detach(this);
|
|
}
|
|
|
|
if (this.persistent) {
|
|
this.persistent = false;
|
|
this.poll_ref.unref(this.ctx);
|
|
}
|
|
|
|
if (this.signal) |signal| {
|
|
this.signal = null;
|
|
signal.detach(this);
|
|
}
|
|
|
|
this.js_this = .zero;
|
|
}
|
|
|
|
pub fn doClose(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
|
|
this.close();
|
|
return .undefined;
|
|
}
|
|
|
|
pub fn finalize(this: *FSWatcher) void {
|
|
this.deinit();
|
|
}
|
|
|
|
pub fn init(args: Arguments) bun.JSC.Maybe(*FSWatcher) {
|
|
var buf: bun.PathBuffer = undefined;
|
|
var slice = args.path.slice();
|
|
if (bun.strings.startsWith(slice, "file://")) {
|
|
slice = slice[6..];
|
|
}
|
|
|
|
var parts = [_]string{
|
|
slice,
|
|
};
|
|
|
|
const cwd = switch (bun.sys.getcwd(&buf)) {
|
|
.result => |r| r,
|
|
.err => |err| return .{ .err = err },
|
|
};
|
|
buf[cwd.len] = std.fs.path.sep;
|
|
|
|
var joined_buf: bun.PathBuffer = undefined;
|
|
const file_path = Path.joinAbsStringBuf(
|
|
buf[0 .. cwd.len + 1],
|
|
&joined_buf,
|
|
&parts,
|
|
.auto,
|
|
);
|
|
|
|
joined_buf[file_path.len] = 0;
|
|
const file_path_z = joined_buf[0..file_path.len :0];
|
|
|
|
const vm = args.global_this.bunVM();
|
|
|
|
var ctx = FSWatcher.new(.{
|
|
.ctx = vm,
|
|
.current_task = .{
|
|
.ctx = undefined,
|
|
.count = 0,
|
|
},
|
|
.mutex = .{},
|
|
.signal = if (args.signal) |s| s.ref() else null,
|
|
.persistent = args.persistent,
|
|
.path_watcher = null,
|
|
.globalThis = args.global_this,
|
|
.js_this = .zero,
|
|
.encoding = args.encoding,
|
|
.closed = false,
|
|
.verbose = args.verbose,
|
|
});
|
|
ctx.current_task.ctx = ctx;
|
|
|
|
ctx.path_watcher = if (args.signal == null or !args.signal.?.aborted())
|
|
switch (PathWatcher.watch(vm, file_path_z, args.recursive, onPathUpdate, onUpdateEnd, bun.cast(*anyopaque, ctx))) {
|
|
.result => |r| r,
|
|
.err => |err| {
|
|
ctx.deinit();
|
|
return .{ .err = err };
|
|
},
|
|
}
|
|
else
|
|
null;
|
|
ctx.initJS(args.listener);
|
|
return .{ .result = ctx };
|
|
}
|
|
};
|