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

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

@@ -0,0 +1,381 @@
+#pragma once
+#include <ratio>
+#include <string>
+#include <v8.h>
+#include <uv.h>
+
+#include "executor.h"
+#include "holder.h"
+#include "remote_handle.h"
+#include "runnable.h"
+#include "scheduler.h"
+#include "specific.h"
+#include "strings.h"
+#include "cpu_profile_manager.h"
+#include "lib/covariant.h"
+#include "lib/lockable.h"
+#include "lib/thread_pool.h"
+#include "v8-profiler.h"
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <set>
+#include <unordered_map>
+#include <vector>
+#include <list>
+
+namespace ivm {
+
+/**
+ * Wrapper around Isolate with helpers to make working with multiple isolates easier.
+ */
+class IsolateEnvironment {
+	// These are here so they can adjust `extra_allocated_memory`. TODO: Make this a method
+	friend class ExternalCopyString;
+
+	friend class Executor;
+	friend class InspectorAgent;
+	friend class InspectorSession;
+	friend class IsolateHolder;
+	friend class LimitedAllocator;
+	friend class LockedScheduler;
+	friend StringTable;
+	friend class ThreePhaseTask;
+	template <class>
+	friend class IsolateSpecific;
+	template <typename F>
+	friend auto RunWithTimeout(uint32_t timeout_ms, F&& fn) -> v8::Local<v8::Value>;
+
+	public:
+		/**
+		 * Ensures we don't blow up the v8 heap while transferring arbitrary data
+		 */
+		class HeapCheck {
+			private:
+				IsolateEnvironment& env;
+				size_t extra_size_before;
+				bool force;
+			public:
+				explicit HeapCheck(IsolateEnvironment& env, bool force = false);
+				HeapCheck(const HeapCheck&) = delete;
+				auto operator= (const HeapCheck&) -> HeapCheck& = delete;
+				~HeapCheck() = default;
+				void Epilogue();
+		};
+
+	private:
+
+		struct ReleaseAndJoinHandle {
+			std::shared_ptr<IsolateDisposeWait> dispose_wait;
+			std::weak_ptr<IsolateHolder> holder;
+
+			auto operator<(const ReleaseAndJoinHandle& right) const -> bool {
+				return dispose_wait.owner_before(right.dispose_wait);
+			}
+		};
+
+		// Another good candidate for std::optional<> (because this is only used by the root isolate)
+		using OwnedIsolates = lockable_t<std::set<ReleaseAndJoinHandle>, true>;
+		std::unique_ptr<OwnedIsolates> owned_isolates;
+
+		v8::Isolate* isolate{};
+		covariant_t<LockedScheduler, IsolatedScheduler, UvScheduler> scheduler;
+		Executor executor;
+		std::shared_ptr<IsolateDisposeWait> dispose_wait{std::make_shared<IsolateDisposeWait>()};
+		std::weak_ptr<IsolateHolder> holder;
+		std::shared_ptr<IsolateTaskRunner> task_runner;
+		std::unique_ptr<class InspectorAgent> inspector_agent;
+		v8::Persistent<v8::Context> default_context;
+		std::shared_ptr<v8::ArrayBuffer::Allocator> allocator_ptr;
+		std::shared_ptr<v8::BackingStore> snapshot_blob_ptr;
+		v8::StartupData startup_data{};
+		void* timer_holder = nullptr;
+		size_t memory_limit = 0;
+		size_t initial_heap_size_limit = 0;
+		size_t misc_memory_size = 0;
+		std::atomic<size_t> extra_allocated_memory = 0;
+		v8::MemoryPressureLevel memory_pressure = v8::MemoryPressureLevel::kNone;
+		v8::MemoryPressureLevel last_memory_pressure = v8::MemoryPressureLevel::kNone;
+		bool hit_memory_limit = false;
+		bool did_adjust_heap_limit = false;
+		bool nodejs_isolate = false;
+		std::atomic<unsigned int> remotes_count{0};
+		v8::HeapStatistics last_heap {};
+		// Copyable traits used to opt into destructor handle reset
+		std::deque<v8::Persistent<v8::Promise, v8::CopyablePersistentTraits<v8::Promise>>> unhandled_promise_rejections;
+		StringTable string_table;
+
+		std::vector<v8::Eternal<v8::Data>> specifics;
+		std::unordered_map<v8::Persistent<v8::Value>*, std::pair<void(*)(void*), void*>> weak_persistents;
+		std::shared_ptr<CpuProfileManager> cpu_profile_manager;
+
+	public:
+		RemoteHandle<v8::Function> error_handler;
+		std::unordered_multimap<int, struct ModuleInfo*> module_handles;
+		std::unordered_map<class NativeModule*, std::shared_ptr<NativeModule>> native_modules;
+		int terminate_depth = 0;
+		std::atomic<bool> terminated { false };
+
+	private:
+
+		/**
+		 * If this function is called then I have failed you.
+		 */
+		static void OOMErrorCallback(const char* location, bool is_heap_oom);
+#if V8_AT_LEAST(10, 4, 9)
+		static void OOMErrorCallback(const char* location, const v8::OOMDetails& details) {
+			OOMErrorCallback(location, details.is_heap_oom);
+		}
+#endif
+
+		/**
+		 * Called when an isolate has an uncaught error in a promise. This makes no distinction between
+		 * contexts so we have to handle that ourselves.
+		 */
+		static void PromiseRejectCallback(v8::PromiseRejectMessage rejection);
+	public:
+		void PromiseWasHandled(v8::Local<v8::Promise> promise);
+
+	private:
+		static auto CodeGenCallback(v8::Local<v8::Context> context, v8::Local<v8::Value> source) -> v8::ModifyCodeGenerationFromStringsResult;
+		static auto CodeGenCallback2(v8::Local<v8::Context> context, v8::Local<v8::Value> source, bool) -> v8::ModifyCodeGenerationFromStringsResult;
+
+		/**
+		 * GC hooks to kill this isolate before it runs out of memory
+		 */
+		static void MarkSweepCompactEpilogue(v8::Isolate* isolate, v8::GCType gc_type, v8::GCCallbackFlags gc_flags, void* data);
+		static auto NearHeapLimitCallback(void* data, size_t current_heap_limit, size_t initial_heap_limit) -> size_t;
+		void RequestMemoryPressureNotification(v8::MemoryPressureLevel memory_pressure, bool as_interrupt = false);
+		static void MemoryPressureInterrupt(v8::Isolate* isolate, void* data);
+		void CheckMemoryPressure();
+
+		/**
+		 * Wrap an existing Isolate. This should only be called for the main node Isolate.
+		 */
+		void IsolateCtor(v8::Isolate* isolate, v8::Local<v8::Context> context);
+
+		/**
+		 * Create a new wrapped Isolate.
+		 */
+		void IsolateCtor(size_t memory_limit_in_mb, std::shared_ptr<v8::BackingStore> snapshot_blob, size_t snapshot_length);
+
+	public:
+		/**
+		 * The constructor should be called through the factory.
+		 */
+		IsolateEnvironment();
+		explicit IsolateEnvironment(UvScheduler& default_scheduler);
+		IsolateEnvironment(const IsolateEnvironment&) = delete;
+		auto operator= (const IsolateEnvironment&) -> IsolateEnvironment = delete;
+		~IsolateEnvironment();
+
+		/**
+		 * Factory method which generates an IsolateHolder.
+		 */
+		static auto New(v8::Isolate* isolate, v8::Local<v8::Context> context) -> std::shared_ptr<IsolateHolder> {
+			auto env = std::make_shared<IsolateEnvironment>();
+			auto holder = std::make_shared<IsolateHolder>(env);
+			env->holder = holder;
+			env->IsolateCtor(isolate, context);
+			return holder;
+		}
+
+		static auto New(size_t memory_limit_in_mb, std::shared_ptr<v8::BackingStore> snapshot_blob, size_t snapshot_length) -> std::shared_ptr<IsolateHolder> {
+			auto env = std::make_shared<IsolateEnvironment>(static_cast<UvScheduler&>(*Executor::GetDefaultEnvironment().scheduler));
+			auto holder = std::make_shared<IsolateHolder>(env);
+			env->holder = holder;
+			env->IsolateCtor(memory_limit_in_mb, std::move(snapshot_blob), snapshot_length);
+			return holder;
+		}
+
+		/**
+		 * Return pointer the currently running IsolateEnvironment
+		 */
+		static auto GetCurrent() -> IsolateEnvironment& {
+			auto* environment = Executor::GetCurrentEnvironment();
+			assert(environment != nullptr);
+			return *environment;
+
+		}
+
+		/**
+		 * Return shared_ptr to current IsolateHolder
+		 */
+		static auto GetCurrentHolder() -> std::shared_ptr<IsolateHolder> {
+			return Executor::GetCurrentEnvironment()->holder.lock();
+		}
+
+		auto GetScheduler() -> LockedScheduler& {
+			return *scheduler;
+		}
+
+		auto GetTaskRunner() -> const std::shared_ptr<IsolateTaskRunner>& {
+			return task_runner;
+		}
+
+		/**
+		 * Convenience operators to work with underlying isolate
+		 */
+		operator v8::Isolate*() const { // NOLINT
+			return isolate;
+		}
+
+		auto operator->() const -> v8::Isolate* { // Should probably remove this one..
+			return isolate;
+		}
+
+		auto GetIsolate() const -> v8::Isolate* {
+			return isolate;
+		}
+
+		/**
+		 * Default context, useful for generating certain objects when we aren't in a context.
+		 */
+		auto DefaultContext() const -> v8::Local<v8::Context> {
+			return v8::Local<v8::Context>::New(isolate, default_context);
+		}
+
+		/**
+		 * Creates a new context. Must be used instead of Context::New() because of snapshot deserialization
+		 */
+		auto NewContext() -> v8::Local<v8::Context>;
+
+		/**
+		 * Called by Scheduler when there is work to be done in this isolate.
+		 */
+		void AsyncEntry();
+	private:
+		template <std::queue<std::unique_ptr<Runnable>> Scheduler::*Tasks>
+		void InterruptEntryImplementation();
+	public:
+		void InterruptEntryAsync();
+		void InterruptEntrySync();
+
+		/**
+		 * This is called after user code runs. This throws a fatal error if the memory limit was hit.
+		 * If an asyncronous exception (promise) was lost, this will throw it for real.
+		 */
+		auto TaskEpilogue() -> std::unique_ptr<class ExternalCopy>;
+
+		/**
+		 * Get allocator used by this isolate. Will return nullptr for the default isolate.
+		 */
+		auto GetLimitedAllocator() const -> class LimitedAllocator*;
+
+		/**
+		 * Get the initial v8 heap_size_limit when the isolate was created.
+		 */
+		auto GetInitialHeapSizeLimit() const -> size_t {
+			return initial_heap_size_limit;
+		}
+
+		/**
+		 * Enables the inspector for this isolate.
+		 */
+		void EnableInspectorAgent();
+
+		/**
+		 * Returns the InspectorAgent for this Isolate.
+		 */
+		auto GetInspectorAgent() const -> InspectorAgent*;
+
+		// Return IsolateHolder
+		auto GetHolder() { return holder; }
+
+		auto GetDisposeWaitHandle() {
+			return dispose_wait;
+		}
+
+		/**
+		 * Check memory limit flag
+		 */
+		auto DidHitMemoryLimit() const -> bool {
+			return hit_memory_limit;
+		}
+
+		/**
+		 * Not to be confused with v8's `ExternalAllocatedMemory`. This counts up how much memory this
+		 * isolate is holding onto outside of v8's heap, even if that memory is shared amongst other
+		 * isolates.
+		 */
+		auto GetExtraAllocatedMemory() const -> size_t {
+			return extra_allocated_memory;
+		}
+		void AdjustExtraAllocatedMemory(int size) {
+			extra_allocated_memory += size;
+		}
+
+		/**
+		 * Returns the current number of outstanding RemoteHandles<> to this isolate.
+		 */
+		auto GetRemotesCount() const -> unsigned int {
+			return remotes_count.load();
+		}
+		void AdjustRemotes(int delta) {
+			remotes_count.fetch_add(delta);
+		}
+
+		/**
+		 * Is this the default nodejs isolate?
+		 */
+		auto IsDefault() const -> bool {
+			return nodejs_isolate;
+		}
+
+		/**
+		 * Timer getters
+		 */
+		auto GetCpuTime() -> std::chrono::nanoseconds;
+		auto GetWallTime() -> std::chrono::nanoseconds;
+
+		/**
+	     * CPU Profiler
+		 */
+		auto GetCpuProfileManager() -> CpuProfileManager*;
+
+		/**
+		 * Ask this isolate to finish everything it's doing.
+		 */
+		void Terminate();
+
+		/**
+		 * Since a created Isolate can be disposed of at any time we need to keep track of weak
+		 * persistents to call those destructors on isolate disposal.
+		 */
+		void AddWeakCallback(v8::Persistent<v8::Value>* handle, void(*fn)(void*), void* param);
+		void RemoveWeakCallback(v8::Persistent<v8::Value>* handle);
+};
+
+template <class Type>
+template <class Functor>
+auto IsolateSpecific<Type>::Deref(Functor callback) -> v8::Local<Type> {
+	auto& env = *Executor::GetCurrentEnvironment();
+	if (env.specifics.size() <= key) {
+		assert(key <= detail::IsolateSpecificSize);
+		env.specifics.resize(detail::IsolateSpecificSize);
+	}
+	auto& eternal = env.specifics[key];
+	if (eternal.IsEmpty()) {
+		auto handle = callback();
+		// After `callback` is invoked `eternal` is no longer valid! The callback may reference
+		// new IsolateSpecifics which will end up calling `resize` on the underlying vector.
+		env.specifics[key].Set(env.isolate, handle);
+		return handle;
+	}
+	// This is dangerous but `Local` doesn't let you upcast from `Data` to `Value`
+	return HandleConvert{eternal.Get(env.isolate)}.value;
+}
+
+inline auto StringTable::Get() -> auto& {
+	return Executor::GetCurrentEnvironment()->string_table;
+}
+
+auto RaiseCatastrophicError(RemoteHandle<v8::Function>& handler, const char* message) -> bool;
+
+} // namespace ivm

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

@@ -0,0 +1,198 @@
+#include "executor.h"
+#include "environment.h"
+#include "isolate/util.h"
+#include "lib/timer.h"
+#include "v8-profiler.h"
+#include "v8.h"
+#include <cstddef>
+#include <cstdio>
+
+namespace ivm {
+
+/**
+ * Executor implementation
+ */
+Executor::Executor(IsolateEnvironment& env) :
+	env{env},
+	default_executor{*(current_executor == nullptr ? (current_executor = this) : &current_executor->default_executor)},
+	default_thread{&default_executor == this ? std::this_thread::get_id() : default_executor.default_thread} {}
+
+Executor::~Executor() {
+	if (this == &default_executor) {
+		assert(current_executor == &default_executor);
+		current_executor = nullptr;
+	}
+}
+
+auto Executor::MayRunInlineTasks(IsolateEnvironment& env) -> bool {
+	if (current_executor == &env.executor) {
+		if (env.nodejs_isolate) {
+			// nodejs isolates are active by default in their owned thread even if there is no Scope up.
+			// This can cause problems when the GC runs and invokes weak callbacks because there is no
+			// v8::HandleScope set up.
+			return current_executor->depth > 0;
+		} else {
+			return true;
+		}
+	}
+	return false;
+}
+
+thread_local Executor* Executor::current_executor = nullptr;
+thread_local Executor::CpuTimer* Executor::cpu_timer_thread = nullptr;
+
+/**
+ * CpuTimer implementation
+ */
+Executor::CpuTimer::CpuTimer(Executor& executor) :
+		executor{executor}, last{cpu_timer_thread}, time{Now()}
+#if USE_CLOCK_THREAD_CPUTIME_ID
+		, steady_time{std::chrono::steady_clock::now()}
+#endif
+{
+	cpu_timer_thread = this;
+	std::lock_guard<std::mutex> lock{executor.timer_mutex};
+	assert(executor.cpu_timer == nullptr);
+	executor.cpu_timer = this;
+}
+
+Executor::CpuTimer::~CpuTimer() {
+	cpu_timer_thread = last;
+	std::lock_guard<std::mutex> lock{executor.timer_mutex};
+	executor.cpu_time += Now() - time;
+	assert(executor.cpu_timer == this);
+	executor.cpu_timer = nullptr;
+}
+
+auto Executor::CpuTimer::Delta(const std::lock_guard<std::mutex>& /*lock*/) const -> std::chrono::nanoseconds {
+#if USE_CLOCK_THREAD_CPUTIME_ID
+	return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - steady_time);
+#else
+	return std::chrono::duration_cast<std::chrono::nanoseconds>(Now() - time);
+#endif
+}
+
+void Executor::CpuTimer::Pause() {
+	std::lock_guard<std::mutex> lock{executor.timer_mutex};
+	executor.cpu_time += Now() - time;
+	assert(executor.cpu_timer == this);
+	executor.cpu_timer = nullptr;
+	timer_t::pause(executor.env.timer_holder);
+}
+
+void Executor::CpuTimer::Resume() {
+	std::lock_guard<std::mutex> lock{executor.timer_mutex};
+	time = Now();
+#if USE_CLOCK_THREAD_CPUTIME_ID
+	steady_time = std::chrono::steady_clock::now();
+#endif
+	assert(executor.cpu_timer == nullptr);
+	executor.cpu_timer = this;
+	timer_t::resume(executor.env.timer_holder);
+}
+
+#if USE_CLOCK_THREAD_CPUTIME_ID
+auto Executor::CpuTimer::Now() -> TimePoint {
+	timespec ts{};
+	assert(clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0);
+	return TimePoint{std::chrono::duration_cast<std::chrono::system_clock::duration>(
+		std::chrono::seconds{ts.tv_sec} + std::chrono::nanoseconds{ts.tv_nsec}
+	)};
+}
+#else
+auto Executor::CpuTimer::Now() -> TimePoint {
+	return std::chrono::steady_clock::now();
+}
+#endif
+
+/**
+ * WallTimer implementation
+ */
+Executor::WallTimer::WallTimer(Executor& executor) :
+		executor{executor}, cpu_timer{cpu_timer_thread} {
+	// Pause current CPU timer which may not belong to this isolate
+	if (cpu_timer != nullptr) {
+		cpu_timer->Pause();
+	}
+	// Maybe start wall timer
+	if (executor.wall_timer == nullptr) {
+		std::lock_guard<std::mutex> lock{executor.timer_mutex};
+		executor.wall_timer = this;
+		time = std::chrono::steady_clock::now();
+	}
+}
+
+Executor::WallTimer::~WallTimer() {
+	// Resume old CPU timer
+	if (cpu_timer != nullptr) {
+		cpu_timer->Resume();
+	}
+	// Maybe update wall time
+	if (executor.wall_timer == this) {
+		std::lock_guard<std::mutex> lock{executor.timer_mutex};
+		executor.wall_timer = nullptr;
+		executor.wall_time += std::chrono::steady_clock::now() - time;
+	}
+}
+
+auto Executor::WallTimer::Delta(const std::lock_guard<std::mutex>& /*lock*/) const -> std::chrono::nanoseconds {
+	return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - time);
+}
+
+/**
+ * Scope ctor
+ */
+Executor::Scope::Scope(IsolateEnvironment& env) : last{current_executor} {
+	current_executor = &env.executor;
+	++current_executor->depth;
+}
+
+Executor::Scope::~Scope() {
+	--current_executor->depth;
+	current_executor = last;
+}
+
+Executor::Profiler::Profiler(IsolateEnvironment& env) {
+	environment = &env;
+	executor = &env.executor;
+	isolate = env.isolate;
+	profiler = nullptr;
+
+	if (env.GetCpuProfileManager()->IsProfiling()) {
+		profiler = v8::CpuProfiler::New(isolate, v8::kDebugNaming, v8::kEagerLogging);
+		const v8::Local<v8::String> title = v8::String::NewFromUtf8(isolate, "isolated-vm").ToLocalChecked();
+		profiler->StartProfiling(title, true);
+	}
+}
+
+Executor::Profiler::~Profiler() {
+	if (profiler == nullptr) {
+		return;
+	}
+
+	auto DeleterLambda =[](v8::CpuProfile *profile){
+		profile->Delete();
+	};
+	const v8::Local<v8::String> title = v8::String::NewFromUtf8(isolate, "isolated-vm").ToLocalChecked();
+	const std::shared_ptr<v8::CpuProfile> profile{profiler->StopProfiling(title),DeleterLambda};
+	environment->GetCpuProfileManager()->InjestCpuProfile(profile);
+}
+
+/**
+ * Lock implementation
+ */
+Executor::Lock::Lock(IsolateEnvironment& env) :
+	scope{env},
+	wall_timer{env.executor},
+	locker{env.isolate},
+	cpu_timer{env.executor},
+	isolate_scope{env.isolate},
+	handle_scope{env.isolate},
+	profiler(env) {}
+
+/**
+ * Unlock implementation
+ */
+Executor::Unlock::Unlock(IsolateEnvironment& env) : pause_scope{env.executor.cpu_timer}, unlocker{env.isolate} {}
+
+} // namespace ivm