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

package/dist/node/include/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_