node/src/inspector_agent.h at main · nodejs/node · GitHub

History

168 lines (133 loc) · 5.83 KB

Raw

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

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

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

node/src/inspector_agent.h at main · nodejs/node · GitHub

Uh oh!

Uh oh!

node/src/inspector_agent.h at main · nodejs/node · GitHub

Uh oh!

Uh oh!

Expand file tree

Breadcrumbs

inspector_agent.h

Latest commit

History

Breadcrumbs

inspector_agent.h

File metadata and controls