日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

前言：Node.js提供的Inspector不僅可以用來調(diào)試Node.js代碼，還可以實時收集Node.js進程的內(nèi)存，CPU等數(shù)據(jù)，同時支持靜態(tài)、動態(tài)開啟，是一個非常強大的工具，本文從使用和原理詳細講解Inspector。

我們提供的服務有：成都網(wǎng)站設計、成都做網(wǎng)站、微信公眾號開發(fā)、網(wǎng)站優(yōu)化、網(wǎng)站認證、羅平ssl等。為千余家企事業(yè)單位解決了網(wǎng)站和推廣的問題。提供周到的售前咨詢和貼心的售后服務，是有科學管理、有技術的羅平網(wǎng)站制作公司

Node.js的文檔中對inspector的描述很少，但是如果深入探索，其實里面的內(nèi)容還是挺多的。我們先看一下Inspector的使用。

1 Inspector的使用

1.1 本地調(diào)試

我們先從一個例子開始。下面是一個http服務器。

 
 
 
 

  
  
  
  
const http = require('http'); 
  
  
  
  
http.createServer((req, res) => { 
  
  
  
  
    res.end('ok'); 
  
  
  
  
 
  
  
  
  
}).listen(80); 
 
 
 
 

然后我們以node --inspect httpServer.js的方式啟動。我們可以看到以下輸出。

 
 
 
 

  
  
  
  
Debugger listening on ws://127.0.0.1:9229/fbbd9d8f-e088-48cc-b1e0-e16bfe58db44 
  
  
  
  
For help, see: https://nodejs.org/en/docs/inspector 
 
 
 
 

9229端口是Node.js默認選擇的端口，當然我們也可以自定義，具體可參考文檔。這時候我們?nèi)g覽器打開開發(fā)者工具，菜單欄多了一個調(diào)試Node.js的按鈕。

點擊這個按鈕。我們可以看到以下界面。

我們可以選擇某一行代碼打斷點，比如我在第三行，這時候我們訪問80端口，開發(fā)者工具就會停留在斷點處。這時候我們可以看到一些執(zhí)行上下文。

1.2 遠程調(diào)試

但很多時候我們可能需要遠程調(diào)試。比如我在一臺云服務器上部署以上服務器代碼。然后執(zhí)行

 
 
 
 

  
  
  
  
node --inspect=0.0.0.0:8888 httpServer.js 
 
 
 
 

不過這時候我們打開開發(fā)者工具就會發(fā)現(xiàn)按鈕置灰或者找不到我們遠程服務器的信息。這時候我們需要用另一種方式。通過在瀏覽器url輸入框輸入devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws={host}:{port}/{path}的方式(替換{}里面的內(nèi)容為你執(zhí)行Node.js時輸出的信息)，瀏覽器就會去連接你輸入的地址，比如1.1.1.1:9229/abc。這種比較適合于對于通用的場景。

1.3 自動探測

如果是我們自己調(diào)試的話，這種方式看起來就有點麻煩，我們可以使用瀏覽器提供的自動探測功能。1 url輸入框輸入chrome://inspect/#devices我們會看到以下界面

2 點擊configure按鈕，在彈出的彈框里輸入你遠程服務器的地址

3 配置完畢后，我們會看到界面變成這樣了，或者打開新的tab，我們看到開發(fā)者工具的調(diào)試按鈕也變亮了。

4 這時候我們點擊inspect按鈕、Open dedicated DevTools for Node按鈕或者打開新tab的開發(fā)者工具，就可以開始調(diào)試。而且還可以調(diào)試Node.js的原生js模塊。

2 Inspector調(diào)試的原理

下面以通過url的方式調(diào)試(可以看到network)，來看看調(diào)試的時候都發(fā)生了什么，瀏覽器和遠程服務器建立連接后，是通過websocket協(xié)議通信的。

我們看一下這命令是什么意思，首先看Debugger.scriptParsed。

• Debugger.scriptParsed # Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

從說明中我們看到，當V8解析腳本的時候就會觸發(fā)這個事件，那就會告訴瀏覽器這個信息。

我們發(fā)現(xiàn)返回的都是一些元數(shù)據(jù)，沒有腳本的具體代碼內(nèi)容，這時候瀏覽器會再次發(fā)起請求，

我們看到這個腳本的scriptId是103。所以請求里帶了這個scriptId。對應的請求id是11。接著看一下響應。

至此，我們了解了獲取腳本內(nèi)容的過程，然后我們看看調(diào)試的時候是怎樣的過程。當我們在瀏覽器上點擊某一行設置斷點的時候，瀏覽器就會發(fā)送一個請求。

這個命令的意義顧名思義，我們看一下具體定義。

• Debugger.setBreakpointByUrl # Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in locations property. Further matching script parsing will result in subsequent breakpointResolved events issued. This logical breakpoint will survive page reloads.

接著服務返回響應。

這時候我們從另外一個tab訪問80端口。服務器就會在我們設置的斷點處停留，并且通知瀏覽器。

我們看一下這個命令的意思。

這個命令就是當服務器執(zhí)行到斷點時通知瀏覽器，并且返回執(zhí)行的一些上下文，比如是哪個執(zhí)行到哪個斷點停留了。這時候瀏覽器側也會停留在對應的地方，當我們hover某個變量時，就會看到對應的上下文。這些都是通過具體的命令獲取的數(shù)據(jù)。就不一一分析了，可以參考具體文檔。

3 Inspector的實現(xiàn)

大致了解了瀏覽器和服務器的交互過程和協(xié)議后，我們再來深入了解一下關于inspector的一些實現(xiàn)。當然這里不是分析V8中Inspector的實現(xiàn)，而是分析如何使用V8的Inspector以及Node.js中關于Inspector的實現(xiàn)部分。

3.1 開源實現(xiàn)

因為Node.js的實現(xiàn)比較復雜，這里先以一個簡單版的調(diào)試工具源碼來分析inspector的原理。我們先看一下初始化代碼。

 
 
 
 

  
  
  
  
inspector = std::unique_ptr(new Inspector(v8Platform, context, port)); 
  
  
  
  
inspector->startAgent(); 
 
 
 
 

首先新建一個Inspector。然后啟動它。接下來看看Inspector里的邏輯。

 
 
 
 

  
  
  
  
Inspector::Inspector( 
  
  
  
  
        const std::unique_ptr &platform, 
  
  
  
  
        const v8::Local &context, 
  
  
  
  
        const int webSocketPort) { 
  
  
  
  
 
  
  
  
  
    context_ = context; 
  
  
  
  
    // 新建一個websocket server用于和客戶端通信 
  
  
  
  
    websocket_server_ = std::unique_ptr( 
  
  
  
  
            new WebSocketServer( 
  
  
  
  
                    webSocketPort, 
  
  
  
  
                    // 收到客戶的的消息后執(zhí)行onMessage回調(diào) 
  
  
  
  
                    std::bind(&Inspector::onMessage, this, std::placeholders::_1) 
  
  
  
  
                ) 
  
  
  
  
            ); 
  
  
  
  
    // 新建一個inspector client和V8通信 
  
  
  
  
    inspector_client_ = std::unique_ptr( 
  
  
  
  
            new V8InspectorClientImpl( 
  
  
  
  
                    platform, 
  
  
  
  
                    context_, 
  
  
  
  
                    // 收到V8的消息后調(diào)用sendMessage回復給客戶的 
  
  
  
  
                    std::bind(&Inspector::sendMessage, this, std::placeholders::_1), 
  
  
  
  
                    std::bind(&Inspector::waitForFrontendMessage, this) 
  
  
  
  
                ) 
  
  
  
  
            ); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

代碼看起來很復雜，不過我們不需要深究。主要是兩個部分，一個是新建一個websocket服務器，一個是新建一個inspector客戶端(用于和V8 Inspector通信)，整體架構如下。

接下來分別看一下websocket服務器和inspector客戶端的實現(xiàn)。首先看一下websocket服務器的構造函數(shù)。

 
 
 
 

  
  
  
  
WebSocketServer::WebSocketServer(int port, std::function onMessage){ 
  
  
  
  
    port_ = port; 
  
  
  
  
    onMessage_ = std::move(onMessage); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

WebSocketServer構造函數(shù)的實現(xiàn)很簡單，只是初始化一些字段。接著看inspector客戶端的實現(xiàn)。

 
 
 
 

  
  
  
  
V8InspectorClientImpl:: V8InspectorClientImpl(const std::unique_ptr &platform, const v8::Local &context, const std::function &onResponse, const std::function &onWaitFrontendMessageOnPause) { 
  
  
  
  
 
  
  
  
  
    platform_ = platform.get(); 
  
  
  
  
    context_ = context; 
  
  
  
  
    onWaitFrontendMessageOnPause_ = onWaitFrontendMessageOnPause; 
  
  
  
  
    isolate_ = context_->GetIsolate(); 
  
  
  
  
    // 創(chuàng)建一個channel和inspector通信，收到V8消息時會執(zhí)行onResponse 
  
  
  
  
    channel_.reset(new V8InspectorChannelImp(isolate_, onResponse)); 
  
  
  
  
    // 新建一個V8提供的inspector 
  
  
  
  
    inspector_ = v8_inspector::V8Inspector::create(isolate_, this); 
  
  
  
  
    // 創(chuàng)建一個和inspector通信的session。 
  
  
  
  
    session_ = inspector_->connect(kContextGroupId, channel_.get(), v8_inspector::StringView()); 
  
  
  
  
    context_->SetAlignedPointerInEmbedderData(1, this); 
  
  
  
  
    v8_inspector::StringView contextName = convertToStringView("inspector"); 
  
  
  
  
    inspector_->contextCreated(v8_inspector::V8ContextInfo(context, kContextGroupId, contextName)); 
  
  
  
  
    terminated_ = true; 
  
  
  
  
    run_nested_loop_ = false; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

上面代碼很多，主要是根據(jù)V8提供的API來就行。這里主要有三個概念

1 V8Inspector是V8提供的類。

2 session表示和V8 inspector通信的會話。

3 channel用于和V8 inspector通信，從API來看，channel只能從V8獲取數(shù)據(jù)，寫入數(shù)據(jù)是另外的API。

這時候的架構如下

至此，websocket服務器和inspector客戶端就分析完畢了，回到最開始的代碼，初始化完畢后會執(zhí)行startAgent。

 
 
 
 

  
  
  
  
void Inspector::startAgent() { 
  
  
  
  
    websocket_server_->run(); 
  
  
  
  
 
  
  
  
  
} 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
// 啟動websocket服務器 
  
  
  
  
 
  
  
  
  
void WebSocketServer::run() { 
  
  
  
  
 
  
  
  
  
    auto const address = net::ip::make_address("127.0.0.1"); 
  
  
  
  
    net::io_context ioc{1}; 
  
  
  
  
    tcp::acceptor acceptor{ioc, {address, static_cast(port_)}}; 
  
  
  
  
    tcp::socket socket{ioc}; 
  
  
  
  
    acceptor.accept(socket); 
  
  
  
  
    ws_ = std::unique_ptr>(new websocket::stream(std::move(socket))); 
  
  
  
  
    startListening(); 
  
  
  
  
 
  
  
  
  
} 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
// 等待連接 
  
  
  
  
 
  
  
  
  
void WebSocketServer::startListening(){ 
  
  
  
  
 
  
  
  
  
   ws_->accept(); 
  
  
  
  
   while (true) { 
  
  
  
  
       waitFrontendMessage(); 
  
  
  
  
   }}// 讀取連接中的消息void WebSocketServer::waitFrontendMessage(){ 
  
  
  
  
    beast::flat_buffer buffer; 
  
  
  
  
    ws_->read(buffer); 
  
  
  
  
    std::string message = boost::beast::buffers_to_string(buffer.data()); 
  
  
  
  
    onMessage_(std::move(message)); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

startAgent的邏輯就是啟動websocket服務器。啟動完畢后就等待客戶的連接。連接成功后執(zhí)行onMessage_。我們看一下onMessage的實現(xiàn)。

 
 
 
 

  
  
  
  
void Inspector::onMessage(const std::string& message) { 
  
  
  
  
    std::cout << "CDT message: " << message << std::endl; 
  
  
  
  
    // StringView是V8要求的格式 
  
  
  
  
    v8_inspector::StringView protocolMessage = convertToStringView(message); 
  
  
  
  
    // 通知V8 Inspector 
  
  
  
  
    inspector_client_->dispatchProtocolMessage(protocolMessage); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

onMessage通過Inspector客戶端把消息交給V8 Inspector處理。V8 Inspector處理完后，通過channel通知Inspector客戶端，對應的函數(shù)是sendResponse。V8InspectorChannelImp是繼承V8提供的Channel，sendResponse是一個純虛函數(shù)，由V8InspectorChannelImp實現(xiàn)。

 
 
 
 

  
  
  
  
void V8InspectorChannelImp::sendResponse(int callId, std::unique_ptr message) { 
  
  
  
  
    const std::string response = convertToString(isolate_, message->string()); 
  
  
  
  
    onResponse_(response); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

onResponse_是在Chnnel初始化時設置的，對應函數(shù)是inspector客戶端的sendMessage。

 
 
 
 

  
  
  
  
void Inspector::sendMessage(const std::string& message) { 
  
  
  
  
    websocket_server_->sendMessage(message); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

sendMessage通過websocket服務器把V8 Inspector返回的消息返回給客戶的。至此，整個通信流程就完成了。

3.2 Node.js的實現(xiàn)(v14)

Node.js的實現(xiàn)非常復雜并且很繞，本文根據(jù)也無法通俗易懂地介紹和分析，只能按照我自己的思路大致講解一下流程，有興趣的同學可以自行閱讀圓源碼。

3.2.1 初始化

在Node.js初始化的時候，會創(chuàng)建一個inspector::Agent并啟動。

 
 
 
 

  
  
  
  
inspector_agent_ = std::make_unique(this); 
  
  
  
  
env->InitializeInspector({}); 
 
 
 
 

接著看InitializeInspector。

 
 
 
 

  
  
  
  
inspector_agent_->Start(inspector_path, 
  
  
  
  
                        options_->debug_options(), 
  
  
  
  
                        inspector_host_port(), 
  
  
  
  
                        is_main_thread()); 
 
 
 
 

Start中會執(zhí)行StartIoThread進行進一步操作。

 
 
 
 

  
  
  
  
bool Agent::StartIoThread() { 
  
  
  
  
  io_ = InspectorIo::Start(client_->getThreadHandle(), 
  
  
  
  
                           path_, 
  
  
  
  
                           host_port_, 
  
  
  
  
                           debug_options_.inspect_publish_uid); 
  
  
  
  
  return true; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

繼續(xù)看InspectorIo::Start

 
 
 
 

  
  
  
  
std::unique_ptr InspectorIo::Start( 
  
  
  
  
    std::shared_ptr main_thread, 
  
  
  
  
    const std::string& path, 
  
  
  
  
    std::shared_ptr host_port, 
  
  
  
  
    const InspectPublishUid& inspect_publish_uid) { 
  
  
  
  
 
  
  
  
  
  auto io = std::unique_ptr( 
  
  
  
  
      new InspectorIo(main_thread, 
  
  
  
  
                      path, 
  
  
  
  
                      host_port, 
  
  
  
  
                      inspect_publish_uid)); 
  
  
  
  
  return io; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

InspectorIo::Start其實是創(chuàng)建了一個InspectorIo對象，我們看一下構造函數(shù)里的邏輯。

 
 
 
 

  
  
  
  
InspectorIo::InspectorIo(std::shared_ptr main_thread, 
  
  
  
  
                         const std::string& path, 
  
  
  
  
                         std::shared_ptr host_port, 
  
  
  
  
                         const InspectPublishUid& inspect_publish_uid) 
  
  
  
  
    : main_thread_(main_thread), 
  
  
  
  
      host_port_(host_port), 
  
  
  
  
      inspect_publish_uid_(inspect_publish_uid), 
  
  
  
  
      thread_(), 
  
  
  
  
      script_name_(path), 
  
  
  
  
      id_(GenerateID()) { 
  
  
  
  
  Mutex::ScopedLock scoped_lock(thread_start_lock_); 
  
  
  
  
  CHECK_EQ(uv_thread_create(&thread_, InspectorIo::ThreadMain, this), 0); 
  
  
  
  
  thread_start_condition_.Wait(scoped_lock); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

構造函數(shù)里創(chuàng)建了一個線程并在線程中執(zhí)行InspectorIo::ThreadMain。我們接著看ThreadMain。

 
 
 
 

  
  
  
  
void InspectorIo::ThreadMain(void* io) { 
  
  
  
  
  static_cast(io)->ThreadMain(); 
  
  
  
  
 
  
  
  
  
} 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
void InspectorIo::ThreadMain() { 
  
  
  
  
 
  
  
  
  
  uv_loop_t loop; 
  
  
  
  
  loop.data = nullptr; 
  
  
  
  
  int err = uv_loop_init(&loop); 
  
  
  
  
  CHECK_EQ(err, 0); 
  
  
  
  
  std::shared_ptr queue(new RequestQueueData(&loop), 
  
  
  
  
                                          RequestQueueData::CloseAndFree); 
  
  
  
  
  std::string script_path = ScriptPath(&loop, script_name_); 
  
  
  
  
  // 創(chuàng)建一個處理請求的delegate對象 
  
  
  
  
  std::unique_ptr delegate( 
  
  
  
  
      new InspectorIoDelegate(queue, main_thread_, id_, 
  
  
  
  
                              script_path, script_name_)); 
  
  
  
  
  // 創(chuàng)建一個服務器                             
  
  
  
  
  InspectorSocketServer server(std::move(delegate), 
  
  
  
  
                               &loop, 
  
  
  
  
                               host_port_->host(), 
  
  
  
  
                               host_port_->port(), 
  
  
  
  
                               inspect_publish_uid_); 
  
  
  
  
  request_queue_ = queue->handle(); 
  
  
  
  
  // Its lifetime is now that of the server delegate 
  
  
  
  
  queue.reset(); 
  
  
  
  
  { 
  
  
  
  
    Mutex::ScopedLock scoped_lock(thread_start_lock_); 
  
  
  
  
    // 啟動服務器 
  
  
  
  
    if (server.Start()) { 
  
  
  
  
      host_port_->set_port(server.Port()); 
  
  
  
  
    } 
  
  
  
  
    thread_start_condition_.Broadcast(scoped_lock); 
  
  
  
  
  } 
  
  
  
  
  // 進入事件循環(huán) 
  
  
  
  
  uv_run(&loop, UV_RUN_DEFAULT); 
  
  
  
  
  CheckedUvLoopClose(&loop); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

我們分析一下服務器相關的邏輯。先看一下創(chuàng)建一個服務器的邏輯

 
 
 
 

  
  
  
  
InspectorSocketServer::InspectorSocketServer( 
  
  
  
  
    std::unique_ptr delegate, uv_loop_t* loop, 
  
  
  
  
    const std::string& host, int port, 
  
  
  
  
    const InspectPublishUid& inspect_publish_uid, FILE* out) 
  
  
  
  
    : loop_(loop), 
  
  
  
  
      delegate_(std::move(delegate)), 
  
  
  
  
      host_(host), 
  
  
  
  
      port_(port), 
  
  
  
  
      inspect_publish_uid_(inspect_publish_uid), 
  
  
  
  
      next_session_id_(0), 
  
  
  
  
      out_(out) { 
  
  
  
  
  // 把服務器對象關聯(lián)到delete對象中 
  
  
  
  
  delegate_->AssignServer(this); 
  
  
  
  
  // 狀態(tài)為初始化 
  
  
  
  
  state_ = ServerState::kNew; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

接著看啟動服務器的邏輯。

 
 
 
 

  
  
  
  
bool InspectorSocketServer::Start() { 
  
  
  
  
  std::unique_ptr delegate_holder; 
  
  
  
  
  // We will return it if startup is successful 
  
  
  
  
  delegate_.swap(delegate_holder); 
  
  
  
  
  struct addrinfo hints; 
  
  
  
  
  memset(&hints, 0, sizeof(hints)); 
  
  
  
  
  hints.ai_flags = AI_NUMERICSERV; 
  
  
  
  
  hints.ai_socktype = SOCK_STREAM; 
  
  
  
  
  uv_getaddrinfo_t req; 
  
  
  
  
  const std::string port_string = std::to_string(port_); 
  
  
  
  
  // 獲取地址信息 
  
  
  
  
  int err = uv_getaddrinfo(loop_, &req, nullptr, host_.c_str(), 
  
  
  
  
                           port_string.c_str(), &hints); 
  
  
  
  
  for (addrinfo* address = req.addrinfo; address != nullptr; 
  
  
  
  
       address = address->ai_next) { 
  
  
  
  
    // 真正創(chuàng)建一個服務器 
  
  
  
  
    auto server_socket = ServerSocketPtr(new ServerSocket(this)); 
  
  
  
  
    // 監(jiān)聽地址，服務器啟動 
  
  
  
  
    err = server_socket->Listen(address->ai_addr, loop_); 
  
  
  
  
    if (err == 0) 
  
  
  
  
      server_sockets_.push_back(std::move(server_socket)); 
  
  
  
  
  } 
  
  
  
  
  uv_freeaddrinfo(req.addrinfo); 
  
  
  
  
  delegate_.swap(delegate_holder); 
  
  
  
  
  state_ = ServerState::kRunning; 
  
  
  
  
  // 打印提示，讓用戶知道連接到哪個url 
  
  
  
  
  PrintDebuggerReadyMessage(host_, 
  
  
  
  
                            server_sockets_, 
  
  
  
  
                            delegate_->GetTargetIds(), 
  
  
  
  
                            inspect_publish_uid_.console, 
  
  
  
  
                            out_); 
  
  
  
  
  return true; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

啟動服務器的本質(zhì)就是監(jiān)聽某些IP+端口，所以我們接著分析一下ServerSocket對象的Listen函數(shù)。ServerSocket是對Libuv結構體uv_tcp_t的封裝，表示一個基于TCP的socket。另外ServerSocket還保存了所屬的InspectorSocketServer對象。

 
 
 
 

  
  
  
  
int ServerSocket::Listen(sockaddr* addr, uv_loop_t* loop) { 
  
  
  
  
  uv_tcp_t* server = &tcp_socket_; 
  
  
  
  
  // 初始化Libuv handle 
  
  
  
  
  CHECK_EQ(0, uv_tcp_init(loop, server)); 
  
  
  
  
  // 在handle上綁定地址 
  
  
  
  
  uv_tcp_bind(server, addr, 0); 
  
  
  
  
  // 監(jiān)聽socket，監(jiān)聽成功后執(zhí)行SocketConnectedCallback 
  
  
  
  
  uv_listen(reinterpret_cast(server), 511, ServerSocket::SocketConnectedCallback); 
  
  
  
  
  return err; 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

繼續(xù)看SocketConnectedCallback

 
 
 
 

  
  
  
  
void ServerSocket::SocketConnectedCallback(uv_stream_t* tcp_socket, 
  
  
  
  
                                           int status) { 
  
  
  
  
  // 監(jiān)聽成功                                         
  
  
  
  
  if (status == 0) { 
  
  
  
  
    // uv_tcp_t獲取所屬的ServerSocket對象 
  
  
  
  
    ServerSocket* server_socket = ServerSocket::FromTcpSocket(tcp_socket); 
  
  
  
  
    // Memory is freed when the socket closes. 
  
  
  
  
    server_socket->server_->Accept(server_socket->port_, tcp_socket); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

接著看InspectorSocketServer::Accept。

 
 
 
 

  
  
  
  
void InspectorSocketServer::Accept(int server_port, 
  
  
  
  
                                   uv_stream_t* server_socket) { 
  
  
  
  
  // 新建一個session表示一個連接對應的會話                                  
  
  
  
  
  std::unique_ptr session( 
  
  
  
  
      new SocketSession(this, next_session_id_++, server_port)); 
  
  
  
  
  // 申請一個Delegate處理連接中的數(shù)據(jù) 
  
  
  
  
  InspectorSocket::DelegatePointer delegate = 
  
  
  
  
      InspectorSocket::DelegatePointer( 
  
  
  
  
          new SocketSession::Delegate(this, session->id())); 
  
  
  
  
  // 摘取一個連接 
  
  
  
  
  InspectorSocket::Pointer inspector = 
  
  
  
  
      InspectorSocket::Accept(server_socket, std::move(delegate)); 
  
  
  
  
  if (inspector) { 
  
  
  
  
    // 設置session對應的InspectorSocket 
  
  
  
  
    session->Own(std::move(inspector)); 
  
  
  
  
    connected_sessions_[session->id()].second = std::move(session); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

接著看InspectorSocket::Accept

 
 
 
 

  
  
  
  
InspectorSocket::Pointer InspectorSocket::Accept(uv_stream_t* server, 
  
  
  
  
                                                 DelegatePointer delegate) { 
  
  
  
  
  // 摘取一個TCP連接                                                
  
  
  
  
  auto tcp = TcpHolder::Accept(server, std::move(delegate)); 
  
  
  
  
  // 操作成功 
  
  
  
  
  if (tcp) { 
  
  
  
  
    // 新建一個InspectorSocket表示和客戶的通信的對象 
  
  
  
  
    InspectorSocket* inspector = new InspectorSocket(); 
  
  
  
  
    // 設置處理連接數(shù)據(jù)的協(xié)議handler，即把數(shù)據(jù)當作HTTP協(xié)議處理 
  
  
  
  
    inspector->SwitchProtocol(new HttpHandler(inspector, std::move(tcp))); 
  
  
  
  
    return InspectorSocket::Pointer(inspector); 
  
  
  
  
  } else { 
  
  
  
  
    return InspectorSocket::Pointer(nullptr); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

接著看TcpHolder::Accept

 
 
 
 

  
  
  
  
TcpHolder::Pointer TcpHolder::Accept( 
  
  
  
  
    uv_stream_t* server, 
  
  
  
  
    InspectorSocket::DelegatePointer delegate) { 
  
  
  
  
  // 新建一個TcpHolder表示TCP連接 
  
  
  
  
  TcpHolder* result = new TcpHolder(std::move(delegate)); 
  
  
  
  
  uv_stream_t* tcp = reinterpret_cast(&result->tcp_); 
  
  
  
  
  // 初始化 
  
  
  
  
  uv_tcp_init(server->loop, &result->tcp_); 
  
  
  
  
  // 這才是真正的摘取連接邏輯，uv_accept會把連接的fd保存到tcp結構體中 
  
  
  
  
  uv_accept(server, tcp); 
  
  
  
  
  // 設置等待可讀事件，回調(diào)是OnDataReceivedCb 
  
  
  
  
  uv_read_start(tcp, allocate_buffer, OnDataReceivedCb); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

當數(shù)據(jù)到來時，我們看一下OnDataReceivedCb是怎么處理的。

 
 
 
 

  
  
  
  
void TcpHolder::OnDataReceivedCb(uv_stream_t* tcp, ssize_t nread, 
  
  
  
  
                                 const uv_buf_t* buf) { 
  
  
  
  
  TcpHolder* holder = From(tcp); 
  
  
  
  
  holder->ReclaimUvBuf(buf, nread); 
  
  
  
  
  if (nread < 0 || nread == UV_EOF) { 
  
  
  
  
    holder->handler_->OnEof(); 
  
  
  
  
  } else { 
  
  
  
  
    holder->handler_->OnData(&holder->buffer); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

OnDataReceivedCb會調(diào)用handler_的onData函數(shù)，handler_就是HttpHandler。

 
 
 
 

  
  
  
  
void OnData(std::vector* data) override { 
  
  
  
  
    llhttp_errno_t err; 
  
  
  
  
    // 解析http協(xié)議 
  
  
  
  
    err = llhttp_execute(&parser_, data->data(), data->size()); 
  
  
  
  
 
  
  
  
  
    if (err == HPE_PAUSED_UPGRADE) { 
  
  
  
  
      err = HPE_OK; 
  
  
  
  
      llhttp_resume_after_upgrade(&parser_); 
  
  
  
  
    } 
  
  
  
  
    // 省略一些步驟，第一個請求是一個升級http協(xié)議到websocket協(xié)議的請求 
  
  
  
  
    delegate()->OnSocketUpgrade(event.host, event.path, event.ws_key); 
  
  
  
  
 } 
 
 
 
 

看看HttpHandler的delegate(ProtocolHandler是HttpHandler的基類)

 
 
 
 

  
  
  
  
InspectorSocket::Delegate* ProtocolHandler::delegate() { 
  
  
  
  
  return tcp_->delegate(); 
  
  
  
  
 
  
  
  
  
} 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
InspectorSocket::Delegate* TcpHolder::delegate() { 
  
  
  
  
  return delegate_.get(); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

獲取的是TcpHolder的delegate。而TcpHolder的delegate是SocketSession::Delegate。即最后調(diào)用的是SocketSession::Delegate的OnSocketUpgrade函數(shù)。

 
 
 
 

  
  
  
  
void SocketSession::Delegate::OnSocketUpgrade(const std::string& host, 
  
  
  
  
                                              const std::string& path, 
  
  
  
  
                                              const std::string& ws_key) { 
  
  
  
  
  std::string id = path.empty() ? path : path.substr(1); 
  
  
  
  
  server_->SessionStarted(session_id_, id, ws_key); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

繼續(xù)看server_->SessionStarted。

 
 
 
 

  
  
  
  
void InspectorSocketServer::SessionStarted(int session_id, 
  
  
  
  
                                           const std::string& id, 
  
  
  
  
                                           const std::string& ws_key) { 
  
  
  
  
  SocketSession* session = Session(session_id); 
  
  
  
  
  connected_sessions_[session_id].first = id; 
  
  
  
  
  // 處理wesocket和客戶端的會話 
  
  
  
  
  session->Accept(ws_key); 
  
  
  
  
  // 開啟一個服務器中agent和V8 inspector會話 
  
  
  
  
  delegate_->StartSession(session_id, id); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

server_->SessionStarted主要有三個邏輯

1 保存一個和客戶端通信會話的關系

2 完成http協(xié)議到websocket協(xié)議的升級

3 新建一個和V8 Inspector的會話，Node.js類似一個代理。

我們先看如何處理websocket和客戶端的會話

 
 
 
 

  
  
  
  
void Accept(const std::string& ws_key) { 
  
  
  
  
    ws_socket_->AcceptUpgrade(ws_key); 
  
  
  
  
} 
 
 
 
 

ws_socket_是session對應的InspectorSocket對象。

 
 
 
 

  
  
  
  
void InspectorSocket::AcceptUpgrade(const std::string& ws_key) { 
  
  
  
  
  protocol_handler_->AcceptUpgrade(ws_key); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

InspectorSocket::AcceptUpgrade根據(jù)當前處理協(xié)議的handler進一步處理，目前是HTTP協(xié)議。

 
 
 
 

  
  
  
  
void AcceptUpgrade(const std::string& accept_key) override { 
  
  
  
  
    char accept_string[ACCEPT_KEY_LENGTH]; 
  
  
  
  
    generate_accept_string(accept_key, &accept_string); 
  
  
  
  
    // 回復101 Switching Protocols給客戶端說明同意協(xié)議升級 
  
  
  
  
    const char accept_ws_prefix[] = "HTTP/1.1 101 Switching Protocols\r\n" 
  
  
  
  
                                    "Upgrade: websocket\r\n" 
  
  
  
  
                                    "Connection: Upgrade\r\n" 
  
  
  
  
                                    "Sec-WebSocket-Accept: "; 
  
  
  
  
    const char accept_ws_suffix[] = "\r\n\r\n"; 
  
  
  
  
    std::vector reply(accept_ws_prefix, 
  
  
  
  
                            accept_ws_prefix + sizeof(accept_ws_prefix) - 1); 
  
  
  
  
    reply.insert(reply.end(), accept_string, 
  
  
  
  
                 accept_string + sizeof(accept_string)); 
  
  
  
  
    reply.insert(reply.end(), accept_ws_suffix, 
  
  
  
  
                 accept_ws_suffix + sizeof(accept_ws_suffix) - 1); 
  
  
  
  
    if (WriteRaw(reply, WriteRequest::Cleanup) >= 0) { 
  
  
  
  
       // 切換協(xié)議為websocket，協(xié)議升級成功后，后續(xù)的數(shù)據(jù)被當作websocket協(xié)議處理 
  
  
  
  
      inspector_->SwitchProtocol(new WsHandler(inspector_, std::move(tcp_))); 
  
  
  
  
    } else { 
  
  
  
  
      tcp_.reset(); 
  
  
  
  
    } 
  
  
  
  
} 
 
 
 
 

AcceptUpgrade完成了協(xié)議升級，接著服務器還需要和V8 inspector建立一個會話。

 
 
 
 

  
  
  
  
void InspectorIoDelegate::StartSession(int session_id, 
  
  
  
  
                                       const std::string& target_id) { 
  
  
  
  
  auto session = main_thread_->Connect( 
  
  
  
  
      std::unique_ptr( 
  
  
  
  
          new IoSessionDelegate(request_queue_->handle(), session_id)), true); 
  
  
  
  
  if (session) { 
  
  
  
  
    sessions_[session_id] = std::move(session); 
  
  
  
  
    fprintf(stderr, "Debugger attached.\n"); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

main_thread_是MainThreadHandle對象。

 
 
 
 

  
  
  
  
std::unique_ptr MainThreadHandle::Connect( 
  
  
  
  
    std::unique_ptr delegate, 
  
  
  
  
    bool prevent_shutdown) { 
  
  
  
  
  return std::unique_ptr( 
  
  
  
  
      new CrossThreadInspectorSession(++next_session_id_, 
  
  
  
  
                                      shared_from_this(), 
  
  
  
  
                                      std::move(delegate), 
  
  
  
  
                                      prevent_shutdown)); 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

這里新建了一個CrossThreadInspectorSession對象。我們看看CrossThreadInspectorSessionde 構造函數(shù)。

 
 
 
 

  
  
  
  
CrossThreadInspectorSession( 
  
  
  
  
      int id, 
  
  
  
  
      std::shared_ptr thread, 
  
  
  
  
      std::unique_ptr delegate, 
  
  
  
  
      bool prevent_shutdown) 
  
  
  
  
      : state_(thread, std::bind(MainThreadSessionState::Create, 
  
  
  
  
                                 std::placeholders::_1, 
  
  
  
  
                                 prevent_shutdown)) { 
  
  
  
  
    state_.Call(&MainThreadSessionState::Connect, std::move(delegate)); 
  
  
  
  
} 
 
 
 
 

構造函數(shù)中執(zhí)行了MainThreadSessionState::Connect函數(shù)

 
 
 
 

  
  
  
  
void Connect(std::unique_ptr delegate) { 
  
  
  
  
    Agent* agent = thread_->inspector_agent(); 
  
  
  
  
    if (agent != nullptr) 
  
  
  
  
      session_ = agent->Connect(std::move(delegate), prevent_shutdown_); 
  
  
  
  
} 
 
 
 
 

Connect最后調(diào)用了agent的Connect。

 
 
 
 

  
  
  
  
std::unique_ptr Agent::Connect( 
  
  
  
  
    std::unique_ptr delegate, 
  
  
  
  
    bool prevent_shutdown) { 
  
  
  
  
  CHECK_NOT_NULL(client_); 
  
  
  
  
  int session_id = client_->connectFrontend(std::move(delegate), 
  
  
  
  
                                            prevent_shutdown); 
  
  
  
  
  return std::unique_ptr( 
  
  
  
  
      new Sa                                                

                                                本文標題：深入理解Node.js的Inspector                                                

                                                URL地址：http://www.dlmjj.cn/article/ccisheo.html