Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/erlang.yml
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ jobs:

build:

runs-on: ubuntu-latest
runs-on: ubuntu-24.04
Comment thread
hjianbo marked this conversation as resolved.
Resolved

strategy:
fail-fast: false
Expand Down
6 changes: 6 additions & 0 deletions changelog.md
Original file line number Diff line number Diff line change
@@ -1,5 +1,11 @@
# ehttpc changes

## 0.7.9

- Complete chunked responses that end with trailers, preserving the response status,
headers, and body for synchronous and asynchronous requests.
Trailer fields are not merged into the response headers.

## 0.7.8

- Made it possible to call `ehttpc:health_check` with a timeout of `infinity`.
Expand Down
2 changes: 1 addition & 1 deletion src/ehttpc.app.src
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
{application, ehttpc, [
{description, "HTTP Client for Erlang/OTP"},
{vsn, "0.7.7"},
{vsn, "0.7.9"},
{registered, []},
{applications, [
kernel,
Expand Down
5 changes: 5 additions & 0 deletions src/ehttpc.erl
Original file line number Diff line number Diff line change
Expand Up @@ -380,6 +380,11 @@ do_handle_info(
#state{client = Client} = State
) ->
handle_gun_reply(State, Client, StreamRef, IsFin, ?undef, ?undef, Data);
do_handle_info(
{gun_trailers, Client, StreamRef, _Trailers},
#state{client = Client} = State
) ->
handle_gun_reply(State, Client, StreamRef, fin, ?undef, ?undef, <<>>);
do_handle_info(
{gun_error, Client, StreamRef, Reason},
State = #state{client = Client, requests = Requests}
Expand Down
2 changes: 1 addition & 1 deletion test/ehttpc_pool_tests.erl
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,7 @@
-include_lib("eunit/include/eunit.hrl").
-include_lib("snabbkaffe/include/snabbkaffe.hrl").

-define(PORT, (60000 + ?LINE)).
-define(PORT, (62000 + ?LINE)).
Comment thread
hjianbo marked this conversation as resolved.
Resolved

kill_recover_test_() ->
{
Expand Down
25 changes: 15 additions & 10 deletions test/ehttpc_server.erl
Original file line number Diff line number Diff line change
Expand Up @@ -81,7 +81,9 @@ listen(Port) ->
end),
receive
{ok, LSocket} ->
{ok, LSocket}
{ok, LSocket};
{error, Reason} ->
{error, Reason}
end.

loop(Socket, Opts) ->
Expand Down Expand Up @@ -214,9 +216,10 @@ socket_send(
_ ->
0
end,
BeforeFin = maps:get(before_fin, maps:get(chunked, Opts, #{}), fun() -> ok end),
case gen_tcp:send(Socket, Headers) of
ok ->
case socket_send_body_chunks(Socket, BodyChunks, ChunkedDelay, FinDelay) of
case socket_send_body_chunks(Socket, BodyChunks, ChunkedDelay, FinDelay, BeforeFin) of
ok ->
ok;
{error, Reason} ->
Expand All @@ -226,21 +229,21 @@ socket_send(
{error, Reason}
end.

socket_send_body_chunks(_Socket, [], _, _) ->
socket_send_body_chunks(_Socket, [], _, _, _) ->
ok;
socket_send_body_chunks(Socket, [H | T], Delay, FinDelay) ->
socket_send_body_chunks(Socket, [H | T], Delay, FinDelay, BeforeFin) ->
case gen_tcp:send(Socket, H) of
ok ->
%% maybe delya each chunk (when Delay > 0)
timer:sleep(Delay),
case T of
[_] when FinDelay > 0 ->
%% delay the last chunk
timer:sleep(FinDelay);
[_] ->
BeforeFin(),
FinDelay > 0 andalso timer:sleep(FinDelay);
_ ->
ok
end,
socket_send_body_chunks(Socket, T, Delay, FinDelay);
socket_send_body_chunks(Socket, T, Delay, FinDelay, BeforeFin);
{error, Reason} ->
{error, Reason}
end.
Expand Down Expand Up @@ -277,8 +280,10 @@ make_response(Opts, IsHead) ->
},
Resp.

make_chunks(#{chunked := #{chunk_size := Size, chunks := Count}}) ->
make_chunks(#{chunked := #{chunk_size := Size, chunks := Count} = Chunked}) ->
%% we use the counts to generat bytes, (to verify the final number of chunks received)
Count > 255 andalso error({bad_chunk_count, Count}),
RawL = [iolist_to_binary(lists:duplicate(Size, I)) || I <- lists:seq(1, Count)],
[cow_http_te:chunk(I) || I <- RawL] ++ [cow_http_te:last_chunk()].
Trailers = maps:to_list(maps:get(trailers, Chunked, #{})),
Last = ["0\r\n", [[K, ": ", V, "\r\n"] || {K, V} <- Trailers], "\r\n"],
[cow_http_te:chunk(I) || I <- RawL] ++ [Last].
136 changes: 135 additions & 1 deletion test/ehttpc_tests.erl
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@
-include_lib("snabbkaffe/include/snabbkaffe.hrl").

-define(POOL, <<"testpool">>).
-define(PORT, (60000 + ?LINE)).
-define(PORT, (62000 + ?LINE)).

-define(WITH_SERVER(Opts, Expr),
with_server(Opts, fun() -> Expr end)
Expand Down Expand Up @@ -770,6 +770,140 @@ head_request_test() ->
{ok, _, _} = ehttpc:request(?POOL, head, <<"/">>)
).

chunked_trailers_test_() ->
[
{integer_to_list(Count), fun() -> chunked_trailers(Count) end}
|| Count <- [0, 2]
].

chunked_trailers(Count) ->
Port = ?PORT,
ServerOpts = #{
port => Port,
name => chunked_trailers,
chunked => #{chunk_size => 3, chunks => Count, trailers => #{<<"x-check">> => <<"ok">>}}
},
?WITH(
ServerOpts,
pool_opts(Port, false),
begin
Worker = ehttpc_pool:pick_worker(?POOL),
Expected = iolist_to_binary([binary:copy(<<I>>, 3) || I <- lists:seq(1, Count)]),
?assertMatch({ok, 200, _, Expected}, ehttpc:request(Worker, get, req(), 500, 0)),
#{client := Client} = ehttpc:get_state(Worker, normal),
Tester = self(),
Callback = {fun(Result) -> Tester ! {trailers_result, Result} end, []},
ok = ehttpc:request_async(Worker, get, req(), 500, Callback),
receive
{trailers_result, Result} -> ?assertMatch({ok, 200, _, Expected}, Result)
after 1_000 ->
error(trailers_callback_timeout)
end,
?assertMatch(#{client := Client}, ehttpc:get_state(Worker, normal))
end
).

chunked_trailers_pipeline_test() ->
with_controlled_trailers(fun(Worker) ->
ok = request_trailers_async(Worker, first),
Server = await_trailers(),
ok = request_trailers_async(Worker, second),
?assertMatch(#{requests := #{sent := 2}}, ehttpc:get_state(Worker)),
#{client := Client} = ehttpc:get_state(Worker),
Server ! send_trailers,
assert_trailers_result(first),
Server = await_trailers(),
Server ! send_trailers,
assert_trailers_result(second),
?assertMatch(#{client := Client, requests := #{sent := 0}}, ehttpc:get_state(Worker))
end).

chunked_trailers_after_timeout_test() ->
with_controlled_trailers(fun(Worker) ->
?assertEqual({error, timeout}, ehttpc:request(Worker, get, req(), 200, 0)),
Server = await_trailers(),
#{client := Client} = ehttpc:get_state(Worker),
ok = request_trailers_async(Worker, next),
?assertMatch(#{requests := #{sent := 2}}, ehttpc:get_state(Worker)),
Server ! send_trailers,
Server = await_trailers(),
Server ! send_trailers,
assert_trailers_result(next),
?assertMatch(#{client := Client, requests := #{sent := 0}}, ehttpc:get_state(Worker))
end).

chunked_trailers_after_cancel_test() ->
with_controlled_trailers(fun(Worker) ->
Tester = self(),
ok = ehttpc:request_async(Worker, get, req(), 1_000, #{
final_reply => {fun(Result) -> Tester ! {cancelled_result, Result} end, []},
stream_ref => {fun(Ref, W) -> Tester ! {trailers_stream, Ref, W} end, []}
}),
Ref =
receive
{trailers_stream, R, Worker} -> R
after 1_000 -> error(no_stream_ref)
end,
Server = await_trailers(),
ok = ehttpc:cancel(Worker, Ref),
?assertMatch(#{requests := #{sent := 0}}, ehttpc:get_state(Worker)),
Server ! send_trailers,
ok = request_trailers_async(Worker, next),
Server = await_trailers(),
Server ! send_trailers,
assert_trailers_result(next),
receive
{cancelled_result, _} -> error(callback_after_cancel)
after 100 -> ok
end
end).

with_controlled_trailers(Fun) ->
Tester = self(),
BeforeFin = fun() ->
Tester ! {trailers_ready, self()},
receive
send_trailers -> ok
after 2_000 -> error(trailers_not_released)
end
end,
Port = ?PORT,
ServerOpts = #{
port => Port,
name => controlled_trailers,
chunked => #{
chunk_size => 1,
chunks => 1,
trailers => #{<<"x-check">> => <<"ok">>},
before_fin => BeforeFin
}
},
?WITH(ServerOpts, pool_opts(Port, 2), Fun(ehttpc_pool:pick_worker(?POOL))).

await_trailers() ->
receive
{trailers_ready, Server} -> Server
after 1_000 -> error(no_trailers)
end.

request_trailers_async(Worker, Tag) ->
Tester = self(),
ehttpc:request_async(
Worker,
get,
req(),
1_000,
{
fun(Result) -> Tester ! {Tag, Result} end, []
}
).

assert_trailers_result(Tag) ->
receive
{Tag, Result} -> ?assertMatch({ok, 200, _, <<1>>}, Result)
after 1_000 -> error(trailers_callback_timeout)
end.

data_chunked_test() ->
Port = ?PORT,
Host = "127.0.0.1",
Expand Down
Loading