修复HTTP2 stream异步关闭引起coredump · Pull Request !10 · OpenNJet/OpenNJet

1. 优化缩进，使用工具进行合并，部分缩进工具未识别出，未合并到主线
2. 修复http2 stream关闭后，物理连接未同步关闭，后续接收到对端数据后，导致的coredump
    - 在进行72小时稳定性测试时，发现http2协议反向代理模式偶尔会coredump,堆栈信息如下：

```
#0  0x0000000000000000 in ?? ()
#1  0x000055c8fc00f421 in njt_http_v2_parse_headers (ph2=ph2@entry=0x55c8fca0b670, b=b@entry=0x55c8fe269cb0) at src/http/v2/njt_http_v2.c:5332
#2  0x000055c8fc030e17 in njt_http_v2_proxy_process_header (r=<optimized out>) at src/http/modules/njt_http_proxy_module.c:6717
#3  0x000055c8fbfead25 in njt_http_upstream_process_header (r=0x55c8fe325e18, u=0x55c8fe2699c0) at src/http/njt_http_upstream.c:2920
#4  0x000055c8fbfe6b12 in njt_http_upstream_handler (ev=<optimized out>) at src/http/njt_http_upstream.c:1424
#5  0x000055c8fbf97810 in njt_event_process_posted (cycle=cycle@entry=0x55c8fc900228, posted=0x55c8fc8b57d0 <njt_posted_events>) at src/event/njt_event_posted.c:36
#6  0x000055c8fbf972bb in njt_process_events_and_timers (cycle=cycle@entry=0x55c8fc900228) at src/event/njt_event.c:276
#7  0x000055c8fbf9f391 in njt_worker_process_cycle (cycle=cycle@entry=0x55c8fc900228, data=data@entry=0x1) at src/os/unix/njt_process_cycle.c:1576
#8  0x000055c8fbf9d9de in njt_spawn_process (cycle=cycle@entry=0x55c8fc900228, proc=proc@entry=0x55c8fbf9f310 <njt_worker_process_cycle>, data=data@entry=0x1, 
    name=name@entry=0x55c8fc4113b8 "worker process", respawn=respawn@entry=-3, preproc=preproc@entry=0x0) at src/os/unix/njt_process.c:208
#9  0x000055c8fbf9f927 in njt_start_worker_processes (cycle=cycle@entry=0x55c8fc900228, n=4, type=type@entry=-3) at src/os/unix/njt_process_cycle.c:648
#10 0x000055c8fbfa148e in njt_master_process_cycle (cycle=0x55c8fc900228) at src/os/unix/njt_process_cycle.c:176
#11 0x000055c8fbf4dd72 in main (argc=<optimized out>, argv=<optimized out>) at src/core/njet.c:419

```

- 测试脚本如下：
```
#!/bin/bash  
  
# 定义命令数组  
commands=(  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http3 -m GET \"https://test92.jdfmgt.com:8843/\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http3 -m GET \"https://test92.jdfmgt.com:8843/2m\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http3 -m GET \"https://test92.jdfmgt.com:8843/3to2/\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http3 -m GET \"https://test92.jdfmgt.com:8843/3to2/2m\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http2 -m GET \"https://test92.jdfmgt.com:8743/\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http2 -m GET \"https://test92.jdfmgt.com:8743/2m\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http2 -m GET \"https://test92.jdfmgt.com:8743/2to3/\" -t 3000"  
    "./http_bench -q 2000 -c 80 -cpus 12 -d 10 -http http2 -m GET \"https://test92.jdfmgt.com:8743/2to3/2m\" -t 3000"  
)  
  
# 定义一个函数，用于随机等待并执行随机命令  
random_wait_and_execute() {  
    # 随机等待时间（秒），0到119之间  
    RANDOM_SECONDS=$((RANDOM % 5))  
  
    # 等待随机时间  
    echo "等待 $RANDOM_SECONDS 秒后执行命令..."  
    sleep $RANDOM_SECONDS  
  
    # 随机选择一个命令索引（0到数组长度减1之间）  
    RANDOM_INDEX=$((RANDOM % ${#commands[@]}))  
  
    # 执行随机选择的命令  
    echo "当前时间：$(date "+%Y-%m-%d %H:%M:%S")，执行命令：${commands[$RANDOM_INDEX]}"  
    bash -c "${commands[$RANDOM_INDEX]}"  # 使用 bash -c 来执行命令，以处理可能包含特殊字符的字符串  
}  
  
# 无限循环执行上述函数  
while true; do  
    random_wait_and_execute  
    # 可以在这里添加一些逻辑来决定何时停止循环，比如执行了一定次数后  
done

```
    - njet配置如下：

```
worker_processes 4;
worker_cpu_affinity 0001 0010 0100 1000;

error_log logs/error.log error;

http {
    include mime.types;
    access_log off;
    proxy_buffering off;          #性能测试时，不缓存页面

log_format quic '$remote_addr - $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent" "$http3"';
    log_format proxy_log_format '$remote_addr - $remote_user [$time_local] '
                               '"$request" $status $body_bytes_sent '
                               '"$http_referer" "$http_user_agent"';

#http
    upstream h {
          server test95.jdfmgt.com:8280;
          keepalive 120;
    }

#https
    upstream hs {
          server test95.jdfmgt.com:8643;
          keepalive 120;
    }

#http2
    upstream h2 {
          server test95.jdfmgt.com:8743;
          keepalive 200;
    }

#http3
    upstream h3 {
          server test95.jdfmgt.com:8843;
          keepalive 200;
    }

server {
	listen 8280;
	server_name test92.jdfmgt.com;
	location / {
		proxy_pass http://h;
                          #error_log logs/log_8280.log debug_http;
	}
	
	location /1to2/ {
            proxy_pass https://h2/;
            proxy_http_version 2;         #后端协议http2
            #error_log logs/log_1to2.log debug_http;
        }

location /1to3/ {
            proxy_pass https://h3/;
            proxy_http_version 3;           #后端协议http3
            #error_log logs/log_1to3.log debug_http;
        }
	
    }

#https测试
    server {
	listen 8643 ssl;
        server_name test92.jdfmgt.com;
        #ssl_protocols       TLSv1.3;

ssl_certificate     jdfmgt_com_2024.pem;
        ssl_certificate_key jdfmgt_com_2024.key;     
        
        #https测试	
        location / {
            proxy_pass https://hs;
	    proxy_set_header Connection "keep-alive";

#error_log logs/log_8643.log debug_http;
        }

#https到http2测试	
        location /1to2/ {
            proxy_pass https://h2/;
            proxy_http_version 2;     #后端协议http2
            #error_log logs/log_1to2.log debug_http;
        }
	
        #https到http3测试		
        location /1to3/ {
            proxy_pass https://h3/;
            proxy_http_version 3;      #后端协议http3
            #error_log logs/log_1to3.log debug_http;
        }
    }
   
    #http2
    server {
        listen 8743 ssl;
       http2 on;
        server_name test92.jdfmgt.com;

#压测时配置，防止物理连接断开
        keepalive_requests 20000;
        keepalive_time     600;
        #ssl_protocols       TLSv1.3;

ssl_certificate     jdfmgt_com_2024.pem;
        ssl_certificate_key jdfmgt_com_2024.key;
      
       #http2测试
        location / {
                 proxy_pass https://h2;
	    proxy_http_version 2;
         #   error_log logs/log_8743.log debug_http;
        }
        
       #http2到http3测试	
        location /2to3/ {
            proxy_pass https://h3/;
            proxy_http_version 3;
            #error_log logs/log_2to3.log debug_http;
        }
#	location /stub {
 #           stub_status;
  #      }
    }
    #http3
    server {
        listen 8843 quic reuseport sndbuf=65535 rcvbuf=65535;
        http3 on;
	server_name test92.jdfmgt.com;
	 #压测时配置，防止stream超出上限，导致物理连接断开
	keepalive_requests 20000;
            keepalive_time     60;
	http3_max_concurrent_streams 1024;
            http3_stream_buffer_size 1024k;
	quic_gso on;

ssl_protocols       TLSv1.3;

ssl_certificate     jdfmgt_com_2024.pem;
        ssl_certificate_key jdfmgt_com_2024.key;     
        
        
        location / {
            proxy_pass https://h3;
            proxy_http_version 3;
            proxy_http3_max_concurrent_streams 1024;
	    proxy_quic_gso on;    #开启gso
#            error_log logs/log_8843.log debug_http;
        }

#http3到http2测试		     
        location /3to2/ {
            proxy_pass https://h2/;
            proxy_http_version 2;
#            error_log logs/log_3to2.log debug;
        }
   }
}
```
经分析跟踪，定位为http2 stream在压力测试时，可能会异常关闭，而stream在关闭时并不会同步关闭connection,因此关闭stream后，可能还会收到对端的报文，而响应的stream对象已经销毁，从而导致coredump，修改bug后，进行72小时稳定测试，运行正常。

类型	指派人员	状态
审查	zhaoygf 已审查通过	已完成 (1/1人)
测试	zhaoygf 已测试通过	已完成 (1/1人)

GVPOpenNJet/OpenNJet

搜索帮助

GVP OpenNJet/OpenNJet