1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
#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 {
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() {}
};
// 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,
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();
}
private:
static void CloseServerSocket(ServerSocket*);
using ServerSocketPtr = DeleteFnPtr<ServerSocket, CloseServerSocket>;
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, kStopping, kStopped};
uv_loop_t* loop_;
std::unique_ptr<SocketServerDelegate> delegate_;
const std::string host_;
int port_;
std::string path_;
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_
|
