Der Kernprozess der NodeJS-Verarbeitung einer TCP-Verbindung

int uv_tcp_listen(uv_tcp_t* tcp, int Rückstand, uv_connection_cb cb) {
 // Legen Sie die Strategie für die Verarbeitung von Anfragen fest, siehe die Analyse unten if (single_accept == -1) {
  const char* val = getenv("UV_TCP_SINGLE_ACCEPT");
  single_accept = (val != NULL && atoi(val) != 0); /* Standardmäßig deaktiviert. */
 }
 wenn (einzelnes_akzeptieren)
  tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
 //Bind ausführen oder Flag setzen err = maybe_new_socket(tcp, AF_INET, flags);
 // Mit dem Abhören beginnen, wenn (listen(tcp->io_watcher.fd, backlog))
  returniere UV__ERR(errno);
 // Rückruf festlegen tcp->connection_cb = cb;
 tcp->flags |= UV_HANDLE_BOUND;
 // Legen Sie den Rückruf des E/A-Watchers fest, der ausgeführt wird, wenn Epoll die Verbindung überwacht. tcp->io_watcher.cb = uv__server_io;
 // Füge die Beobachterwarteschlange ein. Zu diesem Zeitpunkt wurde sie noch nicht zu epoll hinzugefügt. Die Poll-E/A-Phase durchläuft die Beobachterwarteschlange zur Verarbeitung (epoll_ctl).
 uv__io_start(tcp->loop, &tcp->io_watcher, POLLIN);

 gebe 0 zurück;
}

void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 // Schleifenverarbeitung, uv__stream_fd (stream) ist der dem Server entsprechende fd
 während (uv__stream_fd(stream) != -1) {
  // Holen Sie sich den FD für die Kommunikation mit dem Client über Accept. Wir können sehen, dass sich dieser FD vom FD des Servers unterscheidet. err = uv__accept(uv__stream_fd(stream));
  // Der fd, der uv__stream_fd(stream) entspricht, ist nicht blockierend. Die Rückgabe dieses Fehlers bedeutet, dass keine Verbindung zum Annehmen verfügbar ist. Direkt zurückgeben, wenn (err < 0) {
   wenn (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK))
    zurückkehren;
  }
  //Zeichnen Sie es auf stream->accepted_fd = err;
  // Rückruf ausführen stream->connection_cb(stream, 0);
  /*
   stream->accepted_fd ist -1, was bedeutet, dass accepted_fd im Rückruf connection_cb verbraucht wurde.
   Andernfalls melden Sie zuerst das Leseereignis des fd des Servers in epoll ab, warten Sie auf den Verbrauch und registrieren Sie es dann erneut, d. h. verarbeiten Sie die Anforderung nicht mehr */
  wenn (stream->accepted_fd != -1) {
   uv__io_stop(Schleife, &stream->io_watcher, POLLIN);
   zurückkehren;
  }
 /*
   OK, accepted_fd wurde verbraucht, möchten wir immer noch neues fd akzeptieren?
   Wenn UV_HANDLE_TCP_SINGLE_ACCEPT gesetzt ist, bedeutet dies, dass immer nur eine Verbindung gleichzeitig verarbeitet wird und dann eine Weile pausiert wird, um anderen Prozessen die Möglichkeit zu geben, sie anzunehmen (in einer Multiprozessarchitektur). Wenn es sich nicht um eine Multiprozessarchitektur handelt, stellen Sie dies erneut ein.
   Dies führt zu einer Verzögerung der Verbindungsverarbeitung*/
  wenn (Stream->Typ == UV_TCP &&
    (Stream->Flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
   Struktur Timespec Timeout = { 0, 1 };
   nanosleep(&timeout, NULL);
  }
 }
}

//Rückruf wird ausgelöst, wenn eine Verbindungsvorlage vorhanden ist <typename WrapType, typename UVType>
void ConnectionWrap<WrapTyp, UVTyp>::BeiVerbindung(uv_stream_t* handle,
                          int status) {
 // Holen Sie sich das C++-Layer-Objekt, das der Libuv-Struktur entspricht WrapType* wrap_data = static_cast<WrapType*>(handle->data);
 CHECK_EQ(&wrap_data->handle_, reinterpret_cast<UVType*>(handle));

 Umgebung* env = wrap_data->env();
 HandleScope handle_scope(env->isolate());
 Kontext::Bereich context_scope(env->context());

 //Objekt zur Kommunikation mit dem Client Local<Value> client_handle;

 wenn (Status == 0) {
  // Instanziieren Sie das Client-JavaScript-Objekt und den Handle.
  // Erstellen Sie eine neue JS-Ebene mit dem Objekt Local<Object> client_obj;
  wenn (!WrapType::Instantiate(env, wrap_data, WrapType::SOCKET)
       .ToLocal(&client_obj))
   zurückkehren;

  // Das Client-JavaScript-Objekt auspacken.
  WrapType* Wrap;
  // Speichern Sie das C++-Layer-Objekt, das dem von der JS-Ebene verwendeten Objekt client_obj entspricht, in Wrap ASSIGN_OR_RETURN_UNWRAP(&wrap, client_obj);
  // Den entsprechenden Handle holen
  uv_stream_t* Client = reinterpret_cast<uv_stream_t*>(&wrap->handle_);
  // Nimm eines der von handleAccept empfangenen FDS und speichere es im Client, damit der Client mit dem Client kommunizieren kann, wenn (uv_accept(handle, client))
   zurückkehren;
  Client-Handle = Client-Objekt;
 } anders {
  client_handle = Undefiniert(env->isolate());
 }
 // Callback js, client_handle entspricht der Ausführung von neuem TCP in der js-Ebene
 Lokal<Wert> argv[] = { Integer::Neu(env->isolate(), status), client_handle };
 : Wrap_Data->MakeCallback(Umgebung->onconnection_string(), Arraygröße(argv), argv);
}

int uv_accept(uv_stream_t* Server, uv_stream_t* Client) {
 int err;

 Schalter (Client->Typ) {
  Fall UV_NAMED_PIPE:
  Fall UV_TCP:
   // fd auf Client setzen err = uv__stream_open(client,
              Server->accepted_fd,
              UV_HANDLE_LESBAR | UV_HANDLE_SCHREIBBAR);
   brechen;
 // ...
 }

 Client->Flags |= UV_HANDLE_BOUND;
 // Markieren Sie, dass fd verbraucht wurde
 server->accepted_fd = -1;
 Rückgabefehler;
}

const socket = neuer Socket({
  Griff: ClientHandle,
  allowHalfOpen: self.allowHalfOpen,
  pauseOnCreate: self.pauseOnConnect,
  lesbar: wahr,
  beschreibbar: true
 });