0
Fork 0
mirror of https://github.com/ninenines/cowboy.git synced 2025-07-14 12:20:24 +00:00

Graceful shutdown

Note: This commit makes cowboy depend on cowlib master.

Graceful shutdown for HTTP/2:

1. A GOAWAY frame with the last stream id set to 2^31-1 is sent and a
   timer is started (goaway_initial_timeout, default 1000ms), to wait
   for any in-flight requests sent by the client, and the status is set
   to 'closing_initiated'. If the client responds with GOAWAY and closes
   the connection, we're done.
2. A second GOAWAY frame is sent with the actual last stream id and the
   status is set to 'closing'. If no streams exist, the connection
   terminates. Otherwise a second timer (goaway_complete_timeout,
   default 3000ms) is started, to wait for the streams to complete. New
   streams are not accepted when status is 'closing'.
3. If all streams haven't completed after the second timeout, the
   connection is forcefully terminated.

Graceful shutdown for HTTP/1.x:

1. If a request is currently being handled, it is waited for and the
   response is sent back to the client with the header "Connection:
   close". Then, the connection is closed.
2. If the current request handler is not finished within the time
   configured in transport option 'shutdown' (default 5000ms), the
   connection process is killed by its supervisor (ranch).

Implemented for HTTP/1.x and HTTP/2 in the following scenarios:

* When receiving exit signal 'shutdown' from the supervisor (e.g. when
  cowboy:stop_listener/3 is called).
* When a connection process is requested to terminate using
  sys:terminate/2,3.

LH: Edited tests a bit and added todos for useful tests to add.
This commit is contained in:
Viktor Söderqvist 2020-10-08 17:53:25 +02:00 committed by Loïc Hoguin
parent fa9c8ad832
commit 059d58d39f
No known key found for this signature in database
GPG key ID: 8A9DF795F6FED764
9 changed files with 397 additions and 64 deletions

View file

@ -284,3 +284,135 @@ settings_timeout_infinity(Config) ->
after
cowboy:stop_listener(?FUNCTION_NAME)
end.
graceful_shutdown_connection(Config) ->
doc("Check that ongoing requests are handled before gracefully shutting down a connection."),
Dispatch = cowboy_router:compile([{"localhost", [
{"/delay_hello", delay_hello_h,
#{delay => 500, notify_received => self()}}
]}]),
ProtoOpts = #{
env => #{dispatch => Dispatch}
},
{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
Port = ranch:get_port(?FUNCTION_NAME),
try
ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
Ref = gun:get(ConnPid, "/delay_hello"),
%% Make sure the request is received.
receive {request_received, <<"/delay_hello">>} -> ok end,
%% Tell the connection to shutdown while the handler is working.
[CowboyConnPid] = ranch:procs(?FUNCTION_NAME, connections),
monitor(process, CowboyConnPid),
ok = sys:terminate(CowboyConnPid, goaway),
%% Check that the response is sent to the client before the
%% connection goes down.
{response, nofin, 200, _RespHeaders} = gun:await(ConnPid, Ref),
{ok, RespBody} = gun:await_body(ConnPid, Ref),
<<"Hello world!">> = iolist_to_binary(RespBody),
%% Check that the connection is gone soon afterwards. (The exit
%% reason is supposed to be 'goaway' as passed to
%% sys:terminate/2, but it is {shutdown, closed}.)
receive
{'DOWN', _, process, CowboyConnPid, _Reason} ->
ok
end,
[] = ranch:procs(?FUNCTION_NAME, connections),
gun:close(ConnPid)
after
cowboy:stop_listener(?FUNCTION_NAME)
end.
graceful_shutdown_timeout(Config) ->
doc("Check that a connection is closed when gracefully shutting down times out."),
Dispatch = cowboy_router:compile([{"localhost", [
{"/long_delay_hello", delay_hello_h,
#{delay => 10000, notify_received => self()}}
]}]),
ProtoOpts = #{
env => #{dispatch => Dispatch},
goaway_initial_timeout => 200,
goaway_complete_timeout => 500
},
{ok, _} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
Port = ranch:get_port(?FUNCTION_NAME),
try
ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
Ref = gun:get(ConnPid, "/long_delay_hello"),
%% Make sure the request is received.
receive {request_received, <<"/long_delay_hello">>} -> ok end,
%% Tell the connection to shutdown while the handler is working.
[CowboyConnPid] = ranch:procs(?FUNCTION_NAME, connections),
monitor(process, CowboyConnPid),
ok = sys:terminate(CowboyConnPid, goaway),
%% Check that connection didn't wait for the slow handler.
{error, {stream_error, closed}} = gun:await(ConnPid, Ref),
%% Check that the connection is gone. (The exit reason is
%% supposed to be 'goaway' as passed to sys:terminate/2, but it
%% is {shutdown, {stop, {exit, goaway}, 'Graceful shutdown timed
%% out.'}}.)
receive
{'DOWN', _, process, CowboyConnPid, _Reason} ->
ok
after 100 ->
error(still_alive)
end,
[] = ranch:procs(?FUNCTION_NAME, connections),
gun:close(ConnPid)
after
cowboy:stop_listener(?FUNCTION_NAME)
end.
graceful_shutdown_listener(Config) ->
doc("Check that connections are shut down gracefully when stopping a listener."),
Dispatch = cowboy_router:compile([{"localhost", [
{"/delay_hello", delay_hello_h,
#{delay => 500, notify_received => self()}}
]}]),
ProtoOpts = #{
env => #{dispatch => Dispatch}
},
{ok, Listener} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
Port = ranch:get_port(?FUNCTION_NAME),
ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
Ref = gun:get(ConnPid, "/delay_hello"),
%% Shutdown listener while the handlers are working.
receive {request_received, <<"/delay_hello">>} -> ok end,
ListenerMonitorRef = monitor(process, Listener),
ok = cowboy:stop_listener(?FUNCTION_NAME),
receive
{'DOWN', ListenerMonitorRef, process, Listener, _Reason} ->
ok
end,
%% Check that the request is handled before shutting down.
{response, nofin, 200, _RespHeaders} = gun:await(ConnPid, Ref),
{ok, RespBody} = gun:await_body(ConnPid, Ref),
<<"Hello world!">> = iolist_to_binary(RespBody),
gun:close(ConnPid).
graceful_shutdown_listener_timeout(Config) ->
doc("Check that connections are shut down when gracefully stopping a listener times out."),
Dispatch = cowboy_router:compile([{"localhost", [
{"/long_delay_hello", delay_hello_h,
#{delay => 10000, notify_received => self()}}
]}]),
ProtoOpts = #{
env => #{dispatch => Dispatch},
goaway_initial_timeout => 200,
goaway_complete_timeout => 500
},
{ok, Listener} = cowboy:start_clear(?FUNCTION_NAME, [{port, 0}], ProtoOpts),
Port = ranch:get_port(?FUNCTION_NAME),
ConnPid = gun_open([{type, tcp}, {protocol, http2}, {port, Port}|Config]),
Ref = gun:get(ConnPid, "/long_delay_hello"),
%% Shutdown listener while the handlers are working.
receive {request_received, <<"/long_delay_hello">>} -> ok end,
ListenerMonitorRef = monitor(process, Listener),
ok = cowboy:stop_listener(?FUNCTION_NAME),
receive
{'DOWN', ListenerMonitorRef, process, Listener, _Reason} ->
ok
end,
%% Check that the slow request is aborted.
{error, {stream_error, closed}} = gun:await(ConnPid, Ref),
gun:close(ConnPid).