@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/inspector/worker_agent.h

@@ -0,0 +1,40 @@
+#ifndef SRC_INSPECTOR_WORKER_AGENT_H_
+#define SRC_INSPECTOR_WORKER_AGENT_H_
+
+#include "node/inspector/protocol/NodeWorker.h"
+#include "v8.h"
+
+
+namespace node {
+namespace inspector {
+class WorkerManagerEventHandle;
+class WorkerManager;
+
+namespace protocol {
+class NodeWorkers;
+
+class WorkerAgent : public NodeWorker::Backend {
+ public:
+  explicit WorkerAgent(std::weak_ptr<WorkerManager> manager);
+  ~WorkerAgent() override = default;
+
+  void Wire(UberDispatcher* dispatcher);
+
+  DispatchResponse sendMessageToWorker(const String& message,
+                                       const String& sessionId) override;
+
+  DispatchResponse enable(bool waitForDebuggerOnStart) override;
+  DispatchResponse disable() override;
+  DispatchResponse detach(const String& sessionId) override;
+
+ private:
+  std::shared_ptr<NodeWorker::Frontend> frontend_;
+  std::weak_ptr<WorkerManager> manager_;
+  std::unique_ptr<WorkerManagerEventHandle> event_handle_;
+  std::shared_ptr<NodeWorkers> workers_;
+};
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_WORKER_AGENT_H_

package/dist/node/include/inspector/worker_inspector.h

@@ -0,0 +1,124 @@
+#ifndef SRC_INSPECTOR_WORKER_INSPECTOR_H_
+#define SRC_INSPECTOR_WORKER_INSPECTOR_H_
+
+#include "inspector/network_resource_manager.h"
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace node {
+namespace inspector {
+class InspectorSession;
+class InspectorSessionDelegate;
+class MainThreadHandle;
+class WorkerManager;
+
+class WorkerDelegate {
+ public:
+  virtual void WorkerCreated(const std::string& title,
+                             const std::string& url,
+                             bool waiting,
+                             std::shared_ptr<MainThreadHandle> worker) = 0;
+  virtual ~WorkerDelegate() = default;
+};
+
+class WorkerManagerEventHandle {
+ public:
+  explicit WorkerManagerEventHandle(std::shared_ptr<WorkerManager> manager,
+                                    int id)
+                                    : manager_(manager), id_(id) {}
+  void SetWaitOnStart(bool wait_on_start);
+  ~WorkerManagerEventHandle();
+
+ private:
+  std::shared_ptr<WorkerManager> manager_;
+  int id_;
+};
+
+struct WorkerInfo {
+  WorkerInfo(const std::string& target_title,
+             const std::string& target_url,
+             std::shared_ptr<MainThreadHandle> worker_thread)
+             : title(target_title),
+               url(target_url),
+               worker_thread(worker_thread) {}
+  std::string title;
+  std::string url;
+  std::shared_ptr<MainThreadHandle> worker_thread;
+};
+
+class ParentInspectorHandle {
+ public:
+  ParentInspectorHandle(
+      uint64_t id,
+      std::string_view url,
+      std::shared_ptr<MainThreadHandle> parent_thread,
+      bool wait_for_connect,
+      std::string_view name,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+  ~ParentInspectorHandle();
+  std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
+      uint64_t thread_id, std::string_view url, std::string_view name) {
+    return std::make_unique<ParentInspectorHandle>(
+        thread_id, url, parent_thread_, wait_, name, network_resource_manager_);
+  }
+  void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
+                     bool waiting);
+  bool WaitForConnect() {
+    return wait_;
+  }
+  const std::string& url() const { return url_; }
+  std::unique_ptr<inspector::InspectorSession> Connect(
+      std::unique_ptr<inspector::InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager() {
+    return network_resource_manager_;
+  }
+
+ private:
+  uint64_t id_;
+  std::string url_;
+  std::shared_ptr<MainThreadHandle> parent_thread_;
+  bool wait_;
+  std::string name_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+
+class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
+ public:
+  explicit WorkerManager(std::shared_ptr<MainThreadHandle> thread)
+                         : thread_(thread) {}
+
+  std::unique_ptr<ParentInspectorHandle> NewParentHandle(
+      uint64_t thread_id,
+      std::string_view url,
+      std::string_view name,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+  void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
+  void WorkerFinished(uint64_t session_id);
+  std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
+      std::unique_ptr<WorkerDelegate> attach_delegate);
+  void SetWaitOnStartForDelegate(int id, bool wait);
+  void RemoveAttachDelegate(int id);
+  std::shared_ptr<MainThreadHandle> MainThread() {
+    return thread_;
+  }
+
+ private:
+  std::shared_ptr<MainThreadHandle> thread_;
+  std::unordered_map<uint64_t, WorkerInfo> children_;
+  std::unordered_map<int, std::unique_ptr<WorkerDelegate>> delegates_;
+  // If any one needs it, workers stop for all
+  std::unordered_set<int> delegates_waiting_on_start_;
+  int next_delegate_id_ = 0;
+};
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_WORKER_INSPECTOR_H_

package/dist/node/include/inspector_agent.h

@@ -0,0 +1,165 @@
+#pragma once
+
+#include "inspector/network_resource_manager.h"
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "node_options.h"
+#include "v8.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace v8_inspector {
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+struct ContextInfo;
+
+namespace inspector {
+class InspectorIo;
+class ParentInspectorHandle;
+class NodeInspectorClient;
+class WorkerManager;
+
+class InspectorSession {
+ public:
+  virtual ~InspectorSession() = default;
+  virtual void Dispatch(const v8_inspector::StringView& message) = 0;
+};
+
+class InspectorSessionDelegate {
+ public:
+  virtual ~InspectorSessionDelegate() = default;
+  virtual void SendMessageToFrontend(const v8_inspector::StringView& message)
+                                     = 0;
+};
+
+class Agent {
+ public:
+  explicit Agent(node::Environment* env);
+  ~Agent();
+
+  // Create client_, may create io_ if option enabled
+  bool Start(const std::string& path,
+             const DebugOptions& options,
+             std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+             bool is_main);
+  // Stop and destroy io_
+  void Stop();
+
+  bool IsListening() { return io_ != nullptr; }
+  // Returns true if the Node inspector is actually in use. It will be true
+  // if either the user explicitly opted into inspector (e.g. with the
+  // --inspect command line flag) or if inspector JS API had been used.
+  bool IsActive();
+
+  // Blocks till frontend connects and sends "runIfWaitingForDebugger"
+  void WaitForConnect();
+  bool WaitForConnectByOptions();
+  void StopIfWaitingForConnect();
+
+  // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
+  void WaitForDisconnect();
+  void ReportUncaughtException(v8::Local<v8::Value> error,
+                               v8::Local<v8::Message> message);
+
+  void EmitProtocolEvent(v8::Local<v8::Context> context,
+                         const v8_inspector::StringView& event,
+                         v8::Local<v8::Object> params);
+
+  void SetupNetworkTracking(v8::Local<v8::Function> enable_function,
+                            v8::Local<v8::Function> disable_function);
+  void EnableNetworkTracking();
+  void DisableNetworkTracking();
+
+  // Async stack traces instrumentation.
+  void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
+                          bool recurring);
+  void AsyncTaskCanceled(void* task);
+  void AsyncTaskStarted(void* task);
+  void AsyncTaskFinished(void* task);
+  void AllAsyncTasksCanceled();
+
+  void RegisterAsyncHook(v8::Isolate* isolate,
+    v8::Local<v8::Function> enable_function,
+    v8::Local<v8::Function> disable_function);
+  void EnableAsyncHook();
+  void DisableAsyncHook();
+
+  void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
+  std::unique_ptr<ParentInspectorHandle> GetParentHandle(uint64_t thread_id,
+                                                         std::string_view url,
+                                                         std::string_view name);
+
+  // Called to create inspector sessions that can be used from the same thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  // Called from the worker to create inspector sessions that is connected
+  // to the main thread.
+  // The inspector responds by using the delegate to send messages back.
+  std::unique_ptr<InspectorSession> ConnectToMainThread(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+
+  void PauseOnNextJavascriptStatement(const std::string& reason);
+
+  std::string GetWsUrl() const;
+
+  // Can only be called from the main thread.
+  bool StartIoThread();
+
+  // Calls StartIoThread() from off the main thread.
+  void RequestIoThreadStart();
+
+  const DebugOptions& options() { return debug_options_; }
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port() { return host_port_; }
+  void ContextCreated(v8::Local<v8::Context> context, const ContextInfo& info);
+
+  // Interface for interacting with inspectors in worker threads
+  std::shared_ptr<WorkerManager> GetWorkerManager();
+
+  inline Environment* env() const { return parent_env_; }
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager();
+
+ private:
+  void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+  void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+
+  node::Environment* parent_env_;
+  // Encapsulates majority of the Inspector functionality
+  std::shared_ptr<NodeInspectorClient> client_;
+  // Interface for transports, e.g. WebSocket server
+  std::unique_ptr<InspectorIo> io_;
+  std::unique_ptr<ParentInspectorHandle> parent_handle_;
+  std::string path_;
+
+  // This is a copy of the debug options parsed from CLI in the Environment.
+  // Do not use the host_port in that, instead manipulate the shared host_port_
+  // pointer which is meant to store the actual host and port of the inspector
+  // server.
+  DebugOptions debug_options_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+
+  bool pending_enable_async_hook_ = false;
+  bool pending_disable_async_hook_ = false;
+
+  bool network_tracking_enabled_ = false;
+  bool pending_enable_network_tracking = false;
+  bool pending_disable_network_tracking = false;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/dist/node/include/inspector_io.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_socket_server.h"
+#include "node_mutex.h"
+
+#include "uv.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+namespace inspector {
+
+class MainThreadHandle;
+class RequestQueue;
+
+class InspectorIo {
+ public:
+  // Start the inspector agent thread, waiting for it to initialize
+  // bool Start();
+  // Returns empty pointer if thread was not started
+  static std::unique_ptr<InspectorIo> Start(
+      std::shared_ptr<MainThreadHandle> main_thread,
+      const std::string& path,
+      std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+      const InspectPublishUid& inspect_publish_uid);
+
+  // Will block till the transport thread shuts down
+  ~InspectorIo();
+
+  void StopAcceptingNewConnections();
+  std::string GetWsUrl() const;
+
+ private:
+  InspectorIo(std::shared_ptr<MainThreadHandle> handle,
+              const std::string& path,
+              std::shared_ptr<ExclusiveAccess<HostPort>> host_port,
+              const InspectPublishUid& inspect_publish_uid);
+
+  // Wrapper for agent->ThreadMain()
+  static void ThreadMain(void* agent);
+
+  // Runs a uv_loop_t
+  void ThreadMain();
+
+  // This is a thread-safe object that will post async tasks. It lives as long
+  // as an Inspector object lives (almost as long as an Isolate).
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  // Used to post on a frontend interface thread, lives while the server is
+  // running
+  std::shared_ptr<RequestQueue> request_queue_;
+  std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;
+  InspectPublishUid inspect_publish_uid_;
+
+  // The IO thread runs its own uv_loop to implement the TCP server off
+  // the main thread.
+  uv_thread_t thread_;
+
+  // For setting up interthread communications
+  Mutex thread_start_lock_;
+  ConditionVariable thread_start_condition_;
+  std::string script_name_;
+  // May be accessed from any thread
+  const std::string id_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/dist/node/include/inspector_profiler.h

@@ -0,0 +1,149 @@
+#ifndef SRC_INSPECTOR_PROFILER_H_
+#define SRC_INSPECTOR_PROFILER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include <optional>
+#include <unordered_set>
+#include "inspector_agent.h"
+#include "simdjson.h"
+
+namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
+
+namespace profiler {
+
+class V8ProfilerConnection {
+ public:
+  class V8ProfilerSessionDelegate : public inspector::InspectorSessionDelegate {
+   public:
+    explicit V8ProfilerSessionDelegate(V8ProfilerConnection* connection)
+        : connection_(connection) {}
+
+    void SendMessageToFrontend(
+        const v8_inspector::StringView& message) override;
+
+   private:
+    V8ProfilerConnection* connection_;
+  };
+
+  explicit V8ProfilerConnection(Environment* env);
+  virtual ~V8ProfilerConnection() = default;
+
+  Environment* env() const { return env_; }
+
+  // Dispatch a protocol message, and returns the id of the message.
+  // `method` does not need to be surrounded by quotes.
+  // The optional `params` should be formatted in JSON.
+  // The strings should be in one byte characters - which is enough for
+  // the commands we use here.
+  uint64_t DispatchMessage(const char* method,
+                           const char* params = nullptr,
+                           bool is_profile_request = false);
+
+  // Use DispatchMessage() to dispatch necessary inspector messages
+  // to start and end the profiling.
+  virtual void Start() = 0;
+  virtual void End() = 0;
+
+  // Return a descriptive name of the profile for debugging.
+  virtual const char* type() const = 0;
+  // Return if the profile is ending and the response can be parsed.
+  virtual bool ending() const = 0;
+  // Return the directory where the profile should be placed.
+  virtual std::string GetDirectory() const = 0;
+  // Return the filename the profile should be written as.
+  virtual std::string GetFilename() const = 0;
+  // Return the profile object parsed from `message.result`,
+  // which will be then written as a JSON.
+  virtual std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result);
+  virtual void WriteProfile(simdjson::ondemand::object* result);
+
+  bool HasProfileId(uint64_t id) const { return profile_ids_.contains(id); }
+
+  void RemoveProfileId(uint64_t id) { profile_ids_.erase(id); }
+
+ private:
+  uint64_t next_id() { return id_++; }
+  std::unique_ptr<inspector::InspectorSession> session_;
+  uint64_t id_ = 1;
+  std::unordered_set<uint64_t> profile_ids_;
+
+ protected:
+  simdjson::ondemand::parser json_parser_;
+  Environment* env_ = nullptr;
+};
+
+class V8CoverageConnection : public V8ProfilerConnection {
+ public:
+  explicit V8CoverageConnection(Environment* env) : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "coverage"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+  std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result) override;
+  void WriteProfile(simdjson::ondemand::object* result) override;
+  void WriteSourceMapCache();
+  void TakeCoverage();
+  void StopCoverage();
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+class V8CpuProfilerConnection : public V8ProfilerConnection {
+ public:
+  explicit V8CpuProfilerConnection(Environment* env)
+      : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "CPU"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+class V8HeapProfilerConnection : public V8ProfilerConnection {
+ public:
+  explicit V8HeapProfilerConnection(Environment* env)
+      : V8ProfilerConnection(env) {}
+
+  void Start() override;
+  void End() override;
+
+  const char* type() const override { return "heap"; }
+  bool ending() const override { return ending_; }
+
+  std::string GetDirectory() const override;
+  std::string GetFilename() const override;
+
+ private:
+  std::unique_ptr<inspector::InspectorSession> session_;
+  bool ending_ = false;
+};
+
+}  // namespace profiler
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_INSPECTOR_PROFILER_H_

package/dist/node/include/inspector_socket.h

@@ -0,0 +1,60 @@
+#ifndef SRC_INSPECTOR_SOCKET_H_
+#define SRC_INSPECTOR_SOCKET_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <string>
+#include <vector>
+
+namespace node {
+namespace inspector {
+
+class ProtocolHandler;
+
+// HTTP Wrapper around a uv_tcp_t
+class InspectorSocket {
+ public:
+  class Delegate {
+   public:
+    virtual void OnHttpGet(const std::string& host,
+                           const std::string& path) = 0;
+    virtual void OnSocketUpgrade(const std::string& host,
+                                 const std::string& path,
+                                 const std::string& accept_key) = 0;
+    virtual void OnWsFrame(const std::vector<char>& frame) = 0;
+    virtual ~Delegate() = default;
+  };
+
+  using DelegatePointer = std::unique_ptr<Delegate>;
+  using Pointer = std::unique_ptr<InspectorSocket>;
+
+  static Pointer Accept(uv_stream_t* server, DelegatePointer delegate);
+
+  ~InspectorSocket();
+
+  void AcceptUpgrade(const std::string& accept_key);
+  void CancelHandshake();
+  void Write(const char* data, size_t len);
+  void SwitchProtocol(ProtocolHandler* handler);
+  std::string GetHost();
+
+  InspectorSocket(const InspectorSocket&) = delete;
+  InspectorSocket& operator=(const InspectorSocket&) = delete;
+
+ private:
+  static void Shutdown(ProtocolHandler*);
+  InspectorSocket() = default;
+
+  DeleteFnPtr<ProtocolHandler, Shutdown> protocol_handler_;
+};
+
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_INSPECTOR_SOCKET_H_