@nocobase/plugin-workflow-javascript 2.1.0-beta.10 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/src/isolate/scheduler.cc

@@ -0,0 +1,191 @@
+#include "environment.h"
+#include "executor.h"
+#include "node_wrapper.h"
+#include "scheduler.h"
+#include <memory>
+#include <v8.h>
+#include <utility>
+
+using namespace v8;
+namespace ivm {
+namespace {
+	thread_pool_t thread_pool{std::thread::hardware_concurrency() + 1};
+}
+
+/*
+ * Scheduler implementation
+ */
+void Scheduler::CancelAsync() {
+	if (async_wait != nullptr) {
+		async_wait->Cancel();
+	}
+}
+
+void Scheduler::DoneRunning() {
+	assert(status == Status::Running);
+	status = Status::Waiting;
+}
+
+void Scheduler::InterruptIsolate() {
+	assert(status == Status::Running);
+	// Since this callback will be called by v8 we can be certain the pointer to `isolate` is still valid
+	env.GetIsolate()->RequestInterrupt([](Isolate* /*isolate_ptr*/, void* env_ptr) {
+		static_cast<IsolateEnvironment*>(env_ptr)->InterruptEntryAsync();
+	}, &env);
+}
+
+void Scheduler::InterruptSyncIsolate() {
+	env.GetIsolate()->RequestInterrupt([](Isolate* /*isolate_ptr*/, void* env_ptr) {
+		static_cast<IsolateEnvironment*>(env_ptr)->InterruptEntrySync();
+	}, &env);
+}
+
+auto Scheduler::WakeIsolate(std::shared_ptr<IsolateEnvironment> isolate_ptr) -> bool {
+	if (status == Status::Waiting) {
+		status = Status::Running;
+		// Move shared reference to this scheduler to ensure the IsolateEnvironment won't be deleted
+		// before a thread picks up this work.
+		assert(!env_ref);
+		env_ref = std::move(isolate_ptr);
+		IncrementUvRef();
+		SendWake();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+auto LockedScheduler::GetForegroundTaskRunner() -> std::shared_ptr<v8::TaskRunner> {
+	return env.GetTaskRunner();
+}
+
+void LockedScheduler::DecrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder) {
+	auto ref = holder->GetIsolate();
+	if (ref) {
+		ref->scheduler->DecrementUvRef();
+	}
+}
+
+void LockedScheduler::IncrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder) {
+	auto ref = holder->GetIsolate();
+	if (ref) {
+		ref->scheduler->IncrementUvRef();
+	}
+}
+
+IsolatedScheduler::IsolatedScheduler(IsolateEnvironment& env, UvScheduler& default_scheduler) :
+	LockedScheduler{env},
+	default_scheduler{default_scheduler} {}
+
+void IsolatedScheduler::DecrementUvRef() {
+	default_scheduler.DecrementUvRef();
+}
+
+void IsolatedScheduler::IncrementUvRef() {
+	default_scheduler.IncrementUvRef();
+}
+
+void IsolatedScheduler::SendWake() {
+	thread_pool.exec(thread_affinity, [](bool pool_thread, void* param) {
+		auto& scheduler = *static_cast<IsolatedScheduler*>(param);
+		auto ref = std::exchange(scheduler.env_ref, {});
+		ref->AsyncEntry();
+		if (!pool_thread) {
+			ref->GetIsolate()->DiscardThreadSpecificMetadata();
+		}
+		// Grab reference to default scheduler, since resetting `ref` may deallocate `scheduler` and
+		// invalidate the instance. Resetting `ref` must take place here because the destructor might
+		// invoke cleanup tasks on the default isolate which will increment `uv_ref_count`.
+		// `uv_ref_count` needs to be incremented before it's decremented otherwise `UvScheduler` will
+		// try to invoke `uv_ref` from a non-default thread.
+		auto& default_scheduler = scheduler.default_scheduler;
+		ref = {};
+		if (--default_scheduler.uv_ref_count == 0) {
+			// Wake up the libuv loop so we can unref the async handle from the default thread.
+			uv_async_send(default_scheduler.uv_async);
+		}
+	}, this);
+}
+
+UvScheduler::UvScheduler(IsolateEnvironment& env) :
+		LockedScheduler{env},
+		loop{node::GetCurrentEventLoop(v8::Isolate::GetCurrent())},
+		uv_async{new uv_async_t} {
+	uv_async_init(loop, uv_async, [](uv_async_t* async) {
+		auto& scheduler = *static_cast<UvScheduler*>(async->data);
+		auto ref = [&]() {
+			// Lock is required to access env_ref on the default scheduler but a non-default scheduler
+			// doesn't need it. This is because `WakeIsolate` can trigger this function via
+			// `uv_async_send` while another thread is writing to `env_ref`
+			std::lock_guard<std::mutex> lock{scheduler.mutex};
+			return std::exchange(scheduler.env_ref, {});
+		}();
+		if (ref) {
+			ref->AsyncEntry();
+			if (--scheduler.uv_ref_count == 0) {
+				uv_unref(reinterpret_cast<uv_handle_t*>(scheduler.uv_async));
+			}
+		} else {
+			if (scheduler.uv_ref_count.load() == 0) {
+				uv_unref(reinterpret_cast<uv_handle_t*>(scheduler.uv_async));
+			}
+		}
+	});
+	uv_async->data = this;
+	uv_unref(reinterpret_cast<uv_handle_t*>(uv_async));
+}
+
+UvScheduler::~UvScheduler() {
+	uv_close(reinterpret_cast<uv_handle_t*>(uv_async), [](uv_handle_t* handle) {
+		delete reinterpret_cast<uv_async_t*>(handle);
+	});
+}
+
+void UvScheduler::DecrementUvRef() {
+	if (--uv_ref_count == 0) {
+		if (Executor::IsDefaultThread()) {
+			uv_unref(reinterpret_cast<uv_handle_t*>(uv_async));
+		} else {
+			uv_async_send(uv_async);
+		}
+	}
+}
+
+void UvScheduler::IncrementUvRef() {
+	if (++uv_ref_count == 1) {
+		// Only the default thread should be able to reach this branch
+		assert(Executor::IsDefaultThread());
+		uv_ref(reinterpret_cast<uv_handle_t*>(uv_async));
+	}
+}
+
+void UvScheduler::SendWake() {
+	uv_async_send(uv_async);
+}
+
+/*
+ * Scheduler::AsyncWait implementation
+ */
+Scheduler::AsyncWait::~AsyncWait() {
+	scheduler.Lock()->async_wait = nullptr;
+}
+
+void Scheduler::AsyncWait::Cancel() {
+	*state.write() = canceled;
+	state.notify_one();
+}
+
+void Scheduler::AsyncWait::Done() {
+	*state.write() = finished;
+	state.notify_one();
+}
+
+auto Scheduler::AsyncWait::Wait() const -> Scheduler::AsyncWait::State {
+	auto lock = state.read<true>();
+	while (*lock == pending) {
+		lock.wait();
+	}
+	return *lock;
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/scheduler.h

@@ -0,0 +1,165 @@
+#pragma once
+#include "platform_delegate.h"
+#include "runnable.h"
+#include "lib/lockable.h"
+#include "lib/thread_pool.h"
+#include <uv.h>
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <queue>
+
+namespace ivm {
+class IsolateEnvironment;
+class IsolateHolder;
+
+// gcc 5's std::queue implementation has an explicit default ctor so std::exchange(..., {})
+// doesn't work. This changed in C++11 and I guess they're behind.
+template <class Type>
+auto ExchangeDefault(Type& container) {
+	return std::exchange(container, Type{});
+}
+
+/**
+ * Keeps track of tasks an isolate needs to run and manages its run state (running or waiting).
+ * This does all the interaction with libuv async and the thread pool.
+ */
+class UvScheduler;
+class Scheduler {
+	friend IsolateEnvironment;
+	friend class LockedScheduler;
+	private:
+		using TaskQueue = std::queue<std::unique_ptr<Runnable>>;
+
+	public:
+		explicit Scheduler(IsolateEnvironment& env) : env{env} {}
+		Scheduler(const Scheduler&) = delete;
+		~Scheduler() = default;
+		auto operator=(const Scheduler&) = delete;
+
+		// Request cancellation of current async task
+		void CancelAsync();
+		// Called after AsyncEntry finishes
+		void DoneRunning();
+		// Request an interrupt in this isolate. `status` must == Running to invoke this.
+		void InterruptIsolate();
+		// Interrupts an isolate running in the default thread
+		void InterruptSyncIsolate();
+		// Returns true if a wake was scheduled, false if the isolate is already running.
+		auto WakeIsolate(std::shared_ptr<IsolateEnvironment> isolate_ptr) -> bool;
+
+		// Scheduler::AsyncWait will pause the current thread until woken up by another thread
+		class AsyncWait {
+			public:
+				enum State { pending, finished, canceled };
+
+				// This is templated so we can cast to the protected base class here instead of at the call
+				// site
+				template <class Type>
+				explicit AsyncWait(Type& scheduler) :
+						scheduler{scheduler} {
+					auto lock = scheduler.Lock();
+					assert(lock->async_wait == nullptr);
+					lock->async_wait = this;
+				}
+				AsyncWait(const AsyncWait&) = delete;
+				~AsyncWait();
+				auto operator=(const AsyncWait&) = delete;
+
+				void Cancel();
+				void Done();
+				auto Wait() const -> State;
+
+				class LockedScheduler& scheduler;
+				lockable_t<State, false, true> state{pending};
+		};
+
+		// Task queues
+		TaskQueue tasks;
+		TaskQueue handle_tasks;
+		TaskQueue interrupts;
+		TaskQueue sync_interrupts;
+
+	protected:
+		mutable std::mutex mutex;
+		mutable std::condition_variable cv;
+		std::shared_ptr<IsolateEnvironment> env_ref;
+		IsolateEnvironment& env;
+
+	private:
+		virtual void IncrementUvRef() = 0;
+		virtual void DecrementUvRef() = 0;
+		virtual void SendWake() = 0;
+
+		enum class Status { Waiting, Running };
+		AsyncWait* async_wait = nullptr;
+		Status status = Status::Waiting;
+};
+
+class LockedScheduler : protected Scheduler, public node::IsolatePlatformDelegate {
+	friend Scheduler::AsyncWait;
+	public:
+		using Scheduler::Scheduler;
+
+		// Locks the scheduler and return a lock with access to public interface
+		auto Lock() {
+			// TODO: Would be nice to find a way to roll this into the lockable abstraction
+			class Lock {
+				public:
+					auto operator*() -> auto& { return scheduler; }
+					auto operator->() { return &scheduler; }
+
+					explicit Lock(Scheduler& scheduler, std::mutex& mutex) :
+						lock{mutex},
+						scheduler{scheduler} {}
+
+				private:
+					std::unique_lock<std::mutex> lock;
+					Scheduler& scheduler;
+			};
+			return Lock{*this, mutex};
+		}
+
+		// IsolatePlatformDelegate overrides
+		auto GetForegroundTaskRunner() -> std::shared_ptr<v8::TaskRunner> final;
+		auto IdleTasksEnabled() -> bool final { return false; }
+
+		// Used to ref/unref the uv handle from C++ API
+		static void DecrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder);
+		static void IncrementUvRefForIsolate(const std::shared_ptr<IsolateHolder>& holder);
+};
+
+class IsolatedScheduler final : public LockedScheduler {
+	public:
+		explicit IsolatedScheduler(IsolateEnvironment& env, UvScheduler& default_scheduler);
+
+	private:
+		void DecrementUvRef() override;
+		void IncrementUvRef() override;
+		void SendWake() override;
+
+		thread_pool_t::affinity_t thread_affinity;
+		UvScheduler& default_scheduler;
+};
+
+class UvScheduler final : public LockedScheduler {
+	friend IsolatedScheduler;
+	friend Scheduler;
+	public:
+		explicit UvScheduler(IsolateEnvironment& env);
+		UvScheduler(const UvScheduler&) = delete;
+		~UvScheduler();
+		auto operator=(const UvScheduler&) = delete;
+
+	private:
+		void DecrementUvRef() override;
+		void IncrementUvRef() override;
+		void SendWake() override;
+
+		uv_loop_t* loop = nullptr;
+		uv_async_t* uv_async = nullptr;
+		std::atomic<int> uv_ref_count{0};
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/specific.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <v8.h>
+#include <atomic>
+
+namespace ivm {
+namespace detail {
+	extern std::atomic<size_t> IsolateSpecificSize;
+}
+
+/**
+ * Like thread_local data, but specific to an Isolate instead.
+ */
+template <class Type>
+class IsolateSpecific {
+	template <class>
+	friend class IsolateSpecific;
+
+	public:
+		IsolateSpecific() = default;
+
+		template <class Functor>
+		auto Deref(Functor callback) -> v8::Local<Type>;
+
+	private:
+		size_t key{detail::IsolateSpecificSize++};
+		union HandleConvert {
+			explicit HandleConvert(v8::Local<v8::Data> data) : data{data} {}
+			v8::Local<v8::Data> data;
+			v8::Local<Type> value;
+		};
+};
+
+} // namespace ivm
+
+#include "environment.h"

package/dist/node_modules/isolated-vm/src/isolate/stack_trace.cc

@@ -0,0 +1,219 @@
+#include "stack_trace.h"
+#include "functor_runners.h"
+#include "specific.h"
+#include "v8_version.h"
+#include <cstring>
+#include <sstream>
+#include <string>
+
+using namespace v8;
+
+namespace ivm {
+
+static auto StringConcat(Isolate* isolate, Local<String> left, Local<String> right) -> Local<String> {
+	return String::Concat(isolate, left, right);
+}
+
+/**
+ * This returns an object that's like Symbol() in JS but only C++ can see it.
+ */
+auto GetPrivateStackSymbol() -> Local<Private> {
+	static IsolateSpecific<Private> holder;
+	return holder.Deref([]() {
+		return Private::New(Isolate::GetCurrent());
+	});
+}
+
+/**
+ * Helper which renders to string either a String (pass-through), StackTrace (render), or Array
+ * (recursion pair)
+ */
+auto RenderErrorStack(Local<Value> data) -> Local<String> {
+	Isolate* isolate = Isolate::GetCurrent();
+	if (data->IsString()) {
+		// Plain string. We need to remove the first line of `stack` to avoid repeating the error
+		// message
+		String::Utf8Value string_value{isolate, data.As<String>()};
+		const char* c_str = *string_value;
+		// If it starts with "    at" then the message has already been removed
+		if (strncmp(c_str, "    at", 6) == 0) {
+			return data.As<String>();
+		}
+		// Find the newline
+		const char* pos = strchr(c_str, '\n');
+		while (pos != nullptr) {
+			if (strncmp(pos + 1, "    at", 6) == 0) {
+				// Found the start of the stack
+				return Unmaybe(String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(pos), NewStringType::kNormal));
+			}
+			pos = strchr(pos + 1, '\n');
+		}
+		// No stack, just a message
+		return String::Empty(isolate);
+
+	} else if (data->IsArray()) {
+		// Array pair
+		Local<Context> context = isolate->GetCurrentContext();
+		Local<Array> array = data.As<Array>();
+		return StringConcat(isolate,
+			StringConcat(isolate,
+				RenderErrorStack(Unmaybe(array->Get(context, 1))),
+				Unmaybe(String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>("\n    at (<isolated-vm boundary>)"), NewStringType::kNormal))
+			),
+			RenderErrorStack(Unmaybe(array->Get(context, 0)))
+		);
+	} else {
+		// StackTraceHolder
+		StackTraceHolder& that = *ClassHandle::Unwrap<StackTraceHolder>(data.As<Object>());
+		Local<StackTrace> stack_trace = Deref(that.stack_trace);
+		return Unmaybe(String::NewFromUtf8(isolate, StackTraceHolder::RenderSingleStack(stack_trace).c_str(), NewStringType::kNormal));
+	}
+}
+
+/**
+ * Accessor on error `stack`. Renders from previously saved stack trace.
+ */
+void ErrorStackGetter(Local<Name> /*property*/, const PropertyCallbackInfo<Value>& info) {
+	FunctorRunners::RunCallback(info, [ &info ]() {
+		Isolate* isolate = Isolate::GetCurrent();
+		Local<Context> context = isolate->GetCurrentContext();
+		Local<Object> holder = info.This();
+		Local<Value> name = Unmaybe(holder->Get(context, StringTable::Get().name));
+		if (!name->IsString()) {
+			name = holder->GetConstructorName();
+		}
+		return StringConcat(isolate,
+			StringConcat(isolate, name.As<String>(), StringTable::Get().colonSpace),
+			StringConcat(isolate,
+				Unmaybe(
+					Unmaybe(info.This()->Get(context, StringTable::Get().message))->ToString(context)
+				),
+				RenderErrorStack(Unmaybe(holder->GetPrivate(context, GetPrivateStackSymbol())))
+			)
+		);
+	});
+}
+
+/**
+ * Utility function which sets the stack getter on an error object
+ */
+void AttachStackGetter(Local<Object> error, Local<Value> data) {
+	Local<Context> context = Isolate::GetCurrent()->GetCurrentContext();
+	Unmaybe(error->SetPrivate(context, GetPrivateStackSymbol(), data));
+	Unmaybe(error->SetAccessor(
+		context,
+		StringTable::Get().stack,
+		ErrorStackGetter, nullptr,
+		Local<Value>(),
+		AccessControl::DEFAULT,
+		PropertyAttribute::DontEnum
+	));
+}
+
+/**
+ * StackTraceHolder implementation
+ */
+StackTraceHolder::StackTraceHolder(Local<StackTrace> stack_handle) : stack_trace(Isolate::GetCurrent(), stack_handle) {}
+
+auto StackTraceHolder::Definition() -> Local<FunctionTemplate> {
+	return MakeClass("StackTraceHolder", nullptr);
+}
+
+void StackTraceHolder::AttachStack(Local<Object> error, Local<StackTrace> stack) {
+	AttachStackGetter(error, ClassHandle::NewInstance<StackTraceHolder>(stack));
+}
+
+void StackTraceHolder::ChainStack(Local<Object> error, Local<StackTrace> stack) {
+	Isolate* isolate = Isolate::GetCurrent();
+	Local<Context> context = isolate->GetCurrentContext();
+	Local<Value> existing_data = Unmaybe(error->GetPrivate(context, GetPrivateStackSymbol()));
+	if (existing_data->IsUndefined()) {
+		// This error has not passed through ivm yet. Get the existing stack trace.
+		Local<StackTrace> existing_stack = Exception::GetStackTrace(error);
+		if (existing_stack.IsEmpty()) {
+			// In this case it's probably passed through ExternalCopy which flattens the `stack` property
+			// into a plain value
+			existing_data = Unmaybe(error->Get(context, StringTable::Get().stack));
+			if (existing_data->IsUndefined() || !existing_data->IsString()) {
+				return AttachStack(error, stack);
+			}
+		} else {
+			existing_data = ClassHandle::NewInstance<StackTraceHolder>(existing_stack);
+		}
+	}
+	Local<Array> pair = Array::New(isolate, 2);
+	Unmaybe(pair->Set(context, 0, ClassHandle::NewInstance<StackTraceHolder>(stack)));
+	Unmaybe(pair->Set(context, 1, existing_data));
+	AttachStackGetter(error, pair);
+}
+
+auto StackTraceHolder::RenderSingleStack(Local<StackTrace> stack_trace) -> std::string {
+	Isolate* isolate = Isolate::GetCurrent();
+	std::stringstream ss;
+	int size = stack_trace->GetFrameCount();
+	for (int ii = 0; ii < size; ++ii) {
+		Local<StackFrame> frame = stack_trace->GetFrame(isolate, ii);
+		ss <<"\n    at ";
+		String::Utf8Value fn_name{isolate, frame->GetFunctionName()};
+		if (frame->IsWasm()) {
+			String::Utf8Value script_name{isolate, frame->GetScriptName()};
+			bool has_name = fn_name.length() != 0 || script_name.length() != 0;
+			if (has_name) {
+				if (script_name.length() == 0) {
+					ss <<*fn_name;
+				} else {
+					ss <<*script_name;
+					if (fn_name.length() != 0) {
+						ss <<"." <<*fn_name;
+					}
+				}
+				ss <<" (<WASM>";
+			}
+			ss <<frame->GetLineNumber() <<":" <<frame->GetColumn();
+			if (has_name) {
+				ss <<")";
+			}
+		} else {
+			if (frame->IsConstructor()) {
+				ss <<"new ";
+				if (fn_name.length() == 0) {
+					ss <<"<anonymous>";
+				} else {
+					ss <<*fn_name;
+				}
+			} else if (fn_name.length() != 0) {
+				ss <<*fn_name;
+			} else {
+				AppendFileLocation(isolate, frame, ss);
+				return ss.str();
+			}
+			ss <<" (";
+			AppendFileLocation(isolate, frame, ss);
+			ss <<")";
+		}
+	}
+	return ss.str();
+}
+
+void StackTraceHolder::AppendFileLocation(Isolate* /*isolate*/, Local<StackFrame> frame, std::stringstream& ss) {
+	String::Utf8Value script_name{Isolate::GetCurrent(), frame->GetScriptNameOrSourceURL()};
+	if (script_name.length() == 0) {
+		if (frame->IsEval()) {
+			ss <<"[eval]";
+		} else {
+			ss <<"<anonymous>";
+		}
+	} else {
+		ss <<*script_name;
+	}
+	int line_number = frame->GetLineNumber();
+	if (line_number != -1) {
+		ss <<":" <<line_number;
+		int column = frame->GetColumn();
+		if (column != -1) {
+			ss <<":" <<column;
+		}
+	}
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/stack_trace.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <v8.h>
+#include "class_handle.h"
+#include <string>
+
+namespace ivm {
+
+/**
+ * v8::StackTrace doesn't inherit from v8::Value so it can't be set as a property of an object which
+ * is what we need to do to pass stack traces in an efficent way.  So this gets around that.
+ */
+class StackTraceHolder : public ClassHandle {
+	private:
+		static void AppendFileLocation(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame, std::stringstream& ss);
+	public:
+		v8::Persistent<v8::StackTrace, v8::CopyablePersistentTraits<v8::StackTrace>> stack_trace;
+		explicit StackTraceHolder(v8::Local<v8::StackTrace> stack_handle);
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		static void AttachStack(v8::Local<v8::Object> error, v8::Local<v8::StackTrace> stack);
+		static void ChainStack(v8::Local<v8::Object> error, v8::Local<v8::StackTrace> stack);
+		static auto RenderSingleStack(v8::Local<v8::StackTrace> stack_trace) -> std::string;
+};
+
+} // namespace ivm