path: root/lib/inets/test/httpd_bench_SUITE.erl

%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2012-2018. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%


%%
-module(httpd_bench_SUITE).
-compile(export_all).

-include_lib("common_test/include/ct.hrl").
-include_lib("common_test/include/ct_event.hrl").
-include_lib("public_key/include/public_key.hrl").
-include_lib("kernel/include/file.hrl").

-define(remote_host, "NETMARKS_REMOTE_HOST").
-define(LF, [10]).
-define(CR, [13]).
-define(CRLF, ?CR ++ ?LF).

%%--------------------------------------------------------------------
%% Common Test interface functions -----------------------------------
%%--------------------------------------------------------------------
suite() -> 
    [{timetrap, {minutes, 1}},
     {ct_hooks,[{ts_install_cth,[{nodenames,2}]}]}].

all() -> 
    [
     {group, http_dummy},
     {group, http_inets},
     {group, http_nginx},
     {group, https_inets},
     {group, https_dummy},
     {group, https_nginx},
     {group, http_dummy_keep_alive},
     {group, http_inets_keep_alive},
     {group, http_nginx_keep_alive},
     {group, https_inets_keep_alive},
     {group, https_dummy_keep_alive},
     {group, https_nginx_keep_alive}
    ].

groups() -> 
    [
     {http_dummy, [],  client_tests()},
     {http_inets, [],   client_tests()},
     {http_nginx, [],   client_tests()},
     {https_dummy, [],  client_tests()}, 
     {https_inets, [],  client_tests()},
     {https_nginx, [],  client_tests()},
     {http_dummy_keep_alive, [],  client_tests()},
     {http_inets_keep_alive, [],  client_tests()},
     {http_nginx_keep_alive, [],  client_tests()},
     {https_dummy_keep_alive, [], client_tests()},
     {https_inets_keep_alive, [], client_tests()},
     {https_nginx_keep_alive, [], client_tests()}
    ].

    
client_tests() ->
    [wget_small,
     erl_dummy_small,
     httpc_small,
     wget_big,
     erl_dummy_big, 
     httpc_big
    ].

init_per_suite(Config) -> 
    try	
	{Node, Host} = setup(Config, node()),
	init_ssl(Config),
	[{iter, 10}, {server_node, Node}, {server_host, Host} | Config]
    catch _:_ ->
	    {skipped, "Benchmark machines only"}
    end.

end_per_suite(_Config) -> 
    [application:stop(App) || App <- [asn1, crypto, public_key, ssl, inets]].

init_per_group(Group, Config) when Group == http_dummy_keep_alive; 
				   Group == https_dummy_keep_alive;
				   Group == http_inets_keep_alive; 
				   Group == https_inets_keep_alive;
				   Group == http_nginx_keep_alive;
				   Group == https_nginx_keep_alive ->
    Version = http_version(Group),
    start_web_server(Group,
		     [{keep_alive, true}, 
		      {reuse_sessions, false},
		      {http_version, Version},
		      {http_opts,[{version, Version}]},
		      {http_headers, [{"connection", "keep-alive"}]},
		      {httpc_opts, [{keep_alive_timeout, 1500}, 
				    {max_keep_alive_length, ?config(iter, Config)}]}
		      | Config]);
init_per_group(Group, Config)  when Group == http_dummy; 
				    Group == https_dummy;
				    Group == http_inets; 
				    Group == https_inets;
				    Group == http_nginx;
				    Group == https_nginx ->
    Version = http_version(Group),
    start_web_server(Group, 
		     [{keep_alive, false}, 
		      {reuse_sessions, false},
		      {http_version, Version},
		      {http_headers, [{"connection", "close"}]},
		      {http_opts,[{version, Version}]},
		      {httpc_opts, [{keep_alive_timeout, 0}, {max_keep_alive_length, 0}]}
		      | Config]);


init_per_group(_, Config) ->
    Config.

end_per_group(Group, Config) ->
    stop_web_server(Group, Config).

init_per_testcase(TestCase, Config) when TestCase == httpc_small;
					 TestCase == httpc_big
					 -> 
    Opts = ?config(httpc_opts, Config),
    inets:start(httpc, [{profile, TestCase}, {socket_opts, [{nodelay, true}]}]),
    httpc:set_options(Opts, TestCase),
    [{profile, TestCase} | proplists:delete(profile, Config)];

init_per_testcase(_, Config) -> 
    Config.
end_per_testcase(TestCase, _Config) when TestCase == httpc_small;
					 TestCase == httpc_big ->	
    ok = inets:stop(httpc, TestCase);
end_per_testcase(_TestCase, Config) ->	
    Config.
%%--------------------------------------------------------------------
%% Test Cases --------------------------------------------------------
%%--------------------------------------------------------------------

erl_dummy_small(Config) when is_list(Config) -> 
    {ok, Result} = run_test(httpd_lib_client, "1k_file", Config),
    notify(Result, Config, "erl_1k_file"). 

erl_dummy_big(Config)  when is_list(Config) -> 
    {ok, Result} = run_test(httpd_lib_client, "1M_file", Config),
    notify(Result, Config, "erl_1M_file"). 

wget_small(Config) when is_list(Config) -> 
    {ok, Result} = run_test(wget_client, "1k_file", Config),
    notify(Result, Config, "wget_1k_file"). 

wget_big(Config)  when is_list(Config) -> 
    {ok, Result} = run_test(wget_client, "1M_file", Config),
    notify(Result, Config, "wget_1M_file"). 

httpc_small(Config) when is_list(Config) -> 
    {ok, Result} = run_test(httpc_client, "1k_file", Config),
    notify(Result, Config, "httpc_1k_file"). 

httpc_big(Config)  when is_list(Config) -> 
    {ok, Result} = run_test(httpc_client, "1M_file", Config),
    notify(Result, Config, "httpc_1M_file"). 

%%--------------------------------------------------------------------
%% Internal functions ------------------------------------------------
%%--------------------------------------------------------------------

%%--------------------------------------------------------------------
%% Report benchmark results  ------------------------------------------------
%%--------------------------------------------------------------------

notify({TestPerSec, _MBps}, Config, Suffix) ->
    Name = lists:concat([?config(protocol,Config), " ", 
			 server_name(Config, [dummy_pid, httpd_pid, nginx_port]), 
			 "", Suffix]),
    ct:comment("~p tps", [TestPerSec]),
    ct_event:notify(#event{name = benchmark_data,
			   data=[{value, TestPerSec},
				 {suite, ?MODULE},
				 {name, Name}]}),
			 ok.
%%--------------------------------------------------------------------
%% Setup erlang nodes  ------------------------------------------------
%%--------------------------------------------------------------------

server_name(Config, [Server | Rest]) ->
    case proplists:get_value(Server, Config) of
	undefined ->
	    server_name(Config, Rest);
	_ ->
	    server_name(Server)
    end.

server_name(httpd_pid) ->   
   "inets";
server_name(nginx_port) -> 
    "nginx";
server_name(dummy_pid) ->
    "erlang".

setup(_Config, nonode@nohost) ->
    exit(dist_not_enabled);
setup(_Config, _LocalNode) ->
    Host = case os:getenv(?remote_host) of
	       false ->
		   {ok, This} = inet:gethostname(),
		   This;
	       RemHost ->
		   RemHost
	   end,
    Node = list_to_atom("inets_perf_server@" ++ Host),
    SlaveArgs = case init:get_argument(pa) of
	       {ok, PaPaths} ->
		   lists:append([" -pa " ++ P || [P] <- PaPaths]);
	       _ -> []
	   end,
    Prog =
	case os:find_executable("erl") of
	    false -> "erl";
	    P -> P
	end,
    case net_adm:ping(Node) of
	pong -> ok;
	pang ->
	    {ok, Node} = slave:start(Host, inets_perf_server, SlaveArgs, no_link, Prog)
    end,
    Path = code:get_path(),
    true = rpc:call(Node, code, set_path, [Path]),
    [ensure_started(Node, App) || App <- [asn1, crypto, public_key, ssl, inets]],
    [ensure_started(node(), App) || App <- [asn1, crypto, public_key, ssl, inets]],
    (Node =:= node()) andalso restrict_schedulers(client),
    {Node, Host}.

ensure_started(Node, App) ->
     ok = rpc:call(Node, application, ensure_started, [App]).


restrict_schedulers(Type) ->
    %% We expect this to run on 8 core machine
    Extra0 = 1,
    Extra =  if (Type =:= server) -> -Extra0; true -> Extra0 end,
    Scheds = erlang:system_info(schedulers),
    erlang:system_flag(schedulers_online, (Scheds div 2) + Extra).

%%--------------------------------------------------------------------
%% Setup TLS input files  ------------------------------------------------
%%--------------------------------------------------------------------

init_ssl(Config) ->
    DDir = ?config(data_dir, Config),
    PDir = ?config(priv_dir, Config),
    {ok, _} = make_certs:all(DDir,
			     PDir).
cert_opts(Config) ->
    ClientCaCertFile = filename:join([?config(priv_dir, Config), 
				      "client", "cacerts.pem"]),
    ClientCertFile = filename:join([?config(priv_dir, Config), 
				    "client", "cert.pem"]),
    ServerCaCertFile = filename:join([?config(priv_dir, Config), 
				      "server", "cacerts.pem"]),
    ServerCertFile = filename:join([?config(priv_dir, Config), 
				    "server", "cert.pem"]),
    ServerKeyFile = filename:join([?config(priv_dir, Config), 
			     "server", "key.pem"]),
    ClientKeyFile = filename:join([?config(priv_dir, Config), 
				   "client", "key.pem"]),
    [{server_verification_opts, [{reuseaddr, true}, 
				 {cacertfile, ServerCaCertFile},
				 {ciphers, ["ECDHE-RSA-AES256-GCM-SHA384"]},
				 {certfile, ServerCertFile}, {keyfile, ServerKeyFile}]},
     {client_verification_opts, [
				 %%{verify, verify_peer},
				 {cacertfile, ClientCaCertFile}, 
				 {certfile, ClientCertFile},  
				 {keyfile, ClientKeyFile}]}]. 

%%--------------------------------------------------------------------
%% Run clients  ------------------------------------------------
%%--------------------------------------------------------------------

run_test(Client, File, Config) -> 
    Parent = self(),
    Pid = spawn(fun() ->
			receive
			    go -> 
				Parent ! {self(),
					  do_runs(Client, [{file, File} | Config])}
			end
		end),
    Pid ! go,
    receive
	{Pid,{{tps, Tps}, {mbps, MBps}}} ->
	    ct:pal("Tps: ~p  Bps~p", [Tps, MBps]),
	    {ok, {Tps, MBps}}
    end.

do_runs(Client, Config) ->
    N = ?config(iter, Config),
    DataDir = ?config(data_dir, Config),
    File = ?config(file, Config),
    Name = filename:join(DataDir, File), 
    Args = ?MODULE:Client(Config),
    ?MODULE:Client({init, Args}),
    Run = 
	fun() ->
		ok = ?MODULE:Client(Args, N)	
	end,
    {ok, Info} = file:read_file_info(Name, []),
    Length = Info#file_info.size,
    {TimeInMicro, _} = timer:tc(Run),
    ReqPerSecond = (1000000 * N) div TimeInMicro,
    BytesPerSecond = (1000000 * N * Length) div TimeInMicro,
    {{tps, ReqPerSecond}, {mbps, BytesPerSecond}}.


httpc_client({init, [_, Profile, URL, Headers, HTTPOpts]}) ->
     %% Make sure pipelining feature will kick in when appropriate. 
    {ok, {{_ ,200, "OK"}, _,_}} = httpc:request(get,{URL, Headers}, HTTPOpts, 
						[{body_format, binary}, 
						 {socket_opts, [{nodelay, true}]}], Profile),
    ct:sleep(1000);
httpc_client(Config) ->
    File = ?config(file, Config),
    Protocol = ?config(protocol, Config),
    Profile = ?config(profile, Config),
    URL = (?config(urlfun,Config))(File),
    Headers =  ?config(http_headers, Config),
    HTTPOpts = ?config(http_opts, Config),
    [Protocol, Profile, URL, Headers, HTTPOpts].
httpc_client(_,0) ->
    ok;
httpc_client([Protocol, Profile, URL, Headers, HTTPOpts], N) ->
    {ok, {{_ ,200,"OK"}, _,_}} = httpc:request(get,{URL, Headers}, HTTPOpts, [{body_format, binary},
									     {socket_opts, [{nodelay, true}]}], Profile),
    httpc_client([Protocol, Profile, URL, Headers, HTTPOpts], N-1).

httpd_lib_client({init, [_, Type, Version, Request, Host, Port, Opts]}) ->
    ok = httpd_test_lib:verify_request(Type, Host, 
     				       Port,  
     				       Opts, node(),
     				       Request,
     				       [{statuscode, 200},
     					{version, Version}], infinity),
    ct:sleep(1000);
httpd_lib_client(Config) ->
    File = ?config(file, Config),
    KeepAlive = ?config(keep_alive, Config),
    Host = ?config(server_host, Config),
    Port = ?config(port, Config),
    ReuseSession = ?config(reuse_sessions, Config),
    {Type, Opts} = 
	case ?config(protocol, Config) of
	    "http" ->
		{ip_comm, [{active, true}, {mode, binary},{nodelay, true}]};
	    "https" ->	
		SSLOpts =  proplists:get_value(client_verification_opts, cert_opts(Config)),
		{ssl, [{active, true}, {mode, binary}, {nodelay, true},  
		       {reuse_sessions, ReuseSession} | SSLOpts]}
		    
	end,
    Version = ?config(http_version, Config),
    Request = case KeepAlive of
		  true ->
		      http_request("GET /" ++ File ++ " ", Version, Host, {"connection:keep-alive\r\n", ""});
		  false ->
		      http_request("GET /" ++ File ++ " ", Version, Host)
	      end,
    
    Args = [KeepAlive, Type, Version, Request, Host, Port, Opts],
    httpd_lib_client(Args, 1),
    Args.

httpd_lib_client(_, 0) ->
    ok;
httpd_lib_client([true, Type, Version, Request, Host, Port, Opts], N) ->
    ok = httpd_test_lib:verify_request_N(Type, Host, 
					 Port,  
					 Opts, node(),
					 Request,
					 [{statuscode, 200},
					  {version, Version}], infinity, N);
httpd_lib_client([false, Type, Version, Request, Host, Port, Opts] = List, N) ->
    ok = httpd_test_lib:verify_request(Type, Host, 
				       Port,  
				       Opts, node(),
				       Request,
				       [{statuscode, 200},
					{version, Version}], infinity),
    httpd_lib_client(List, N-1).

wget_client({init,_}) ->
    ok;
wget_client(Config) ->
    File = ?config(file, Config),
    URL = (?config(urlfun,Config))(File),
    KeepAlive = ?config(keep_alive, Config),
    PrivDir = ?config(priv_dir, Config),
    Protocol = ?config(protocol, Config),
    Iter = ?config(iter, Config),
    FileName = filename:join(PrivDir, "wget_req"),
    ProtocolOpts = case Protocol of
		    "http" ->
			   [];
		       "https" ->
			   proplists:get_value(client_verification_opts, cert_opts(Config))
		   end,
    wget_req_file(FileName,URL,Iter),
    [KeepAlive, FileName, URL, Protocol, ProtocolOpts, Iter].
wget_client([KeepAlive, WgetFile, _URL, Protocol, ProtocolOpts, _], _) ->
    process_flag(trap_exit, true),
    Cmd = wget_N(KeepAlive, WgetFile, Protocol, ProtocolOpts),
    %%ct:pal("Wget cmd: ~p", [Cmd]),
    Port = open_port({spawn, Cmd}, [stderr_to_stdout]), 
    wait_for_wget(Port).


%%--------------------------------------------------------------------
%% Start/stop servers  ------------------------------------------------
%%--------------------------------------------------------------------
start_web_server(Group, Config) when Group == http_dummy;
				     Group == http_dummy_keep_alive ->
    start_dummy("http", Config);

start_web_server(Group, Config) when Group == https_dummy;
				     Group == https_dummy_keep_alive ->
    start_dummy("https", Config);

start_web_server(Group, Config) when Group == http_inets;
				     Group == http_inets_keep_alive ->
    start_inets("http", [], Config);
    
start_web_server(Group, Config) when Group == https_inets;
				     Group == https_inets_keep_alive ->
    Opts = proplists:get_value(server_verification_opts, cert_opts(Config)),
    ReuseSessions = ?config(reuse_sessions, Config),
    SSLConfHttpd = [{socket_type, {essl,
				   [{nodelay, true}, {reuse_sessions, ReuseSessions} | Opts]}}],
    start_inets("https", SSLConfHttpd, Config);

start_web_server(Group, Config)  when Group == http_nginx;
				      Group == http_nginx_keep_alive ->
    case os:find_executable("nginx") of
	false ->
	    {skip, "nginx not found"};
	_ ->
	    start_nginx("http",  Config)
    end;

start_web_server(Group, Config)  when Group == https_nginx;
				      Group == https_nginx_keep_alive ->
     case os:find_executable("nginx") of
	false ->
	    {skip, "nginx not found"};
	 _ ->
	     start_nginx("https",  cert_opts(Config) ++ Config)  
     end.
   
start_inets(Protocol, ConfHttpd, Config) ->
    PrivDir = ?config(priv_dir, Config),
    DataDir = ?config(data_dir, Config),
    Node = ?config(server_node, Config),
    Host = ?config(server_host, Config),    
    HTTPVersion = ?config(http_version, Config),    
    Conf = [httpd, [{port,0},
		    {http_version, HTTPVersion},
		    {ipfamily, inet},
		    {server_name, "inets_test"},
		    {server_root, PrivDir}, 
		    {document_root, DataDir},
		    {keep_alive, ?config(keep_alive, Config)},
		    {keep_alive_timeout, 360}
		    | ConfHttpd]],
    {ok, Pid} = rpc:call(Node, inets, start, Conf),
    Port = proplists:get_value(port,  rpc:call(Node, httpd, info, [Pid])),
    F = fun(File) -> 
		lists:concat([Protocol,"://",Host,":",Port,"/",File]) 
	end,
    [{httpd_pid,Pid},{urlfun,F},{protocol,Protocol},{port,Port} | Config].

start_dummy("http"= Protocol, Config) ->
    HTTPVersion = ?config(http_version, Config),    
    Node = ?config(server_node, Config),
    %%DataDir= ?config(data_dir, Config),
    Host = ?config(server_host, Config),
    Conf = [
	    %%{big, filename:join(DataDir, "1M_file")},
	    %%{small, filename:join(DataDir, "1k_file")},
	    {big, {gen,  crypto:strong_rand_bytes(1000000)}},
	    {small, {gen,  crypto:strong_rand_bytes(1000)}},
	    {http_version, HTTPVersion},
	    {keep_alive,  ?config(keep_alive, Config)}
	   ],
    {Pid, Port} = rpc:call(Node, http_test_lib, dummy_server, [ip_comm, inet, [{content_cb, ?MODULE}, {conf, Conf}]]),
    F = fun(File) -> 
		lists:concat([Protocol,"://",Host,":",Port,"/",File]) 
	end,
    [{dummy_pid,Pid},{urlfun,F},{protocol, Protocol},{port,Port} | Config];

start_dummy("https" = Protocol, Config) ->
    HTTPVersion = ?config(http_version, Config),    
    Node = ?config(server_node, Config),
    %% DataDir= ?config(data_dir, Config),
    Host = ?config(server_host, Config),
    SSLOpts =  proplists:get_value(server_verification_opts, cert_opts(Config)),
    Opts = [{active, true}, {nodelay, true}, {reuseaddr, true} | SSLOpts],
    Conf = [%%{big, filename:join(DataDir, "1M_file")},
	    %%{small, filename:join(DataDir, "1k_file")},
	    {big, {gen, crypto:strong_rand_bytes(1000000)}},
	    {small, {gen, crypto:strong_rand_bytes(1000)}},
	    {http_version, HTTPVersion},
	    {keep_alive, ?config(keep_alive, Config)}
	   ],
    {Pid, Port} = rpc:call(Node, http_test_lib, dummy_server,
			   [ssl, inet, [{ssl, Opts}, {content_cb, ?MODULE}, {conf, Conf}]]),
    F = fun(File) -> 
		lists:concat([Protocol,"://",Host,":",Port,"/",File]) 
	end,
    [{dummy_pid,Pid},{urlfun,F},{protocol,Protocol},{port,Port} | Config].

start_nginx(Protocol, Config) ->
    PrivDir = ?config(priv_dir, Config),
    DataDir = ?config(data_dir, Config),
    Host = ?config(server_host, Config),    
    Port = inet_port(node()),
    
    ConfFile = filename:join(PrivDir, "nginx.conf"),
    nginx_conf(ConfFile, [{port, Port}, {protocol, Protocol} | Config]),
    Cmd = "nginx -c " ++ ConfFile, 
    NginxPort =  open_port({spawn, Cmd}, [{cd, DataDir}, stderr_to_stdout]), 

    F = fun(File) -> 
 		lists:concat([Protocol,"://",Host,":",Port,"/",File]) 
	end,
    
    wait_for_nginx_up(Host, Port),
   
    [{port, Port},{nginx_port, NginxPort},{urlfun,F},{protocol, Protocol} | Config ].

stop_nginx(Config)->
    PrivDir = ?config(priv_dir, Config),    
    {ok, Bin} = file:read_file(filename:join(PrivDir, "nginx.pid")),
    Pid = string:strip(binary_to_list(Bin), right, $\n),
    Cmd = "kill " ++ Pid,
    os:cmd(Cmd).
    
stop_web_server(Group, Config) when  Group == http_inets;
				     Group == http_inets_keep_alive;
				     Group == https_inets;
				     Group == https_inets_keep_alive -> 
    ServerNode = ?config(server_node, Config),
    rpc:call(ServerNode, inets, stop, [httpd, ?config(httpd_pid, Config)]);
stop_web_server(Group, Config) when  Group == http_dummy;
				     Group == http_dummy_keep_alive;
				     Group == https_dummy;
				     Group == https_dummy_keep_alive -> 
    stop_dummy_server(Config);
stop_web_server(Group, Config) when  Group == http_nginx;
				     Group == http_nginx_keep_alive;
				     Group == https_nginx;
				     Group == https_nginx_keep_alive -> 
    stop_nginx(Config).

stop_dummy_server(Config) ->    
      case ?config(dummy_pid, Config) of
	  Pid when is_pid(Pid) ->
	      exit(Pid, kill);
	  _ ->
	      ok
      end.

%%--------------------------------------------------------------------
%% Misc  ------------------------------------------------
%%--------------------------------------------------------------------
http_request(Request, "HTTP/1.1" = Version, Host, {Headers, Body}) ->
    Request ++ Version ++ "\r\nhost:" ++ Host ++ "\r\n" ++ Headers ++ "\r\n" ++ Body;
http_request(Request, Version, _, {Headers, Body}) ->
    Request ++ Version ++ "\r\n" ++ Headers  ++ "\r\n" ++ Body.

http_request(Request, "HTTP/1.1" = Version, Host) ->
    Request ++ Version ++ "\r\nhost:" ++ Host  ++ "\r\n\r\n";
http_request(Request, Version, _) ->
    Request ++ Version ++ "\r\n\r\n".

http_version(_) ->
    "HTTP/1.1".

inet_port(Node) ->
    {Port, Socket} = do_inet_port(Node),
     rpc:call(Node, gen_tcp, close, [Socket]),
     Port.

do_inet_port(Node) ->
    {ok, Socket} = rpc:call(Node, gen_tcp, listen, [0, [{reuseaddr, true}]]),
    {ok, Port} = rpc:call(Node, inet, port, [Socket]),
    {Port, Socket}.
 
%%--------------------------------------------------------------------
%% Dummy server callbacks  ------------------------------------------------
%%--------------------------------------------------------------------

handle_request(CB, S, "/1M_file" ++ _, Opts) ->
    Name = proplists:get_value(big, Opts),
    KeepAlive = proplists:get_value(keep_alive, Opts),
    do_handle_request(CB, S, Name, Opts, KeepAlive);
handle_request(CB, S, "/1k_file" ++ _, Opts) ->
    Name = proplists:get_value(small, Opts),
    KeepAlive = proplists:get_value(keep_alive, Opts),
    do_handle_request(CB, S, Name, Opts, KeepAlive).

do_handle_request(CB, S, Name, Opts, KeepAlive) when is_list(Name) ->
    Version = proplists:get_value(http_version, Opts),
    {ok, Fdesc} = file:open(Name, [read, binary]),
    {ok, Info} = file:read_file_info(Name, []),
    Length = Info#file_info.size,
    Response = response_status_line_and_headers(Version, "Content-Length:" 
						++ integer_to_list(Length) ++ ?CRLF, keep_alive(KeepAlive)), 
    CB:send(S, Response),
    send_file(CB, S, Fdesc);
do_handle_request(CB, S, {gen, Data}, Opts, KeepAlive) ->
    Version = proplists:get_value(http_version, Opts),
    Length = size(Data),
    Response = response_status_line_and_headers(Version, "Content-Length:" 
						++ integer_to_list(Length) ++ ?CRLF, keep_alive(KeepAlive)), 
    CB:send(S, Response),
    send_file(CB, S, {gen, Data}).
    
send_file(CB, S, {gen, Data})  ->
    CB:send(S, Data);
    %% ChunkSize = 64*1024,
    %% case size(Data) of
    %% 	N when N > ChunkSize ->
    %% 	    <<Chunk:N/binary, Rest/binary>> = Data,
    %% 	    %%{Chunk, Rest} = lists:split(N, Data),
    %% 	    CB:send(S, Chunk),
    %% 	    send_file(CB, S, {gen, Rest});
    %% 	_ ->
    %% 	    CB:send(S, Data)
    %% end; 

send_file(CB, S, FileDesc) ->
    case file:read(FileDesc, 64*1024) of
	{ok, Chunk} ->
	    CB:send(S, Chunk),
	    send_file(CB, S, FileDesc);	
	eof ->
	    file:close(FileDesc),
	    ok
    end.

response_status_line_and_headers(Version, Headers,  ConnectionHeader) -> 
    StatusLine = [Version, " ", "200 OK", ?CRLF],
    [StatusLine, Headers, ConnectionHeader, ?CRLF].

keep_alive(true)->
    "Connection:keep-alive\r\n";
keep_alive(false) ->
    "Connection:close\r\n".

handle_http_msg({_Method, RelUri, _, {_, _Headers}, _Body}, Socket, Conf) ->
    handle_request(connect_cb(Socket), Socket, RelUri, Conf),
    case proplists:get_value(keep_alive, Conf) of
	true ->
	    <<>>;
	false ->
	    stop
    end.
    
connect_cb({sslsocket, _, _}) ->
    ssl;
connect_cb(_) ->
    gen_tcp.

%%--------------------------------------------------------------------
%% Setup wget  ------------------------------------------------
%%--------------------------------------------------------------------
wget_req_file(FileName, Url, Iter) ->
    {ok, File} = file:open(FileName, [write]),
    write_urls(File, Url, Iter).

write_urls(File, Url, 1) ->
    file:write(File, Url), 
    file:close(File);
write_urls(File, Url, N) ->
    file:write(File, Url), 
    file:write(File, "\n"),
    write_urls(File, Url, N-1).
    
wait_for_wget(Port) ->
    receive 
	{Port, {data, _Data}} when is_port(Port) ->
	    wait_for_wget(Port);
	{Port, closed} -> 
	    ok;
	{'EXIT', Port, _Reason} ->
	    ok
    end.

wget_N(KeepAlive, WegetFile, "http", _ProtocolOpts) ->
    "wget -i " ++ WegetFile ++ " " ++ wget_keep_alive(KeepAlive) ++ 
	" --no-cache --timeout=120" ;
wget_N(KeepAlive, WegetFile, "https", ProtocolOpts) ->
    
    "wget -i " ++ WegetFile ++ " " ++ wget_keep_alive(KeepAlive) 
	++ wget_cert(ProtocolOpts) ++ wget_key(ProtocolOpts)
	++ wget_cacert(ProtocolOpts) ++ 
	" --no-cache --timeout=120".

wget(KeepAlive, URL, "http", _ProtocolOpts) ->
    "wget " ++ URL ++ " " ++ wget_keep_alive(KeepAlive) ++ 
	" --no-cache --timeout=120" ;
wget(KeepAlive, URL, "https", ProtocolOpts) ->
    
    "wget " ++ URL ++ " " ++ wget_keep_alive(KeepAlive) 
	++ wget_cert(ProtocolOpts) ++ wget_key(ProtocolOpts)
	++ wget_cacert(ProtocolOpts) ++ 
	" --no-cache --timeout=120".

wget_keep_alive(true)->
    "";
wget_keep_alive(false) ->
   "--no-http-keep-alive ".

wget_cacert(ProtocolOpts) ->
    "--ca-certificate=" ++ proplists:get_value(cacertfile, ProtocolOpts) ++ " ".

wget_cert(ProtocolOpts) ->
    "--certificate=" ++ proplists:get_value(certfile, ProtocolOpts) ++ " ".

wget_key(ProtocolOpts) ->
    "--private-key=" ++ proplists:get_value(keyfile, ProtocolOpts) ++ " ".

%%--------------------------------------------------------------------
%% Setup nginx  ------------------------------------------------
%%--------------------------------------------------------------------
nginx_conf(ConfFile, Config)->
    Protocol = ?config(protocol, Config),
    file:write_file(ConfFile,
		    [format_nginx_conf(nginx_global(Config)),
		     format_nginx_conf(nginx_events(Config)),
		     format_nginx_conf(nginx_http(Protocol, Config))]).
       
format_nginx_conf(Directives) ->
    lists:map(fun({Key, Value}) ->
			  io_lib:format("~s ~s;\n", [Key, Value]);
		     (Str) ->
			  Str    
		  end, Directives).


nginx_global(Config) ->
    PrivDir = ?config(priv_dir, Config),
    [{"pid", filename:join(PrivDir, "nginx.pid")},
     {"error_log",  filename:join(PrivDir, "nginx.pid")},
     {"worker_processes", "1"}].

nginx_events(_Config) ->
    ["events {\n",
     {"worker_connections",  "1024"},
     "\n}"
    ].

nginx_http("http", Config) ->
    PrivDir = ?config(priv_dir, Config),
    DataDir = ?config(data_dir, Config),
    Port = ?config(port, Config),
    ["http {\n" |
     nginx_defaults(PrivDir) ++
	 [" server {",
	  {root,                DataDir}, 
	  {listen,              integer_to_list(Port)},
	  " location / {\n  try_files $uri $uri/ /index.html;\n}"
	  "}\n", "}\n"
	 ]
    ];
	
nginx_http("https", Config) ->
    PrivDir = ?config(priv_dir, Config),
    DataDir = ?config(data_dir, Config),
    Port = ?config(port, Config),
    SSLOpts = ?config(server_verification_opts, Config),
    Ciphers = proplists:get_value(ciphers, SSLOpts),
    ReuseSession = ?config(reuse_sessions, Config),
    ["http {" |
     nginx_defaults(PrivDir) ++
	 [" server {",
	  {"root",                DataDir}, 
	  {"listen",              integer_to_list(Port) ++ " ssl"},
	  {"ssl_certificate",     ?config(certfile, SSLOpts)},
	  {"ssl_certificate_key", ?config(keyfile, SSLOpts)},
	  {"ssl_protocols",       "TLSv1 TLSv1.1 TLSv1.2"},
	  {"ssl_ciphers",         Ciphers}, 
	  {"ssl_session_cache",    nginx_reuse_session(ReuseSession)},
	  " location / {\n  try_files $uri $uri/ /index.html;\n}"
	  "}\n", "}\n"
	 ]
    ].
	
nginx_defaults(PrivDir) ->
    [
     %% Set temp and cache file options that will otherwise default to
     %% restricted locations accessible only to root.
     {"client_body_temp_path", filename:join(PrivDir, "client_body")},
     {"fastcgi_temp_path",   filename:join(PrivDir, "fastcgi_temp")}, 
     {"proxy_temp_path", filename:join(PrivDir, "proxy_temp")},
     {"scgi_temp_path", filename:join(PrivDir, "scgi_temp")},
     {"uwsgi_temp_path", filename:join(PrivDir, "uwsgi_temp_path")},
     {"access_log",  filename:join(PrivDir, "access.log")},
     {"error_log",   filename:join(PrivDir, "error.log")},
     %% Standard options
     {"sendfile", "on"},
     {"tcp_nopush", "on"},
     {"tcp_nodelay", "on"},
     {"keepalive_timeout",  "360"},
     {"types_hash_max_size", "2048"},
     {"include", "/etc/nginx/mime.types"},
     {"default_type", "application/octet-stream"}
    ].

nginx_reuse_session(true) ->
    "on";
nginx_reuse_session(false) ->
    "off".

wait_for_nginx_up(Host, Port) ->
    case gen_tcp:connect(Host, Port, []) of
	{ok, Socket} ->
	    gen_tcp:close(Socket);
	_  ->
	    ct:sleep(100),
	    wait_for_nginx_up(Host, Port)
    end.