@nocobase/plugin-workflow-javascript 2.1.0-beta.11 → 2.1.0-beta.13

package/dist/node_modules/isolated-vm/src/lib/timer.cc

@@ -0,0 +1,233 @@
+#include "timer.h"
+#include <cassert>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <utility>
+#include <unordered_set>
+
+namespace ivm {
+
+/**
+ * Contains data on a timer. This is shared between the timer_t handle and the thread responsible
+ * for the timer.
+ */
+struct timer_data_t {
+	timer_data_t(
+		std::chrono::steady_clock::time_point timeout,
+		void** holder,
+		timer_t::callback_t callback,
+		const std::lock_guard<std::mutex>& /*lock*/
+	) : callback{std::move(callback)}, holder{holder}, timeout{timeout} {
+		if (holder != nullptr) {
+			last_holder_value = std::exchange(*holder, static_cast<void*>(this));
+		}
+	}
+
+	auto adjust() -> bool {
+		if (paused_duration == std::chrono::steady_clock::duration{}) {
+			return false;
+		} else {
+			timeout += paused_duration;
+			paused_duration = {};
+			return true;
+		}
+	}
+
+	auto is_paused() const -> bool {
+		return paused_at != std::chrono::steady_clock::time_point{};
+	}
+
+	void pause() {
+		paused_at = std::chrono::steady_clock::now();
+	}
+
+	void resume() {
+		paused_duration += std::chrono::steady_clock::now() - paused_at;
+		paused_at = {};
+	}
+
+	struct cmp {
+		auto operator()(const std::shared_ptr<timer_data_t>& left, const std::shared_ptr<timer_data_t>& right) const {
+			return left->timeout > right->timeout;
+		}
+	};
+
+	timer_t::callback_t callback;
+	void** holder = nullptr;
+	void* last_holder_value;
+	std::chrono::steady_clock::time_point timeout;
+	std::chrono::steady_clock::time_point paused_at{};
+	std::chrono::steady_clock::duration paused_duration{};
+	std::shared_ptr<timer_data_t> threadless_self;
+	bool is_alive = true;
+	bool is_running = false;
+	bool is_dtor_waiting = false;
+};
+
+namespace {
+
+/**
+ * Stash these here in case statics are destroyed while the module is unloading but timers are still
+ * active
+ */
+struct shared_state_t {
+	std::unordered_set<struct timer_thread_t*> threads;
+	std::condition_variable cv;
+	std::mutex mutex;
+};
+auto global_shared_state = std::make_shared<shared_state_t>();
+
+/**
+ * Manager for a thread which handles 1 or many timers.
+ */
+struct timer_thread_t {
+	explicit timer_thread_t(std::shared_ptr<timer_data_t> first_timer) :
+			next_timeout{first_timer->timeout}, shared_state{global_shared_state} {
+		queue.emplace(std::move(first_timer));
+		std::thread thread{[this] { entry(); }};
+		thread.detach();
+	}
+
+	void entry() {
+		std::unique_lock<std::mutex> lock{shared_state->mutex, std::defer_lock};
+		while (true) {
+			std::this_thread::sleep_until(next_timeout);
+			lock.lock();
+			next_timeout = std::chrono::steady_clock::now();
+			run_next(lock);
+			if (queue.empty()) {
+				auto ii = shared_state->threads.find(this);
+				assert(ii != shared_state->threads.end());
+				shared_state->threads.erase(ii);
+				lock.unlock();
+				delete this;
+				return;
+			}
+			next_timeout = queue.top()->timeout;
+			lock.unlock();
+		}
+	}
+
+	void maybe_run_next(std::unique_lock<std::mutex>& lock) {
+		if (!queue.empty() && queue.top()->timeout <= next_timeout) {
+			run_next(lock);
+		}
+	}
+
+	void run_next(std::unique_lock<std::mutex>& lock) {
+		auto data = queue.top();
+		queue.pop();
+		{
+			if (data->is_alive) {
+				if (data->is_paused()) {
+					data->threadless_self = std::move(data);
+				} else if (data->adjust()) {
+					start_or_join_timer(std::move(data), lock);
+				} else {
+					data->is_running = true;
+					lock.unlock();
+					data->callback(reinterpret_cast<void*>(this));
+					lock.lock();
+					data->is_running = false;
+					if (data->is_dtor_waiting) {
+						shared_state->cv.notify_all();
+					}
+					return;
+				}
+			} else {
+				data.reset();
+			}
+		}
+		maybe_run_next(lock);
+	}
+
+	// Requires lock
+	template <template<class> class Lock>
+	static void start_or_join_timer(std::shared_ptr<timer_data_t> data, const Lock<std::mutex>& /*lock*/) {
+		// Try to find a thread to put this timer into
+		for (const auto& thread : global_shared_state->threads) {
+			if (thread->next_timeout < data->timeout) {
+				thread->queue.push(std::move(data));
+				return;
+			}
+		}
+
+		// Time to spawn a new thread
+		global_shared_state->threads.insert(new timer_thread_t(std::move(data)));
+	}
+
+	std::priority_queue<
+		std::shared_ptr<timer_data_t>,
+		std::deque<std::shared_ptr<timer_data_t>>,
+		timer_data_t::cmp
+	> queue;
+	std::chrono::steady_clock::time_point next_timeout;
+	std::shared_ptr<shared_state_t> shared_state;
+};
+
+} // anonymous namespace
+
+/**
+ * timer_t implementation
+ */
+timer_t::timer_t(uint32_t ms, void** holder, const callback_t& callback) {
+	std::lock_guard<std::mutex> lock{global_shared_state->mutex};
+	data = std::make_shared<timer_data_t>(
+		std::chrono::steady_clock::now() + std::chrono::milliseconds{ms},
+		holder, callback,
+		lock
+	);
+	timer_thread_t::start_or_join_timer(data, lock);
+}
+
+timer_t::~timer_t() {
+	std::unique_lock<std::mutex> lock{global_shared_state->mutex};
+	if (data->is_running) {
+		data->is_dtor_waiting = true;
+		do {
+			global_shared_state->cv.wait(lock);
+		} while (data->is_running);
+	}
+	data->is_alive = false;
+	if (data->holder != nullptr) {
+		*data->holder = data->last_holder_value;
+	}
+}
+
+void timer_t::chain(void* ptr) {
+	auto& thread = *reinterpret_cast<timer_thread_t*>(ptr);
+	std::unique_lock<std::mutex> lock{global_shared_state->mutex};
+	thread.maybe_run_next(lock);
+}
+
+void timer_t::pause(void*& holder) {
+	std::unique_lock<std::mutex> lock{global_shared_state->mutex};
+	if (holder != nullptr) {
+		auto& data = *static_cast<timer_data_t*>(holder);
+		data.pause();
+	}
+}
+
+void timer_t::resume(void*& holder) {
+	std::unique_lock<std::mutex> lock{global_shared_state->mutex};
+	if (holder != nullptr) {
+		auto& data = *static_cast<timer_data_t*>(holder);
+		data.resume();
+		if (data.threadless_self) {
+			timer_thread_t::start_or_join_timer(std::move(data.threadless_self), lock);
+		}
+	}
+}
+
+void timer_t::wait_detached(uint32_t ms, const callback_t& callback) {
+	std::lock_guard<std::mutex> lock{global_shared_state->mutex};
+	timer_thread_t::start_or_join_timer(std::make_shared<timer_data_t>(
+		std::chrono::steady_clock::now() + std::chrono::milliseconds{ms},
+		nullptr, callback, lock
+	), lock);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/lib/timer.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <memory>
+#include <functional>
+
+namespace ivm {
+
+/**
+ * isolated-vm could start timers from different threads which libuv isn't really cut out for, so
+ * I'm rolling my own here. The goal of the library is to have atomic timers without spawning a new
+ * thread for each timer.
+ */
+struct timer_data_t;
+class timer_t {
+	public:
+		using callback_t = std::function<void(void*)>;
+
+		// Runs a callback unless the `timer_t` destructor is called.
+		timer_t(uint32_t ms, void** holder, const callback_t& callback);
+		timer_t(uint32_t ms, const callback_t& callback) : timer_t{ms, nullptr, callback} {}
+		timer_t(const timer_t&) = delete;
+		~timer_t();
+		auto operator= (const timer_t&) = delete;
+
+		// Runs a callback in `ms` with no `timer_t` object.
+		static void wait_detached(uint32_t ms, const callback_t& callback);
+		// Invoked from callbacks when they are done scheduling and may need to wait
+		static void chain(void* ptr);
+		// Pause/unpause timer callbacks
+		static void pause(void*& holder);
+		static void resume(void*& holder);
+
+	private:
+		std::shared_ptr<timer_data_t> data;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/callback.cc

@@ -0,0 +1,151 @@
+#include "callback.h"
+
+#include <utility>
+#include "external_copy/serializer.h"
+#include "isolate/external.h"
+#include "isolate/three_phase_task.h"
+
+using namespace v8;
+
+namespace ivm {
+
+/**
+ * CallbackHandle implementation
+ */
+auto CallbackHandle::Definition() -> Local<FunctionTemplate> {
+	return Inherit<TransferableHandle>(MakeClass(
+		"Callback", ConstructorFunction<decltype(&New), &New>{}
+	));
+}
+
+auto CallbackHandle::New(Local<Function> fn, MaybeLocal<Object> options) -> std::unique_ptr<CallbackHandle> {
+	auto context = Isolate::GetCurrent()->GetCurrentContext();
+
+	// Get function parameter count
+	auto maybe_length = Unmaybe(fn->Get(context, StringTable::Get().length))->Int32Value(context);
+	int length;
+	if (!maybe_length.To(&length)) {
+		length = 0;
+	}
+
+	// Read options
+	auto apply = CallbackHandle::InvokeData::Apply::Sync;
+	if (ReadOption(options, StringTable::Get().async, false)) {
+		apply = CallbackHandle::InvokeData::Apply::Async;
+	} else if (ReadOption(options, StringTable::Get().ignored, false)) {
+		apply = CallbackHandle::InvokeData::Apply::Ignored;
+	}
+
+	// Return handle instance
+	return std::make_unique<CallbackHandle>(CallbackHandle::Data{
+		HandleCast<std::string>(fn->GetDebugName()),
+		length,
+		RemoteHandle<Function>{fn},
+		RemoteHandle<Context>{context},
+		apply});
+}
+
+auto CallbackHandle::TransferOut() -> std::unique_ptr<Transferable> {
+	return std::make_unique<CallbackTransferable>(data);
+}
+
+/**
+ * Runner for invocation of functions created by `Callback`
+ */
+class InvokeRunner : public ThreePhaseTask {
+	public:
+		InvokeRunner(CallbackHandle::Data data, const FunctionCallbackInfo<Value>& info) : data{std::move(data)} {
+			// Transfer arguments out
+			argv = std::make_unique<SerializedVector>(info);
+		}
+
+		void Phase2() final {
+			// Setup context
+			auto* isolate = Isolate::GetCurrent();
+			auto& env = IsolateEnvironment::GetCurrent();
+			auto context = Deref(data.context);
+			Context::Scope context_scope{context};
+			auto fn = Deref(data.callback);
+			// Copy arguments into isolate
+			auto argv_inner = argv->CopyIntoAsVector();
+			// Run function and transfer out
+			auto maybe_value = fn->Call(context, Undefined(isolate), argv_inner.size(), argv_inner.empty() ? nullptr : &argv_inner[0]);
+			if (env.DidHitMemoryLimit()) {
+				throw FatalRuntimeError("Isolate was disposed during execution due to memory limit");
+			} else if (env.terminated) {
+				throw FatalRuntimeError("Isolate was disposed during execution");
+			}
+			auto value = Unmaybe(maybe_value);
+			if (data.apply != CallbackHandle::Data::Apply::Ignored) {
+				result = TransferOut(value, TransferOptions{TransferOptions::Type::Copy});
+			}
+		}
+
+		auto Phase3() -> Local<Value> final {
+			if (result) {
+				return result->TransferIn();
+			} else {
+				return Undefined(Isolate::GetCurrent());
+			}
+		}
+
+	private:
+		CallbackHandle::InvokeData data;
+		std::unique_ptr<SerializedVector> argv;
+		std::unique_ptr<Transferable> result;
+};
+
+/**
+ * CallbackHandleTransferable implementation
+ */
+CallbackTransferable::CallbackTransferable(CallbackHandle::Data& data) : data{data} {}
+
+CallbackTransferable::CallbackTransferable(Local<Function> data) :
+	CallbackTransferable{data, Isolate::GetCurrent()->GetCurrentContext()} {}
+
+CallbackTransferable::CallbackTransferable(Local<Function> fn, Local<Context> context) : data{
+	[&]() {
+		const auto name = fn->GetDebugName();
+		if (name->IsString()) {
+			return std::optional{HandleCast<std::string>(name)};
+		} else {
+			return std::optional<std::string>{};
+		}
+	}(),
+	HandleCast<int>(Unmaybe(fn->Get(context, StringTable::Get().length))),
+	RemoteHandle<Function>{fn},
+	RemoteHandle<Context>{context},
+	CallbackHandle::InvokeData::Apply::Sync
+} {}
+
+auto CallbackTransferable::TransferIn() -> Local<Value> {
+
+	// Instantiate function in isolate
+	auto* isolate = Isolate::GetCurrent();
+	auto context = isolate->GetCurrentContext();
+	auto external = MakeExternal<CallbackHandle::Data>(data);
+	auto fn = Unmaybe(Function::New(context, Invoke, external, data.length, ConstructorBehavior::kThrow));
+	if (data.name) {
+		fn->SetName(HandleCast<Local<String>>(*data.name));
+	}
+	return fn;
+}
+
+void CallbackTransferable::Invoke(const FunctionCallbackInfo<Value>& info) {
+	FunctorRunners::RunCallback(info, [&]() {
+		auto& data = *static_cast<CallbackHandle::Data*>(info.Data().As<External>()->Value());
+		auto& isolate = *data.context.GetIsolateHolder();
+		switch (data.apply) {
+			case CallbackHandle::Data::Apply::Sync:
+				return ThreePhaseTask::Run<0, InvokeRunner>(isolate, data, info);
+			case CallbackHandle::Data::Apply::Async:
+				return ThreePhaseTask::Run<1, InvokeRunner>(isolate, data, info);
+			case CallbackHandle::Data::Apply::Ignored:
+				return ThreePhaseTask::Run<2, InvokeRunner>(isolate, data, info);
+			default:
+				throw std::logic_error{"Unknown callback flag"};
+		}
+	});
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/module/callback.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "transferable.h"
+#include <optional>
+#include <v8.h>
+#include <tuple>
+#include <utility>
+
+namespace ivm {
+
+/**
+ * Holds a reference to a function in an arbitrary isolate
+ */
+class CallbackHandle : public TransferableHandle {
+	public:
+		template <class ...Args>
+		explicit CallbackHandle(Args&&... args) : data{std::forward<Args>(args)...} {}
+
+		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
+		static auto New(v8::Local<v8::Function> fn, v8::MaybeLocal<v8::Object> maybe_options) ->
+			std::unique_ptr<CallbackHandle>;
+		auto TransferOut() -> std::unique_ptr<Transferable> final;
+
+		void Release();
+
+		struct InvokeData {
+			enum class Apply { Async, Ignored, Sync };
+			RemoteHandle<v8::Function> callback;
+			RemoteHandle<v8::Context> context;
+			Apply apply{};
+		};
+
+		struct Data : public InvokeData {
+			Data() = default;
+
+			template <class ...Args>
+			Data(std::optional<std::string> name, int length, Args&&... args) :
+				InvokeData{std::forward<Args>(args)...},
+				name{std::move(name)}, length{length} {}
+
+			std::optional<std::string> name;
+			int length = 0;
+		};
+
+	private:
+		Data data;
+};
+
+/**
+ * Internal transferable handle for callback
+ */
+class CallbackTransferable : public Transferable {
+	public:
+		explicit CallbackTransferable(CallbackHandle::Data& data);
+		explicit CallbackTransferable(v8::Local<v8::Function> data);
+		CallbackTransferable(v8::Local<v8::Function> fn, v8::Local<v8::Context> context);
+
+		auto TransferIn() -> v8::Local<v8::Value> final;
+
+	private:
+		static void Invoke(const v8::FunctionCallbackInfo<v8::Value>& info);
+		CallbackHandle::Data data;
+};
+
+} // namespace ivm