@encharm/cws 4.3.0 → 4.4.1

package/src/headers/20/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 <unordered_set>
+#include "inspector_agent.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.
+  uint32_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 v8::MaybeLocal<v8::Object> GetProfile(
+      v8::Local<v8::Object> result) = 0;
+  virtual void WriteProfile(v8::Local<v8::Object> result);
+
+  bool HasProfileId(uint32_t id) const {
+    return profile_ids_.find(id) != profile_ids_.end();
+  }
+
+  void RemoveProfileId(uint32_t id) { profile_ids_.erase(id); }
+
+ private:
+  uint32_t next_id() { return id_++; }
+  std::unique_ptr<inspector::InspectorSession> session_;
+  uint32_t id_ = 1;
+  std::unordered_set<uint32_t> profile_ids_;
+
+ protected:
+  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;
+  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) override;
+  void WriteProfile(v8::Local<v8::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;
+  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) 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;
+  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) 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/src/headers/20/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_

package/src/headers/20/inspector_socket_server.h

@@ -0,0 +1,110 @@
+#ifndef SRC_INSPECTOR_SOCKET_SERVER_H_
+#define SRC_INSPECTOR_SOCKET_SERVER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "inspector_agent.h"
+#include "inspector_socket.h"
+#include "uv.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+namespace node {
+namespace inspector {
+
+std::string FormatWsAddress(const std::string& host, int port,
+                            const std::string& target_id,
+                            bool include_protocol);
+
+class InspectorSocketServer;
+class SocketSession;
+class ServerSocket;
+
+class SocketServerDelegate {
+ public:
+  virtual void AssignServer(InspectorSocketServer* server) = 0;
+  virtual void StartSession(int session_id, const std::string& target_id) = 0;
+  virtual void EndSession(int session_id) = 0;
+  virtual void MessageReceived(int session_id, const std::string& message) = 0;
+  virtual std::vector<std::string> GetTargetIds() = 0;
+  virtual std::string GetTargetTitle(const std::string& id) = 0;
+  virtual std::string GetTargetUrl(const std::string& id) = 0;
+  virtual ~SocketServerDelegate() = default;
+};
+
+// HTTP Server, writes messages requested as TransportActions, and responds
+// to HTTP requests and WS upgrades.
+
+class InspectorSocketServer {
+ public:
+  InspectorSocketServer(std::unique_ptr<SocketServerDelegate> delegate,
+                        uv_loop_t* loop,
+                        const std::string& host,
+                        int port,
+                        const InspectPublishUid& inspect_publish_uid,
+                        FILE* out = stderr);
+  ~InspectorSocketServer();
+
+  // Start listening on host/port
+  bool Start();
+
+  // Called by the TransportAction sent with InspectorIo::Write():
+  //   kKill and kStop
+  void Stop();
+  //   kSendMessage
+  void Send(int session_id, const std::string& message);
+  //   kKill
+  void TerminateConnections();
+  int Port() const;
+
+  // Session connection lifecycle
+  void Accept(int server_port, uv_stream_t* server_socket);
+  bool HandleGetRequest(int session_id, const std::string& host,
+                        const std::string& path);
+  void SessionStarted(int session_id, const std::string& target_id,
+                      const std::string& ws_id);
+  void SessionTerminated(int session_id);
+  void MessageReceived(int session_id, const std::string& message) {
+    delegate_->MessageReceived(session_id, message);
+  }
+  SocketSession* Session(int session_id);
+  bool done() const {
+    return server_sockets_.empty() && connected_sessions_.empty();
+  }
+
+  static void CloseServerSocket(ServerSocket*);
+  using ServerSocketPtr = DeleteFnPtr<ServerSocket, CloseServerSocket>;
+
+ private:
+  void SendListResponse(InspectorSocket* socket, const std::string& host,
+                        SocketSession* session);
+  std::string GetFrontendURL(bool is_compat,
+                             const std::string &formatted_address);
+  bool TargetExists(const std::string& id);
+
+  enum class ServerState {kNew, kRunning, kStopped};
+  uv_loop_t* loop_;
+  std::unique_ptr<SocketServerDelegate> delegate_;
+  const std::string host_;
+  int port_;
+  InspectPublishUid inspect_publish_uid_;
+  std::vector<ServerSocketPtr> server_sockets_;
+  std::map<int, std::pair<std::string, std::unique_ptr<SocketSession>>>
+      connected_sessions_;
+  int next_session_id_;
+  FILE* out_;
+  ServerState state_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_INSPECTOR_SOCKET_SERVER_H_