@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/inspector/runtime_agent.h

@@ -0,0 +1,41 @@
+#ifndef SRC_INSPECTOR_RUNTIME_AGENT_H_
+#define SRC_INSPECTOR_RUNTIME_AGENT_H_
+
+#include "node/inspector/protocol/NodeRuntime.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+
+namespace inspector {
+namespace protocol {
+
+class RuntimeAgent : public NodeRuntime::Backend {
+ public:
+  RuntimeAgent();
+
+  void Wire(UberDispatcher* dispatcher);
+
+  DispatchResponse notifyWhenWaitingForDisconnect(bool enabled) override;
+
+  DispatchResponse enable() override;
+
+  DispatchResponse disable() override;
+
+  bool notifyWaitingForDisconnect();
+
+  void setWaitingForDebugger();
+
+  void unsetWaitingForDebugger();
+
+ private:
+  std::shared_ptr<NodeRuntime::Frontend> frontend_;
+  bool notify_when_waiting_for_disconnect_;
+  bool enabled_;
+  bool is_waiting_for_debugger_;
+};
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_RUNTIME_AGENT_H_

package/src/headers/26/inspector/storage_agent.h

@@ -0,0 +1,33 @@
+#ifndef SRC_INSPECTOR_STORAGE_AGENT_H_
+#define SRC_INSPECTOR_STORAGE_AGENT_H_
+
+#include "env.h"
+#include "node/inspector/protocol/Storage.h"
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+class StorageAgent : public protocol::Storage::Backend {
+ public:
+  explicit StorageAgent(Environment* env);
+  ~StorageAgent() override;
+
+  void Wire(protocol::UberDispatcher* dispatcher);
+
+  DispatchResponse getStorageKey(std::optional<protocol::String> frameId,
+                                 protocol::String* storageKey) override;
+
+  StorageAgent(const StorageAgent&) = delete;
+  StorageAgent& operator=(const StorageAgent&) = delete;
+
+ private:
+  std::string to_absolute_path(const std::filesystem::path& input);
+  std::unique_ptr<protocol::Storage::Frontend> frontend_;
+  Environment* env_;
+};
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_STORAGE_AGENT_H_

package/src/headers/26/inspector/target_agent.h

@@ -0,0 +1,59 @@
+#ifndef SRC_INSPECTOR_TARGET_AGENT_H_
+#define SRC_INSPECTOR_TARGET_AGENT_H_
+
+#include <memory>
+#include <string_view>
+#include "inspector/target_manager.h"
+#include "inspector/worker_inspector.h"
+#include "node/inspector/protocol/Target.h"
+
+namespace node {
+
+namespace inspector {
+class TargetInspector;
+
+namespace protocol {
+
+class TargetAgent : public Target::Backend,
+                    public std::enable_shared_from_this<TargetAgent> {
+ public:
+  void Wire(UberDispatcher* dispatcher);
+
+  void createAndAttachIfNecessary(std::shared_ptr<MainThreadHandle> worker,
+                                  const std::string& title,
+                                  const std::string& url);
+
+  DispatchResponse getTargets(
+      std::unique_ptr<protocol::Array<Target::TargetInfo>>* out_targetInfos)
+      override;
+  DispatchResponse setAutoAttach(bool auto_attach,
+                                 bool wait_for_debugger_on_start) override;
+
+  void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
+  void reset();
+
+ private:
+  int getNextTargetId();
+  int getNextSessionId();
+  void targetCreated(const std::string_view target_id,
+                     const std::string_view type,
+                     const std::string_view title,
+                     const std::string_view url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                        const std::string& target_id,
+                        const std::string& type,
+                        const std::string& title,
+                        const std::string& url);
+
+  std::shared_ptr<Target::Frontend> frontend_;
+  std::weak_ptr<WorkerManager> worker_manager_;
+  std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
+  std::unique_ptr<TargetManager> target_manager_ =
+      std::make_unique<TargetManager>();
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TARGET_AGENT_H_

package/src/headers/26/inspector/target_manager.h

@@ -0,0 +1,70 @@
+#ifndef SRC_INSPECTOR_TARGET_MANAGER_H_
+#define SRC_INSPECTOR_TARGET_MANAGER_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "node_mutex.h"
+
+namespace node {
+namespace inspector {
+
+class MainThreadHandle;
+
+class TargetManager {
+ public:
+  struct TargetInfo {
+    std::string target_id;
+    std::string type;
+    std::string title;
+    std::string url;
+    std::shared_ptr<MainThreadHandle> worker;
+    bool attached;
+  };
+
+  TargetManager() = default;
+
+  int NextTargetId();
+  int NextSessionId();
+
+  void SetAutoAttach(bool auto_attach, bool wait_for_debugger_on_start);
+  bool auto_attach() const { return auto_attach_; }
+  bool wait_for_debugger_on_start() const {
+    return wait_for_debugger_on_start_;
+  }
+
+  void AddTarget(std::shared_ptr<MainThreadHandle> worker,
+                 const std::string& target_id,
+                 const std::string& type,
+                 const std::string& title,
+                 const std::string& url,
+                 bool attached);
+  std::vector<TargetInfo> GetTargetsSnapshot() const;
+  std::vector<TargetInfo>& targets() { return targets_; }
+  const std::vector<TargetInfo>& targets() const { return targets_; }
+
+  static void RegisterSessionWorker(int session_id,
+                                    std::shared_ptr<MainThreadHandle> worker);
+  static std::shared_ptr<MainThreadHandle> WorkerForSession(int session_id);
+
+ private:
+  static Mutex session_state_lock_;
+  static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+      session_worker_map_;
+  static int next_session_id_;
+
+  int next_target_id_ = 1;
+  bool auto_attach_ = false;
+  // TODO(islandryu): Honor this flag for worker targets. It is stored here
+  // so Target.setAutoAttach() state can be tracked, but worker startup pause
+  // behavior does not change based on it yet.
+  bool wait_for_debugger_on_start_ = true;
+  std::vector<TargetInfo> targets_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TARGET_MANAGER_H_

package/src/headers/26/inspector/tracing_agent.h

@@ -0,0 +1,43 @@
+#ifndef SRC_INSPECTOR_TRACING_AGENT_H_
+#define SRC_INSPECTOR_TRACING_AGENT_H_
+
+#include "node/inspector/protocol/NodeTracing.h"
+#include "tracing/agent.h"
+#include "v8.h"
+
+
+namespace node {
+class Environment;
+
+namespace inspector {
+class MainThreadHandle;
+
+namespace protocol {
+
+class TracingAgent : public NodeTracing::Backend {
+ public:
+  explicit TracingAgent(Environment*, std::shared_ptr<MainThreadHandle>);
+  ~TracingAgent() override;
+
+  void Wire(UberDispatcher* dispatcher);
+
+  DispatchResponse start(
+      std::unique_ptr<protocol::NodeTracing::TraceConfig> traceConfig) override;
+  DispatchResponse stop() override;
+  DispatchResponse getCategories(
+      std::unique_ptr<protocol::Array<String>>* categories) override;
+
+ private:
+  Environment* env_;
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  tracing::AgentWriterHandle trace_writer_;
+  int frontend_object_id_ = 0;
+  std::shared_ptr<NodeTracing::Frontend> frontend_;
+};
+
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TRACING_AGENT_H_

package/src/headers/26/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/src/headers/26/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/src/headers/26/inspector_agent.h

@@ -0,0 +1,168 @@
+#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 SetAsyncHookTrackingEnabled(bool enabled);
+
+  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 SyncAsyncHookState();
+  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_;
+
+  // The state of the async hook used for async stack traces that the protocol
+  // last requested, and the state JS currently has. SyncAsyncHookState()
+  // reconciles the two when it is possible and safe to call into JS.
+  bool async_hook_wanted_ = false;
+  bool async_hook_enabled_ = false;
+  bool syncing_async_hook_state_ = 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/src/headers/26/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