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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
#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 "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<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();
// Option is set to wait for session connection
bool WillWaitForConnect();
// Blocks till frontend connects and sends "runIfWaitingForDebugger"
void WaitForConnect();
// Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
void WaitForDisconnect();
void ReportUncaughtException(v8::Local<v8::Value> error,
v8::Local<v8::Message> message);
// 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(
int thread_id, const std::string& url);
// 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<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();
private:
void ToggleAsyncHook(v8::Isolate* isolate,
const v8::Global<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<HostPort> host_port_;
bool pending_enable_async_hook_ = false;
bool pending_disable_async_hook_ = false;
v8::Global<v8::Function> enable_async_hook_function_;
v8::Global<v8::Function> disable_async_hook_function_;
};
} // namespace inspector
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
