Bagaimana untuk menangani Nginx membuang badan paket http

Penjelasan terperinci tentang nginx membuang contoh pemprosesan badan pakej http

Rangka kerja http membuang badan pakej permintaan http dan rangka kerja http artikel sebelumnya menerima badan pakej, kedua-duanya disediakan oleh Kaedah rangka http , dipanggil oleh setiap modul http untuk memutuskan perkara yang perlu dilakukan dengan badan pakej. Sama ada untuk memilih untuk membuang atau menerima ditentukan oleh modul. Sebagai contoh, jika modul sumber statik menerima permintaan dapatkan daripada penyemak imbas dan meminta fail, ia boleh terus mengembalikan kandungan fail kepada penyemak imbas. Tidak perlu menerima data badan pakej, dan permintaan dapatkan sebenarnya tidak akan mempunyai badan pakej. Oleh itu, modul sumber statik akan memanggil fungsi badan paket buang yang disediakan oleh rangka kerja http untuk melaksanakan pemprosesan buangan paket.

Berbanding dengan proses menerima badan pakej, operasi membuang badan pakej adalah lebih mudah Sekurang-kurangnya tidak perlu menyimpan badan pakej dalam penimbal request_body dalam struktur http. dan tidak perlu mempertimbangkan sama ada badan pakej hanya disimpan dalam Ke memori, atau hanya pada fail, dsb., rangka kerja membuangnya terus selepas menerima badan pakej. Badan paket buang terdiri daripada tiga bahagian:

(1) Modul http memanggil fungsi ngx_http_discard_request_body yang disediakan oleh rangka kerja buat kali pertama untuk melakukan beberapa operasi pemula. Contohnya, jika semua badan paket tidak boleh dibuang dalam satu operasi, acara baca perlu didaftarkan dalam epoll sekali lagi, supaya operasi membuang paket boleh diteruskan apabila pelaksanaan dijadualkan semula. Tambahan pula, panggil fungsi membuang paket sebenar ngx_http_read_discarded_request_body untuk membuang badan paket.

(2) Jika semua badan paket tidak boleh dibuang dalam satu operasi, apabila acara dijadualkan semula, data paket yang tinggal akan terus diterima dan kemudian dibuang.

(3) Pemprosesan kehilangan paket sebenar, iaitu, terus membuang badan paket selepas menerimanya.

Dapat dilihat dari rajah bahawa antara ketiga-tiga proses ini, proses kehilangan paket adalah fungsi biasa. Maksudnya, sama ada modul http memanggil fungsi ngx_http_discard_request_body untuk memulakan pemprosesan kehilangan paket, atau apabila keseluruhan badan paket tidak diterima dalam satu jadual, ngx_http_discarded_request_body_handler bertanggungjawab untuk membuang baki operasi badan paket dan fungsi kehilangan paket awam ngx_http_read_body_discarded_request akan dipanggil untuk menerima badan paket secara langsung.

1. Proses permulaan kehilangan paket

ngx_http_discard_request_body ialah fungsi yang dipanggil oleh modul http untuk membuang badan paket. Ia adalah operasi telus untuk modul. Dalam erti kata lain, modul hanya perlu memanggil antara muka ini untuk membuang badan paket permintaan http, tanpa mengetahui cara rangka kerja http melaksanakan antara muka ini. Walaupun rangka kerja tidak membuang semua badan paket dalam satu penjadualan, operasi membuang paket akan dilakukan semula apabila penjadualan seterusnya dilaksanakan, tetapi modul tidak mengetahui perkara ini.

//功能: 丢弃http包体的首次回调函数，如果一次性不能全部接收完成并丢弃，则设置 
//  读事件的回调为ngx_http_discarded_request_body_handler 
ngx_int_t ngx_http_discard_request_body(ngx_http_request_t *r) 
{ 
 
 //需要丢弃的包体不用考虑超时问题 
 if (rev->timer_set) 
 { 
  ngx_del_timer(rev); 
 } 
 
 //包体长度小于等于0，则直接返回。表示丢弃包体 
 //如果已经接收过包体了，这时也不需要在接收。通常情况下get请求没有包体，因此包体长度为0 
 if (r->headers_in.content_length_n <= 0 || r->request_body) 
 { 
  return ngx_ok; 
 } 
 
 size = r->header_in->last - r->header_in->pos; 
 //已经预先接收了部分包体 
 if (size) 
 { 
  //包体未全部接收完成 
  if (r->headers_in.content_length_n > size) 
  { 
   r->header_in->pos += size; 
   r->headers_in.content_length_n -= size; 
 
  } 
  else 
  { 
   //包体已经全部接收 
   r->header_in->pos += (size_t) r->headers_in.content_length_n; 
   r->headers_in.content_length_n = 0; 
   return ngx_ok; 
  } 
 } 
 
 //设置后续读事件的回调 
 r->read_event_handler = ngx_http_discarded_request_body_handler; 
 
 //注册读事件回调，插入到epoll 
 ngx_handle_read_event(rev, 0)); 
  
 //接收包体内容 
 if (ngx_http_read_discarded_request_body(r) == ngx_ok) 
 { 
  //表示已经接收到完整的包体了，将延迟关闭清0 
  r->lingering_close = 0; 
 
 } 
 else 
 { 
  //表示需要多次调度才能完成丢弃包体这个操作，于是把引用计数加1，防止这边在丢弃包体，而其他 
  //事件却已经让请求意外销毁 
  r->count++; 
  //标识为正在丢弃包体 
  r->discard_body = 1; 
 } 
 
 return ngx_ok; 
}

Apabila menerima pengepala permintaan http, jika data badan paket http juga diterima, tidak perlu terus melakukan operasi yang tinggal pada masa ini berjaya dibuang, fungsi itu kembali secara langsung. Jika semua badan paket tidak dibuang dalam satu jadual, acara baca read_event_handler struktur permintaan http ngx_http_request_s akan ditetapkan kepada: ngx_http_discarded_request_body_handler Fungsi ini akan bertanggungjawab untuk membuang baki badan paket pada kali berikutnya ia dijadualkan. Oleh itu ngx_http_discard_request_body hanya akan dipanggil buat kali pertama oleh modul http.

Fungsi ini juga akan memanggil fungsi kehilangan paket sebenar ngx_http_read_discarded_request_body untuk mula menerima badan paket dan membuangnya terus.

2. Pemprosesan kehilangan paket

Fungsi ngx_http_read_discarded_request_body bertanggungjawab untuk menerima data badan paket daripada pelanggan dan kemudian membuangnya. Oleh itu, untuk modul, ia adalah operasi membuang badan pakej, tetapi untuk rangka kerja, operasi membuang badan pakej sebenarnya adalah operasi menerima badan pakej, tetapi data badan pakej yang diterima tidak diberikan kepada modul untuk kegunaan. Mengapa rangka kerja perlu menerima badan pakej dan kemudian membuangnya secara langsung, bukankah ia tidak perlu? Ia tidak begitu, ada sebab mengapa ia dilakukan dengan cara ini. Andaikan bahawa penyemak imbas klien yang tidak mantap menggunakan kaedah menyekat untuk menghantar data badan paket http ke pelayan nginx Jika rangka kerja nginx tidak menerimanya, ia akan menyebabkan penyemak imbas pelanggan tamat masa dan tidak bertindak balas, menyebabkan penyemak imbas klien menutup. sambungan. Oleh itu, rangka kerja http nginx mesti terlebih dahulu menerima data badan pakej daripada klien daripada kernel, tetapi data ini tidak berguna kepada modul, jadi data yang diterima akan dibuang terus.

//功能: 从内核中读取数据到nginx中，nginx不对收到的数据进行处理。相当于丢弃包体 
static ngx_int_t ngx_http_read_discarded_request_body(ngx_http_request_t *r) 
{ 
 //用于接收包体的临时缓冲区 
 u_char buffer[ngx_http_discard_buffer_size]; 
 
 for ( ;; ) 
 { 
  //已经全部丢弃成功 
  if (r->headers_in.content_length_n == 0) 
  { 
   //设置丢弃后的读事件回调，再有读事件时，不做任何处理 
   r->read_event_handler = ngx_http_block_reading; 
   return ngx_ok; 
  } 
   
  //从内核中接收包体到临时缓冲区 
  n = r->connection->recv(r->connection, buffer, size); 
 
  //更新剩余需要接收的包体大小 
  r->headers_in.content_length_n -= n; 
 } 
}

        函数内部只是使用一个临时的缓冲区变量存放每次接收来自内核的包体数据。并没有把这部分数据保存到http请求结构中的request_body缓冲区。因此包体数据没有交给http模块，相当于被丢弃了。在所有包体从内核中接收完成时，设置http请求结构ngx_http_request_s的读事件read_event_handler回调设置为: ngx_http_block_reading， 表示再收到来自客户端的数据，则不进行任何处理了。因为已经接收完所有的包体数据，也就不需要理会来自客户端浏览器的其它数据。

三、丢弃剩余的包体

        ngx_http_discarded_request_body_handler用于在一次调度中没有丢弃完所有包体，则该函数会表调用，用于丢弃剩余的包体。函数内部也会调用实际的丢弃包体函数，进行接收包体然后丢弃操作。nginx服务器做了一个优化处理，会设置一个总超时时间，如果超过这个时间都还没有丢弃完全部的包体，则会关闭这个连接。这是一种对服务器保护的措施，避免长时间的丢包操作占用服务器资源。

//功能: 第1次未能全部丢弃包体时，该函数被调用。之后有读事件时，该函数被调用 
void ngx_http_discarded_request_body_handler(ngx_http_request_t *r) 
{ 
 //检测延迟关闭时间,如果总时长超过了lingering_time，则不再接收任何包体，这是一个总时间。 
 //总超时后，将直接光比连接 
 if (r->lingering_time) 
 { 
  timer = (ngx_msec_t) (r->lingering_time - ngx_time()); 
  //已经到达了延迟关闭时间 
  if (timer <= 0) 
  { 
   //清空丢弃包体标识，表示包体已经丢弃 
   r->discard_body = 0;  
   //延迟关闭开关清0 
   r->lingering_close = 0; 
   ngx_http_finalize_request(r, ngx_error); 
   return; 
  } 
 
 } 
 
 //接收包体后丢弃 
 rc = ngx_http_read_discarded_request_body(r); 
 //表示包体已经全部丢弃 
 if (rc == ngx_ok) 
 { 
  r->discard_body = 0;  //包体已经全部接收完 
  r->lingering_close = 0;  //清空延迟关闭标志 
  ngx_http_finalize_request(r, ngx_done); 
  return; 
 } 
}

        ngx_http_discarded_request_body_handler这个函数是怎么被事件对象调用的呢? 在前面的文章已经分析了，ngx_connection_s读事件的回调设置为ngx_http_request_handler。   因此在读事件发生时，会回调请求结构的读回调。如果还不是不清楚这个调用过程，可以参考:

static void ngx_http_request_handler(ngx_event_t *ev) 
{ 
 //如果同时发生读写事件，则只有写事件才会触发。写事件优先级更高 
 if (ev->write)  
 { 
  r->write_event_handler(r); //在函数ngx_http_handler设置为ngx_http_core_run_phases 
 } 
 else 
 { 
  r->read_event_handler(r); //在函数ngx_http_process_request设置为ngx_http_block_reading 
 } 
}

Atas ialah kandungan terperinci Bagaimana untuk menangani Nginx membuang badan paket http. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!