acceptor_SUITE.erl 59 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619
  1. %% Copyright (c) 2011-2018, Loïc Hoguin <essen@ninenines.eu>
  2. %%
  3. %% Permission to use, copy, modify, and/or distribute this software for any
  4. %% purpose with or without fee is hereby granted, provided that the above
  5. %% copyright notice and this permission notice appear in all copies.
  6. %%
  7. %% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  8. %% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  9. %% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  10. %% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  11. %% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  12. %% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  13. %% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  14. -module(acceptor_SUITE).
  15. -compile(export_all).
  16. -compile(nowarn_export_all).
  17. -dialyzer({nowarn_function, misc_wait_for_connections/1}).
  18. %% @todo Remove when specs in ssl are updated to accept local addresses.
  19. -dialyzer({nowarn_function, do_ssl_local_echo/0}).
  20. -import(ct_helper, [doc/1]).
  21. -import(ct_helper, [name/0]).
  22. %% ct.
  23. all() ->
  24. [{group, tcp}, {group, ssl}, {group, misc}, {group, supervisor}].
  25. groups() ->
  26. [{tcp, [
  27. tcp_active_echo,
  28. tcp_active_n_echo,
  29. tcp_echo,
  30. tcp_local_echo,
  31. tcp_graceful,
  32. tcp_inherit_options,
  33. tcp_max_connections,
  34. tcp_max_connections_and_beyond,
  35. tcp_max_connections_infinity,
  36. tcp_remove_connections,
  37. tcp_remove_connections_acceptor_wakeup,
  38. tcp_set_max_connections,
  39. tcp_set_max_connections_clean,
  40. tcp_getopts_capability,
  41. tcp_getstat_capability,
  42. tcp_upgrade,
  43. tcp_10_acceptors_10_listen_sockets,
  44. tcp_many_listen_sockets_no_reuseport,
  45. tcp_error_eaddrinuse,
  46. tcp_error_eacces
  47. ]}, {ssl, [
  48. ssl_accept_error,
  49. ssl_active_echo,
  50. ssl_active_n_echo,
  51. ssl_echo,
  52. ssl_local_echo,
  53. ssl_graceful,
  54. ssl_handshake,
  55. ssl_sni_echo,
  56. ssl_sni_fail,
  57. ssl_upgrade_from_tcp,
  58. ssl_getopts_capability,
  59. ssl_getstat_capability,
  60. ssl_10_acceptors_10_listen_sockets,
  61. ssl_many_listen_sockets_no_reuseport,
  62. ssl_error_eaddrinuse,
  63. ssl_error_no_cert,
  64. ssl_error_eacces
  65. ]}, {misc, [
  66. misc_bad_transport,
  67. misc_bad_transport_options,
  68. misc_repeated_remove,
  69. misc_info,
  70. misc_info_embedded,
  71. misc_opts_logger,
  72. misc_set_transport_options,
  73. misc_wait_for_connections,
  74. misc_multiple_ip_local_socket_opts
  75. ]}, {supervisor, [
  76. connection_type_supervisor,
  77. connection_type_supervisor_separate_from_connection,
  78. supervisor_10_acceptors_1_conns_sup,
  79. supervisor_9_acceptors_4_conns_sups,
  80. supervisor_10_acceptors_10_conns_sups,
  81. supervisor_1_acceptor_10_conns_sups,
  82. supervisor_changed_options_restart,
  83. supervisor_clean_child_restart,
  84. supervisor_clean_restart,
  85. supervisor_conns_alive,
  86. supervisor_embedded_ranch_server_crash,
  87. supervisor_protocol_start_link_crash,
  88. supervisor_server_recover_state,
  89. supervisor_unexpected_message
  90. ]}].
  91. %% misc.
  92. misc_bad_transport(_) ->
  93. doc("Reject invalid transport modules."),
  94. {error, {bad_transport, invalid_transport}} = ranch:start_listener(misc_bad_transport,
  95. invalid_transport, #{},
  96. echo_protocol, []),
  97. ok.
  98. misc_bad_transport_options(_) ->
  99. doc("Ignore invalid transport options."),
  100. {ok, _} = ranch:start_listener(misc_bad_transport_options,
  101. ranch_tcp, [binary, {packet, 4}, <<"garbage">>, raw, backlog],
  102. echo_protocol, []),
  103. ok.
  104. misc_info(_) ->
  105. doc("Information about listeners."),
  106. %% Open a listener with a few connections.
  107. {ok, Pid1} = ranch:start_listener({misc_info, tcp},
  108. ranch_tcp, #{num_acceptors => 1},
  109. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  110. Port1 = ranch:get_port({misc_info, tcp}),
  111. %% Open a few more listeners with different arguments.
  112. {ok, Pid2} = ranch:start_listener({misc_info, act},
  113. ranch_tcp, #{num_acceptors => 2},
  114. active_echo_protocol, {}),
  115. Port2 = ranch:get_port({misc_info, act}),
  116. ranch:set_max_connections({misc_info, act}, infinity),
  117. Opts = ct_helper:get_certs_from_ets(),
  118. {ok, Pid3} = ranch:start_listener({misc_info, ssl},
  119. ranch_ssl, #{num_acceptors => 3, socket_opts => Opts},
  120. echo_protocol, [{}]),
  121. Port3 = ranch:get_port({misc_info, ssl}),
  122. %% Open 5 connections, 3 removed from the count.
  123. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  124. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  125. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  126. receive after 250 -> ok end,
  127. ranch:set_protocol_options({misc_info, tcp}, [{remove, false, 2500}]),
  128. receive after 250 -> ok end,
  129. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  130. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  131. receive after 250 -> ok end,
  132. %% Confirm the info returned by Ranch is correct.
  133. #{
  134. {misc_info, act} := #{
  135. pid := Pid2,
  136. port := Port2,
  137. max_connections := infinity, %% Option was modified.
  138. active_connections := 0,
  139. all_connections := 0,
  140. transport := ranch_tcp,
  141. transport_options := #{num_acceptors := 2},
  142. protocol := active_echo_protocol,
  143. protocol_options := {}
  144. },
  145. {misc_info, ssl} := #{
  146. pid := Pid3,
  147. port := Port3,
  148. max_connections := 1024,
  149. active_connections := 0,
  150. all_connections := 0,
  151. transport := ranch_ssl,
  152. transport_options := #{num_acceptors := 3, socket_opts := Opts},
  153. protocol := echo_protocol,
  154. protocol_options := [{}]
  155. },
  156. {misc_info, tcp} := #{
  157. pid := Pid1,
  158. port := Port1,
  159. max_connections := 1024,
  160. active_connections := 2,
  161. all_connections := 5,
  162. transport := ranch_tcp,
  163. transport_options := #{num_acceptors := 1},
  164. protocol := remove_conn_and_wait_protocol,
  165. protocol_options := [{remove, false, 2500}] %% Option was modified.
  166. }
  167. } = ranch:info(),
  168. %% Get acceptors.
  169. [_] = ranch:procs({misc_info, tcp}, acceptors),
  170. [_, _] = ranch:procs({misc_info, act}, acceptors),
  171. [_, _, _] = ranch:procs({misc_info, ssl}, acceptors),
  172. %% Get connections.
  173. [_, _, _, _, _] = ranch:procs({misc_info, tcp}, connections),
  174. [] = ranch:procs({misc_info, act}, connections),
  175. [] = ranch:procs({misc_info, ssl}, connections),
  176. ok.
  177. misc_info_embedded(_) ->
  178. doc("Information about listeners in embedded mode."),
  179. {ok, SupPid} = embedded_sup:start_link(),
  180. %% Open a listener with a few connections.
  181. {ok, EmbeddedSupPid1} = embedded_sup:start_listener(SupPid, {misc_info_embedded, tcp},
  182. ranch_tcp, #{num_acceptors => 1},
  183. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  184. {_, Pid1, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, tcp}}, 1,
  185. supervisor:which_children(EmbeddedSupPid1)),
  186. Port1 = ranch:get_port({misc_info_embedded, tcp}),
  187. %% Open a few more listeners with different arguments.
  188. {ok, EmbeddedSupPid2} = embedded_sup:start_listener(SupPid, {misc_info_embedded, act},
  189. ranch_tcp, #{num_acceptors => 2},
  190. active_echo_protocol, {}),
  191. {_, Pid2, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, act}}, 1,
  192. supervisor:which_children(EmbeddedSupPid2)),
  193. Port2 = ranch:get_port({misc_info_embedded, act}),
  194. ranch:set_max_connections({misc_info_embedded, act}, infinity),
  195. Opts = ct_helper:get_certs_from_ets(),
  196. {ok, EmbeddedSupPid3} = embedded_sup:start_listener(SupPid, {misc_info_embedded, ssl},
  197. ranch_ssl, #{num_acceptors => 3, socket_opts => Opts},
  198. echo_protocol, [{}]),
  199. {_, Pid3, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, ssl}}, 1,
  200. supervisor:which_children(EmbeddedSupPid3)),
  201. Port3 = ranch:get_port({misc_info_embedded, ssl}),
  202. %% Open 5 connections, 3 removed from the count.
  203. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  204. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  205. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  206. receive after 250 -> ok end,
  207. ranch:set_protocol_options({misc_info_embedded, tcp}, [{remove, false, 2500}]),
  208. receive after 250 -> ok end,
  209. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  210. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  211. receive after 250 -> ok end,
  212. %% Confirm the info returned by Ranch is correct.
  213. #{
  214. {misc_info_embedded, act} := #{
  215. pid := Pid2,
  216. port := Port2,
  217. max_connections := infinity, %% Option was modified.
  218. active_connections := 0,
  219. all_connections := 0,
  220. transport := ranch_tcp,
  221. transport_options := #{num_acceptors := 2},
  222. protocol := active_echo_protocol,
  223. protocol_options := {}
  224. },
  225. {misc_info_embedded, ssl} := #{
  226. pid := Pid3,
  227. port := Port3,
  228. max_connections := 1024,
  229. active_connections := 0,
  230. all_connections := 0,
  231. transport := ranch_ssl,
  232. transport_options := #{num_acceptors := 3, socket_opts := Opts},
  233. protocol := echo_protocol,
  234. protocol_options := [{}]
  235. },
  236. {misc_info_embedded, tcp} := #{
  237. pid := Pid1,
  238. port := Port1,
  239. max_connections := 1024,
  240. active_connections := 2,
  241. all_connections := 5,
  242. transport := ranch_tcp,
  243. transport_options := #{num_acceptors := 1},
  244. protocol := remove_conn_and_wait_protocol,
  245. protocol_options := [{remove, false, 2500}] %% Option was modified.
  246. }
  247. } = ranch:info(),
  248. %% Get acceptors.
  249. [_] = ranch:procs({misc_info_embedded, tcp}, acceptors),
  250. [_, _] = ranch:procs({misc_info_embedded, act}, acceptors),
  251. [_, _, _] = ranch:procs({misc_info_embedded, ssl}, acceptors),
  252. %% Get connections.
  253. [_, _, _, _, _] = ranch:procs({misc_info_embedded, tcp}, connections),
  254. [] = ranch:procs({misc_info_embedded, act}, connections),
  255. [] = ranch:procs({misc_info_embedded, ssl}, connections),
  256. %% Stop embedded tcp listener and ensure it is gone.
  257. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, tcp}),
  258. timer:sleep(500),
  259. false = maps:is_key({misc_info_embedded, tcp}, ranch:info()),
  260. %% Stop embedded act listener and ensure it is gone.
  261. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, act}),
  262. timer:sleep(500),
  263. false = maps:is_key({misc_info_embedded, act}, ranch:info()),
  264. %% Stop embedded ssl listener and ensure it is gone.
  265. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, ssl}),
  266. timer:sleep(500),
  267. false = maps:is_key({misc_info_embedded, ssl}, ranch:info()),
  268. %% Stop embedded supervisor.
  269. embedded_sup:stop(SupPid),
  270. ok.
  271. misc_opts_logger(_) ->
  272. doc("Confirm that messages are sent via the configured logger module."),
  273. register(misc_opts_logger, self()),
  274. {ok, _} = ranch:start_listener(name(),
  275. ranch_tcp, #{logger => ?MODULE, socket_opts => [<<"garbage">>]},
  276. echo_protocol, []),
  277. receive
  278. {warning, "Transport option " ++ _, [<<"garbage">>]} ->
  279. ok
  280. after 1000 ->
  281. error(timeout)
  282. end.
  283. warning(Format, Args) ->
  284. misc_opts_logger ! {warning, Format, Args}.
  285. misc_repeated_remove(_) ->
  286. doc("Ensure repeated removal of connection does not crash the connection supervisor."),
  287. Name = name(),
  288. {ok, _} = ranch:start_listener(Name,
  289. ranch_tcp, #{},
  290. remove_conn_and_wait_protocol, [{remove, 5, 0}]),
  291. Port = ranch:get_port(Name),
  292. ConnsSups = lists:sort(ranch_server:get_connections_sups(Name)),
  293. {ok, _} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  294. timer:sleep(1000),
  295. ConnsSups = lists:sort(ranch_server:get_connections_sups(Name)),
  296. true = lists:all(fun ({_, ConnsSup}) -> erlang:is_process_alive(ConnsSup) end, ConnsSups),
  297. ok = ranch:stop_listener(Name).
  298. misc_set_transport_options(_) ->
  299. doc(""),
  300. Name = name(),
  301. {ok, ListenerSupPid} = ranch:start_listener(Name, ranch_tcp, #{max_connections => 10,
  302. handshake_timeout => 5000, shutdown => 1000, num_acceptors => 1,
  303. socket_opts => [{send_timeout, 5000}]}, echo_protocol, []),
  304. ok = ranch:set_transport_options(Name, #{max_connections => 20, handshake_timeout => 5001,
  305. num_acceptors => 2, shutdown => 1001, socket_opts => [{send_timeout, 5002}]}),
  306. ConnsSups = [ConnsSup || {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  307. _ = [begin
  308. {State, _, _, _} = sys:get_state(ConnsSup),
  309. 20 = element(10, State),
  310. 5001 = element(9, State),
  311. 1001 = element(5, State)
  312. end || ConnsSup <- ConnsSups],
  313. ok = ranch:suspend_listener(Name),
  314. ok = ranch:resume_listener(Name),
  315. 2 = length(ranch:procs(Name, acceptors)),
  316. LSocket = do_get_listener_socket(ListenerSupPid),
  317. {ok, [{send_timeout, 5002}]} = ranch_tcp:getopts(LSocket, [send_timeout]),
  318. ok = ranch:stop_listener(Name).
  319. misc_wait_for_connections(_) ->
  320. doc("Ensure wait for connections works."),
  321. Name = name(),
  322. Self = self(),
  323. %% Ensure invalid arguments are rejected.
  324. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, 'foo', 0) end,
  325. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '==', -1) end,
  326. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '==', 0, -1) end,
  327. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '<', 0) end,
  328. %% Create waiters for increasing number of connections.
  329. Pid1GT = do_create_waiter(Self, Name, '>', 0),
  330. Pid1GE = do_create_waiter(Self, Name, '>=', 1),
  331. Pid1EQ = do_create_waiter(Self, Name, '==', 1),
  332. Pid2GT = do_create_waiter(Self, Name, '>', 1),
  333. Pid2GE = do_create_waiter(Self, Name, '>=', 2),
  334. Pid2EQ = do_create_waiter(Self, Name, '==', 2),
  335. {ok, _} = ranch:start_listener(Name,
  336. ranch_tcp, #{num_acceptors => 1},
  337. echo_protocol, []),
  338. Port = ranch:get_port(Name),
  339. %% Create some connections, ensure that waiters respond.
  340. {ok, Sock1} = gen_tcp:connect("localhost", Port, []),
  341. ok = do_expect_waiter(Pid1GT),
  342. ok = do_expect_waiter(Pid1GE),
  343. ok = do_expect_waiter(Pid1EQ),
  344. ok = do_expect_waiter(undefined),
  345. {ok, Sock2} = gen_tcp:connect("localhost", Port, []),
  346. ok = do_expect_waiter(Pid2GT),
  347. ok = do_expect_waiter(Pid2GE),
  348. ok = do_expect_waiter(Pid2EQ),
  349. ok = do_expect_waiter(undefined),
  350. %% Create waiters for decreasing number of connections.
  351. Pid3LT = do_create_waiter(Self, Name, '<', 2),
  352. Pid3LE = do_create_waiter(Self, Name, '=<', 1),
  353. Pid3EQ = do_create_waiter(Self, Name, '==', 1),
  354. Pid4LT = do_create_waiter(Self, Name, '<', 1),
  355. Pid4LE = do_create_waiter(Self, Name, '=<', 0),
  356. Pid4EQ = do_create_waiter(Self, Name, '==', 0),
  357. %% Close connections, ensure that waiters respond.
  358. ok = gen_tcp:close(Sock1),
  359. ok = do_expect_waiter(Pid3LT),
  360. ok = do_expect_waiter(Pid3LE),
  361. ok = do_expect_waiter(Pid3EQ),
  362. ok = do_expect_waiter(undefined),
  363. ok = gen_tcp:close(Sock2),
  364. ok = do_expect_waiter(Pid4LT),
  365. ok = do_expect_waiter(Pid4LE),
  366. ok = do_expect_waiter(Pid4EQ),
  367. ok = do_expect_waiter(undefined),
  368. ok = ranch:stop_listener(Name),
  369. %% Make sure the listener stopped.
  370. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  371. ok.
  372. do_create_waiter(ReplyTo, Ref, Op, NumConns) ->
  373. spawn(fun () -> ok = ranch:wait_for_connections(Ref, Op, NumConns, 100),
  374. ReplyTo ! {wait_connections, self()} end).
  375. do_expect_waiter(WaiterPid) ->
  376. receive
  377. {wait_connections, _} when WaiterPid=:=undefined ->
  378. error;
  379. {wait_connections, Pid} when Pid=:=WaiterPid ->
  380. ok
  381. after 1000 ->
  382. case WaiterPid of
  383. undefined ->
  384. ok;
  385. _ ->
  386. timeout
  387. end
  388. end.
  389. misc_multiple_ip_local_socket_opts(_) ->
  390. case do_os_supports_local_sockets() of
  391. true ->
  392. do_misc_multiple_ip_local_socket_opts();
  393. false ->
  394. {skip, "No local socket support."}
  395. end.
  396. do_misc_multiple_ip_local_socket_opts() ->
  397. doc("Ensure that a listener uses the expected ip option if multiple are given."),
  398. Name = name(),
  399. SockFile1 = do_tempname(),
  400. SockFile2 = do_tempname(),
  401. Opts = [{ip, {local, SockFile1}}, {ip, {local, SockFile2}}],
  402. {ok, _} = ranch:start_listener(Name, ranch_tcp, #{socket_opts => Opts}, echo_protocol, []),
  403. {local, SockFile2} = ranch:get_addr(Name),
  404. %% Make sure the socket file from the ignored ip option
  405. %% has not been created.
  406. {error, enoent} = file:read_file_info(SockFile1),
  407. ok = ranch:stop_listener(Name),
  408. %% Make sure the socket file from the accepted ip option
  409. %% is removed.
  410. {error, enoent} = file:read_file_info(SockFile2),
  411. ok.
  412. %% ssl.
  413. ssl_accept_error(_) ->
  414. doc("Acceptor must not crash if client disconnects in the middle of SSL handshake."),
  415. Name = name(),
  416. Opts = ct_helper:get_certs_from_ets(),
  417. {ok, ListenerSup} = ranch:start_listener(Name,
  418. ranch_ssl, #{num_acceptors => 1, socket_opts => Opts},
  419. echo_protocol, []),
  420. Port = ranch:get_port(Name),
  421. ListenerSupChildren = supervisor:which_children(ListenerSup),
  422. {_, AcceptorsSup, _, _} = lists:keyfind(ranch_acceptors_sup, 1, ListenerSupChildren),
  423. [{{acceptor, _, _}, AcceptorPid, _, _}] = supervisor:which_children(AcceptorsSup),
  424. true = is_process_alive(AcceptorPid),
  425. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  426. ok = gen_tcp:close(Socket),
  427. receive after 500 -> ok end,
  428. true = is_process_alive(AcceptorPid),
  429. ok = ranch:stop_listener(Name).
  430. ssl_10_acceptors_10_listen_sockets(_) ->
  431. case do_os_supports_reuseport() of
  432. true ->
  433. ok = do_ssl_10_acceptors_10_listen_sockets();
  434. false ->
  435. {skip, "No SO_REUSEPORT support."}
  436. end.
  437. do_ssl_10_acceptors_10_listen_sockets() ->
  438. doc("Ensure that we can use 10 listen sockets across 10 acceptors with SSL."),
  439. Name = name(),
  440. Opts = ct_helper:get_certs_from_ets(),
  441. {ok, ListenerSupPid} = ranch:start_listener(Name,
  442. ranch_ssl, #{
  443. num_acceptors => 10,
  444. num_listen_sockets => 10,
  445. socket_opts => [{raw, 1, 15, <<1:32/native>>}|Opts]},
  446. echo_protocol, []),
  447. 10 = length(do_get_listener_sockets(ListenerSupPid)),
  448. ok = ranch:stop_listener(Name),
  449. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  450. ok.
  451. ssl_many_listen_sockets_no_reuseport(_) ->
  452. case do_os_supports_reuseport() of
  453. true ->
  454. ok = do_ssl_many_listen_sockets_no_reuseport();
  455. false ->
  456. {skip, "No SO_REUSEPORT support."}
  457. end.
  458. do_ssl_many_listen_sockets_no_reuseport() ->
  459. doc("Confirm that ranch:start_listener/5 fails when SO_REUSEPORT is not available with SSL."),
  460. Name = name(),
  461. Opts = ct_helper:get_certs_from_ets(),
  462. {error, eaddrinuse} = ranch:start_listener(Name,
  463. ranch_ssl, #{
  464. num_acceptors => 10,
  465. num_listen_sockets => 10,
  466. socket_opts => [{raw, 1, 15, <<0:32/native>>}|Opts]},
  467. echo_protocol, []),
  468. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  469. ok.
  470. ssl_active_echo(_) ->
  471. doc("Ensure that active mode works with SSL transport."),
  472. Name = name(),
  473. Opts = ct_helper:get_certs_from_ets(),
  474. {ok, _} = ranch:start_listener(Name,
  475. ranch_ssl, Opts,
  476. active_echo_protocol, []),
  477. Port = ranch:get_port(Name),
  478. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  479. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  480. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  481. ok = ranch:stop_listener(Name),
  482. {error, closed} = ssl:recv(Socket, 0, 1000),
  483. %% Make sure the listener stopped.
  484. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  485. ok.
  486. ssl_active_n_echo(_) ->
  487. case application:get_key(ssl, vsn) of
  488. {ok, "9.0"++_} ->
  489. {skip, "No Active N support."};
  490. {ok, "9.1"++_} ->
  491. {skip, "No Active N support."};
  492. {ok, _} ->
  493. do_ssl_active_n_echo()
  494. end.
  495. do_ssl_active_n_echo() ->
  496. doc("Ensure that active N mode works with SSL transport."),
  497. Name = name(),
  498. Opts = ct_helper:get_certs_from_ets(),
  499. {ok, _} = ranch:start_listener(Name,
  500. ranch_ssl, Opts,
  501. batch_echo_protocol, [{batch_size, 3}]),
  502. Port = ranch:get_port(Name),
  503. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  504. ok = ssl:send(Socket, <<"One">>),
  505. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  506. ok = ssl:send(Socket, <<"Two">>),
  507. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  508. ok = ssl:send(Socket, <<"Three">>),
  509. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  510. {ok, <<"OneTwoThree">>} = ssl:recv(Socket, 11, 1000),
  511. ok = ranch:stop_listener(Name),
  512. {error, closed} = ssl:recv(Socket, 0, 1000),
  513. %% Make sure the listener stopped.
  514. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  515. ok.
  516. ssl_echo(_) ->
  517. doc("Ensure that passive mode works with SSL transport."),
  518. Name = name(),
  519. Opts = ct_helper:get_certs_from_ets(),
  520. {ok, _} = ranch:start_listener(Name,
  521. ranch_ssl, Opts,
  522. echo_protocol, []),
  523. Port = ranch:get_port(Name),
  524. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  525. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  526. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  527. ok = ranch:stop_listener(Name),
  528. {error, closed} = ssl:recv(Socket, 0, 1000),
  529. %% Make sure the listener stopped.
  530. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  531. ok.
  532. ssl_handshake(_) ->
  533. doc("Ensure that multiple steps handshake works with SSL transport."),
  534. Name = name(),
  535. {CaCert1, Cert1, Key1} = ct_helper:make_certs(),
  536. {CaCert2, Cert2, Key2} = ct_helper:make_certs(),
  537. Opts1 = [{cert, Cert1}, {key, Key1}, {cacerts, [CaCert1]}, {verify, verify_peer}],
  538. Opts2 = [{cert, Cert2}, {key, Key2}, {cacerts, [CaCert2]}, {verify, verify_peer}],
  539. DefaultOpts = ct_helper:get_certs_from_ets(),
  540. {ok, _} = ranch:start_listener(Name,
  541. ranch_ssl, [{handshake, hello}|DefaultOpts],
  542. handshake_protocol, #{"ranch1" => Opts1, "ranch2" => Opts2}),
  543. Port = ranch:get_port(Name),
  544. {ok, Socket1} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw},
  545. {server_name_indication, "ranch1"}], 5000),
  546. {ok, Cert1} = ssl:peercert(Socket1),
  547. ok = ssl:send(Socket1, <<"SSL Ranch is working!">>),
  548. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket1, 21, 1000),
  549. {ok, Socket2} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw},
  550. {server_name_indication, "ranch2"}], 5000),
  551. {ok, Cert2} = ssl:peercert(Socket2),
  552. ok = ssl:send(Socket2, <<"SSL Ranch is working!">>),
  553. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket2, 21, 1000),
  554. ok = ranch:stop_listener(Name),
  555. {error, closed} = ssl:recv(Socket1, 0, 1000),
  556. {error, closed} = ssl:recv(Socket2, 0, 1000),
  557. %% Make sure the listener stopped.
  558. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  559. ok.
  560. ssl_local_echo(_) ->
  561. case do_os_supports_local_sockets() of
  562. true ->
  563. do_ssl_local_echo();
  564. false ->
  565. {skip, "No local socket support."}
  566. end.
  567. do_ssl_local_echo() ->
  568. doc("Ensure that listening on a local socket works with SSL transport."),
  569. SockFile = do_tempname(),
  570. try
  571. Name = name(),
  572. Opts = ct_helper:get_certs_from_ets(),
  573. {ok, _} = ranch:start_listener(Name,
  574. ranch_ssl, #{socket_opts => [{ip, {local, SockFile}}|Opts]},
  575. echo_protocol, []),
  576. undefined = ranch:get_port(Name),
  577. {ok, Socket} = ssl:connect({local, SockFile}, 0, [binary, {active, false}, {packet, raw}]),
  578. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  579. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  580. ok = ranch:stop_listener(Name),
  581. {error, closed} = ssl:recv(Socket, 0, 1000),
  582. %% Make sure the listener stopped.
  583. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  584. %% Make sure the socket file is removed.
  585. {error, enoent} = file:read_file_info(SockFile),
  586. ok
  587. after
  588. file:delete(SockFile)
  589. end.
  590. ssl_sni_echo(_) ->
  591. doc("Ensure that SNI works with SSL transport."),
  592. Name = name(),
  593. Opts = ct_helper:get_certs_from_ets(),
  594. {ok, _} = ranch:start_listener(Name,
  595. ranch_ssl, [{sni_hosts, [{"localhost", Opts}]}],
  596. echo_protocol, []),
  597. Port = ranch:get_port(Name),
  598. %% We stick to TLS 1.2 because there seems to be a bug in OTP-23.0rc2
  599. %% that leads to a malformed_handshake_data error.
  600. {ok, Socket} = ssl:connect("localhost", Port,
  601. [binary, {active, false}, {packet, raw}, {versions, ['tlsv1.2']}]),
  602. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  603. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  604. ok = ranch:stop_listener(Name),
  605. {error, closed} = ssl:recv(Socket, 0, 1000),
  606. %% Make sure the listener stopped.
  607. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  608. ok.
  609. ssl_sni_fail(_) ->
  610. doc("Ensure that connection fails when host is not in SNI list."),
  611. Name = name(),
  612. Opts = ct_helper:get_certs_from_ets(),
  613. {ok, _} = ranch:start_listener(Name,
  614. ranch_ssl, [{sni_hosts, [{"pouet", Opts}]}],
  615. echo_protocol, []),
  616. Port = ranch:get_port(Name),
  617. %% We stick to TLS 1.2 because there seems to be a bug in OTP-23.0rc2
  618. %% that leads to a malformed_handshake_data error.
  619. {error, _} = ssl:connect("localhost", Port,
  620. [binary, {active, false}, {packet, raw}, {versions, ['tlsv1.2']}]),
  621. ok = ranch:stop_listener(Name),
  622. %% Make sure the listener stopped.
  623. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  624. ok.
  625. ssl_upgrade_from_tcp(_) ->
  626. doc("Ensure a TCP socket can be upgraded to SSL"),
  627. Name = name(),
  628. {ok, _} = ranch:start_listener(Name,
  629. ranch_tcp, #{},
  630. ssl_upgrade_protocol, []),
  631. Port = ranch:get_port(Name),
  632. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  633. ok = gen_tcp:send(Socket, <<"ECHO Before upgrading to SSL">>),
  634. {ok, <<"Before upgrading to SSL">>} = gen_tcp:recv(Socket, 23, 1000),
  635. ok = gen_tcp:send(Socket, <<"UPGRADE">>),
  636. {ok, <<"READY">>} = gen_tcp:recv(Socket, 5, 1000),
  637. {ok, SslSocket} = ssl:connect(Socket, [{verify, verify_none}], 5000),
  638. ok = ssl:send(SslSocket, <<"ECHO After upgrading to SSL">>),
  639. {ok, <<"After upgrading to SSL">>} = ssl:recv(SslSocket, 22, 1000),
  640. ok = ranch:stop_listener(Name),
  641. {error, closed} = ssl:recv(SslSocket, 0, 1000),
  642. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  643. ok.
  644. ssl_graceful(_) ->
  645. doc("Ensure suspending and resuming of listeners does not kill active connections."),
  646. Name = name(),
  647. Opts = ct_helper:get_certs_from_ets(),
  648. {ok, _} = ranch:start_listener(Name,
  649. ranch_ssl, Opts,
  650. echo_protocol, []),
  651. Port = ranch:get_port(Name),
  652. %% Make sure connections with a fresh listener work.
  653. running = ranch:get_status(Name),
  654. {ok, Socket1} = ssl:connect("localhost", Port,
  655. [binary, {active, false}, {packet, raw}]),
  656. ok = ssl:send(Socket1, <<"SSL with fresh listener">>),
  657. {ok, <<"SSL with fresh listener">>} = ssl:recv(Socket1, 23, 1000),
  658. %% Suspend listener, make sure established connections keep running.
  659. ok = ranch:suspend_listener(Name),
  660. suspended = ranch:get_status(Name),
  661. ok = ssl:send(Socket1, <<"SSL with suspended listener">>),
  662. {ok, <<"SSL with suspended listener">>} = ssl:recv(Socket1, 27, 1000),
  663. %% Make sure new connections are refused on the suspended listener.
  664. {error, econnrefused} = ssl:connect("localhost", Port,
  665. [binary, {active, false}, {packet, raw}]),
  666. %% Make sure transport options can be changed when listener is suspended.
  667. ok = ranch:set_transport_options(Name, #{socket_opts => [{port, Port}|Opts]}),
  668. %% Resume listener, make sure connections can be established again.
  669. ok = ranch:resume_listener(Name),
  670. running = ranch:get_status(Name),
  671. {ok, Socket2} = ssl:connect("localhost", Port,
  672. [binary, {active, false}, {packet, raw}]),
  673. ok = ssl:send(Socket2, <<"SSL with resumed listener">>),
  674. {ok, <<"SSL with resumed listener">>} = ssl:recv(Socket2, 25, 1000),
  675. ok = ranch:stop_listener(Name),
  676. {error, closed} = ssl:recv(Socket1, 0, 1000),
  677. {error, closed} = ssl:recv(Socket2, 0, 1000),
  678. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  679. ok.
  680. ssl_getopts_capability(_) ->
  681. doc("Ensure getopts/2 capability."),
  682. Name=name(),
  683. Opts=ct_helper:get_certs_from_ets(),
  684. {ok, _} = ranch:start_listener(Name,
  685. ranch_ssl, Opts,
  686. transport_capabilities_protocol, []),
  687. Port=ranch:get_port(Name),
  688. {ok, Socket}=ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  689. ok=ssl:send(Socket, <<"getopts/2">>),
  690. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  691. ok=ranch:stop_listener(Name),
  692. {error, closed}=ssl:recv(Socket, 0, 1000),
  693. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  694. ok.
  695. ssl_getstat_capability(_) ->
  696. doc("Ensure getstat/1,2 capability."),
  697. Name=name(),
  698. Opts=ct_helper:get_certs_from_ets(),
  699. {ok, _} = ranch:start_listener(Name,
  700. ranch_ssl, Opts,
  701. transport_capabilities_protocol, []),
  702. Port=ranch:get_port(Name),
  703. {ok, Socket}=ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  704. ok=ssl:send(Socket, <<"getstat/1">>),
  705. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  706. ok=ssl:send(Socket, <<"getstat/2">>),
  707. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  708. ok=ranch:stop_listener(Name),
  709. {error, closed}=ssl:recv(Socket, 0, 1000),
  710. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  711. ok.
  712. ssl_error_eaddrinuse(_) ->
  713. doc("Ensure that failure due to an eaddrinuse returns a compact readable error."),
  714. Name = name(),
  715. Opts = ct_helper:get_certs_from_ets(),
  716. {ok, _} = ranch:start_listener(Name,
  717. ranch_ssl, Opts,
  718. active_echo_protocol, []),
  719. Port = ranch:get_port(Name),
  720. {error, eaddrinuse} = ranch:start_listener({Name, fails},
  721. ranch_ssl, [{port, Port}|Opts],
  722. active_echo_protocol, []),
  723. ok = ranch:stop_listener(Name),
  724. %% Make sure the listener stopped.
  725. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  726. ok.
  727. ssl_error_no_cert(_) ->
  728. doc("Ensure that failure due to missing certificate returns a compact readable error."),
  729. {error, no_cert} = ranch:start_listener(name(),
  730. ranch_ssl, #{},
  731. active_echo_protocol, []),
  732. ok.
  733. ssl_error_eacces(_) ->
  734. case os:type() of
  735. {win32, nt} ->
  736. {skip, "No privileged ports."};
  737. {unix, darwin} ->
  738. {skip, "No privileged ports."};
  739. _ ->
  740. doc("Ensure that failure due to an eacces returns a compact readable error."),
  741. Name = name(),
  742. Opts = ct_helper:get_certs_from_ets(),
  743. {error, eacces} = ranch:start_listener(Name,
  744. ranch_ssl, [{port, 283}|Opts],
  745. active_echo_protocol, []),
  746. ok
  747. end.
  748. %% tcp.
  749. tcp_10_acceptors_10_listen_sockets(_) ->
  750. case do_os_supports_reuseport() of
  751. true ->
  752. ok = do_tcp_10_acceptors_10_listen_sockets();
  753. false ->
  754. {skip, "No SO_REUSEPORT support."}
  755. end.
  756. do_tcp_10_acceptors_10_listen_sockets() ->
  757. doc("Ensure that we can use 10 listen sockets across 10 acceptors with TCP."),
  758. Name = name(),
  759. {ok, ListenerSupPid} = ranch:start_listener(Name,
  760. ranch_tcp, #{
  761. num_acceptors => 10,
  762. num_listen_sockets => 10,
  763. socket_opts => [{raw, 1, 15, <<1:32/native>>}]},
  764. echo_protocol, []),
  765. 10 = length(do_get_listener_sockets(ListenerSupPid)),
  766. ok = ranch:stop_listener(Name),
  767. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  768. ok.
  769. tcp_many_listen_sockets_no_reuseport(_) ->
  770. case do_os_supports_reuseport() of
  771. true ->
  772. ok = do_tcp_many_listen_sockets_no_reuseport();
  773. false ->
  774. {skip, "No SO_REUSEPORT support."}
  775. end.
  776. do_tcp_many_listen_sockets_no_reuseport() ->
  777. doc("Confirm that ranch:start_listener/5 fails when SO_REUSEPORT is not available with TCP."),
  778. Name = name(),
  779. {error, eaddrinuse} = ranch:start_listener(Name,
  780. ranch_tcp, #{
  781. num_acceptors => 10,
  782. num_listen_sockets => 10,
  783. socket_opts => [{raw, 1, 15, <<0:32/native>>}]},
  784. echo_protocol, []),
  785. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  786. ok.
  787. tcp_active_echo(_) ->
  788. doc("Ensure that active mode works with TCP transport."),
  789. Name = name(),
  790. {ok, _} = ranch:start_listener(Name,
  791. ranch_tcp, #{},
  792. active_echo_protocol, []),
  793. Port = ranch:get_port(Name),
  794. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  795. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  796. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  797. ok = ranch:stop_listener(Name),
  798. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  799. %% Make sure the listener stopped.
  800. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  801. ok.
  802. tcp_active_n_echo(_) ->
  803. doc("Ensure that active N mode works with TCP transport."),
  804. Name = name(),
  805. {ok, _} = ranch:start_listener(Name,
  806. ranch_tcp, #{},
  807. batch_echo_protocol, [{batch_size, 3}]),
  808. Port = ranch:get_port(Name),
  809. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  810. ok = gen_tcp:send(Socket, <<"One">>),
  811. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  812. ok = gen_tcp:send(Socket, <<"Two">>),
  813. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  814. ok = gen_tcp:send(Socket, <<"Three">>),
  815. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  816. {ok, <<"OneTwoThree">>} = gen_tcp:recv(Socket, 11, 1000),
  817. ok = ranch:stop_listener(Name),
  818. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  819. %% Make sure the listener stopped.
  820. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  821. ok.
  822. tcp_echo(_) ->
  823. doc("Ensure that passive mode works with TCP transport."),
  824. Name = name(),
  825. {ok, _} = ranch:start_listener(Name,
  826. ranch_tcp, #{},
  827. echo_protocol, []),
  828. Port = ranch:get_port(Name),
  829. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  830. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  831. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  832. ok = ranch:stop_listener(Name),
  833. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  834. %% Make sure the listener stopped.
  835. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  836. ok.
  837. tcp_local_echo(_) ->
  838. case do_os_supports_local_sockets() of
  839. true ->
  840. do_tcp_local_echo();
  841. false ->
  842. {skip, "No local socket support."}
  843. end.
  844. do_tcp_local_echo() ->
  845. doc("Ensure that listening on a local socket works with TCP transport."),
  846. SockFile = do_tempname(),
  847. try
  848. Name = name(),
  849. {ok, _} = ranch:start_listener(Name,
  850. ranch_tcp, #{socket_opts => [{ip, {local, SockFile}}]},
  851. echo_protocol, []),
  852. undefined = ranch:get_port(Name),
  853. {ok, Socket} = gen_tcp:connect({local, SockFile}, 0, [binary, {active, false}, {packet, raw}]),
  854. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  855. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  856. ok = ranch:stop_listener(Name),
  857. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  858. %% Make sure the listener stopped.
  859. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  860. %% Make sure the socket file is removed.
  861. {error, enoent} = file:read_file_info(SockFile),
  862. ok
  863. after
  864. file:delete(SockFile)
  865. end.
  866. tcp_graceful(_) ->
  867. doc("Ensure suspending and resuming of listeners does not kill active connections."),
  868. Name = name(),
  869. {ok, _} = ranch:start_listener(Name,
  870. ranch_tcp, #{},
  871. echo_protocol, []),
  872. Port = ranch:get_port(Name),
  873. %% Make sure connections with a fresh listener work.
  874. running = ranch:get_status(Name),
  875. {ok, Socket1} = gen_tcp:connect("localhost", Port,
  876. [binary, {active, false}, {packet, raw}]),
  877. ok = gen_tcp:send(Socket1, <<"TCP with fresh listener">>),
  878. {ok, <<"TCP with fresh listener">>} = gen_tcp:recv(Socket1, 23, 1000),
  879. %% Suspend listener, make sure established connections keep running.
  880. ok = ranch:suspend_listener(Name),
  881. suspended = ranch:get_status(Name),
  882. ok = gen_tcp:send(Socket1, <<"TCP with suspended listener">>),
  883. {ok, <<"TCP with suspended listener">>} = gen_tcp:recv(Socket1, 27, 1000),
  884. %% Make sure new connections are refused on the suspended listener.
  885. {error, econnrefused} = gen_tcp:connect("localhost", Port,
  886. [binary, {active, false}, {packet, raw}]),
  887. %% Make sure transport options can be changed when listener is suspended.
  888. ok = ranch:set_transport_options(Name, [{port, Port}]),
  889. %% Resume listener, make sure connections can be established again.
  890. ok = ranch:resume_listener(Name),
  891. running = ranch:get_status(Name),
  892. {ok, Socket2} = gen_tcp:connect("localhost", Port,
  893. [binary, {active, false}, {packet, raw}]),
  894. ok = gen_tcp:send(Socket2, <<"TCP with resumed listener">>),
  895. {ok, <<"TCP with resumed listener">>} = gen_tcp:recv(Socket2, 25, 1000),
  896. ok = ranch:stop_listener(Name),
  897. {error, closed} = gen_tcp:recv(Socket1, 0, 1000),
  898. {error, closed} = gen_tcp:recv(Socket2, 0, 1000),
  899. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  900. ok.
  901. tcp_inherit_options(_) ->
  902. doc("Ensure TCP options are inherited in the protocol."),
  903. Name = name(),
  904. Opts = [{nodelay, false}, {send_timeout_close, false}],
  905. {ok, _} = ranch:start_listener(Name,
  906. ranch_tcp, Opts,
  907. check_tcp_options, [{pid, self()} | Opts]),
  908. Port = ranch:get_port(Name),
  909. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, true}, {packet, raw}]),
  910. receive checked -> ok after 1000 -> error(timeout) end,
  911. ok = gen_tcp:close(Socket),
  912. ok = ranch:stop_listener(Name).
  913. tcp_max_connections(_) ->
  914. doc("Ensure the max_connections option actually limits connections."),
  915. Name = name(),
  916. {ok, _} = ranch:start_listener(Name,
  917. ranch_tcp, #{max_connections => 10, num_acceptors => 1},
  918. notify_and_wait_protocol, #{pid => self()}),
  919. Port = ranch:get_port(Name),
  920. ok = connect_loop(Port, 11, 150),
  921. 10 = ranch_server:count_connections(Name),
  922. {10, Pids1} = receive_loop(connected, 400),
  923. ok = terminate_loop(stop, Pids1),
  924. {1, Pids2} = receive_loop(connected, 1000),
  925. ok = terminate_loop(stop, Pids2),
  926. ok = ranch:stop_listener(Name).
  927. tcp_max_connections_and_beyond(_) ->
  928. doc("Ensure the max_connections option works when connections are removed from the count."),
  929. Name = name(),
  930. {ok, _} = ranch:start_listener(Name,
  931. ranch_tcp, #{max_connections => 10, num_acceptors => 1},
  932. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  933. Port = ranch:get_port(Name),
  934. ok = connect_loop(Port, 10, 0),
  935. receive after 250 -> ok end,
  936. 0 = ranch_server:count_connections(Name),
  937. 10 = length(do_conns_which_children(Name)),
  938. Counts = do_conns_count_children(Name),
  939. {_, 1} = lists:keyfind(specs, 1, Counts),
  940. {_, 0} = lists:keyfind(supervisors, 1, Counts),
  941. {_, 10} = lists:keyfind(active, 1, Counts),
  942. {_, 10} = lists:keyfind(workers, 1, Counts),
  943. ranch:set_protocol_options(Name, [{remove, false, 2500}]),
  944. receive after 250 -> ok end,
  945. ok = connect_loop(Port, 10, 0),
  946. receive after 250 -> ok end,
  947. 10 = ranch_server:count_connections(Name),
  948. 20 = length(do_conns_which_children(Name)),
  949. Counts2 = do_conns_count_children(Name),
  950. {_, 20} = lists:keyfind(active, 1, Counts2),
  951. {_, 20} = lists:keyfind(workers, 1, Counts2),
  952. ok = ranch:stop_listener(Name).
  953. tcp_max_connections_infinity(_) ->
  954. doc("Set the max_connections option from 10 to infinity and back to 10."),
  955. Name = name(),
  956. {ok, _} = ranch:start_listener(Name,
  957. ranch_tcp, #{max_connections => 10, num_acceptors => 1},
  958. notify_and_wait_protocol, #{pid => self()}),
  959. Port = ranch:get_port(Name),
  960. ok = connect_loop(Port, 20, 0),
  961. 10 = ranch_server:count_connections(Name),
  962. {10, Pids1} = receive_loop(connected, 1000),
  963. 10 = ranch_server:count_connections(Name),
  964. 10 = ranch:get_max_connections(Name),
  965. ranch:set_max_connections(Name, infinity),
  966. receive after 250 -> ok end,
  967. 20 = ranch_server:count_connections(Name),
  968. infinity = ranch:get_max_connections(Name),
  969. ranch:set_max_connections(Name, 10),
  970. 20 = ranch_server:count_connections(Name),
  971. {10, Pids2} = receive_loop(connected, 1000),
  972. ok = terminate_loop(stop, Pids1 ++ Pids2),
  973. ok = ranch:stop_listener(Name).
  974. tcp_remove_connections(_) ->
  975. doc("Ensure that removed connections are only removed once."),
  976. Name = name(),
  977. {ok, _} = ranch:start_listener(Name,
  978. ranch_tcp, #{},
  979. remove_conn_and_wait_protocol, [{remove, true, 0}]),
  980. Port = ranch:get_port(Name),
  981. ok = connect_loop(Port, 10, 0),
  982. receive after 250 -> ok end,
  983. 0 = ranch_server:count_connections(Name),
  984. ok = ranch:stop_listener(Name).
  985. tcp_remove_connections_acceptor_wakeup(_) ->
  986. doc("Ensure that removed connections wake up acceptors."),
  987. Name = name(),
  988. {ok, _} = ranch:start_listener(Name,
  989. ranch_tcp, #{max_connections => 1, num_acceptors => 1},
  990. remove_conn_and_wait_protocol, [{remove, true, infinity}]),
  991. Port = ranch:get_port(Name),
  992. ConnectOptions = [binary, {active, false}],
  993. Localhost = "localhost",
  994. {ok, Socket1} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  995. {ok, Socket2} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  996. {ok, Socket3} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  997. ok = gen_tcp:send(Socket3, <<"bye">>),
  998. true = maps:get(all_connections, ranch:info(Name)) >= 2,
  999. ok = gen_tcp:send(Socket1, <<"bye">>),
  1000. ok = gen_tcp:send(Socket2, <<"bye">>),
  1001. ok = ranch:stop_listener(Name).
  1002. tcp_set_max_connections(_) ->
  1003. doc("Ensure that changing the max_connections option to a larger value allows for more connections."),
  1004. Name = name(),
  1005. {ok, _} = ranch:start_listener(Name,
  1006. ranch_tcp, #{max_connections => 10, num_acceptors => 1},
  1007. notify_and_wait_protocol, #{pid => self()}),
  1008. Port = ranch:get_port(Name),
  1009. ok = connect_loop(Port, 20, 0),
  1010. 10 = ranch_server:count_connections(Name),
  1011. {10, Pids1} = receive_loop(connected, 1000),
  1012. 10 = ranch:get_max_connections(Name),
  1013. ranch:set_max_connections(Name, 20),
  1014. {10, Pids2} = receive_loop(connected, 1000),
  1015. 20 = ranch:get_max_connections(Name),
  1016. ok = terminate_loop(stop, Pids1 ++ Pids2),
  1017. ok = ranch:stop_listener(Name).
  1018. tcp_set_max_connections_clean(Config) ->
  1019. case code:is_module_native(?MODULE) of
  1020. true -> doc("This test uses tracing and is not compatible with native code.");
  1021. false -> do_tcp_set_max_connections_clean(Config)
  1022. end.
  1023. do_tcp_set_max_connections_clean(_) ->
  1024. doc("Ensure that setting max_connections does not crash any process."),
  1025. Name = name(),
  1026. {ok, ListSupPid} = ranch:start_listener(Name,
  1027. ranch_tcp, #{max_connections => 4},
  1028. notify_and_wait_protocol, #{pid => self()}),
  1029. Children = supervisor:which_children(ListSupPid),
  1030. {_, AccSupPid, _, _} = lists:keyfind(ranch_acceptors_sup, 1, Children),
  1031. 1 = erlang:trace(ListSupPid, true, [procs]),
  1032. 1 = erlang:trace(AccSupPid, true, [procs]),
  1033. Port = ranch:get_port(Name),
  1034. N = 20,
  1035. ok = connect_loop(Port, N*5, 0),
  1036. %% Randomly set max_connections.
  1037. [spawn(ranch, set_max_connections, [Name, Max]) ||
  1038. Max <- lists:flatten(lists:duplicate(N, [6, 4, 8, infinity]))],
  1039. receive
  1040. {trace, _, spawn, _, _} ->
  1041. error(dirty_set_max_connections)
  1042. after
  1043. 2000 -> ok
  1044. end,
  1045. _ = erlang:trace(all, false, [all]),
  1046. ok = clean_traces(),
  1047. ok = ranch:stop_listener(Name).
  1048. tcp_getopts_capability(_) ->
  1049. doc("Ensure getopts/2 capability."),
  1050. Name=name(),
  1051. {ok, _}=ranch:start_listener(Name,
  1052. ranch_tcp, #{},
  1053. transport_capabilities_protocol, []),
  1054. Port=ranch:get_port(Name),
  1055. {ok, Socket}=gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1056. ok=gen_tcp:send(Socket, <<"getopts/2">>),
  1057. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1058. ok=ranch:stop_listener(Name),
  1059. {error, closed}=gen_tcp:recv(Socket, 0, 1000),
  1060. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  1061. ok.
  1062. tcp_getstat_capability(_) ->
  1063. doc("Ensure getstat/1,2 capability."),
  1064. Name=name(),
  1065. {ok, _}=ranch:start_listener(Name,
  1066. ranch_tcp, #{},
  1067. transport_capabilities_protocol, []),
  1068. Port=ranch:get_port(Name),
  1069. {ok, Socket}=gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1070. ok=gen_tcp:send(Socket, <<"getstat/1">>),
  1071. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1072. ok=gen_tcp:send(Socket, <<"getstat/2">>),
  1073. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1074. ok=ranch:stop_listener(Name),
  1075. {error, closed}=gen_tcp:recv(Socket, 0, 1000),
  1076. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  1077. ok.
  1078. tcp_upgrade(_) ->
  1079. doc("Ensure that protocol options can be updated."),
  1080. Name = name(),
  1081. {ok, _} = ranch:start_listener(Name,
  1082. ranch_tcp, #{},
  1083. notify_and_wait_protocol, #{pid => self()}),
  1084. Port = ranch:get_port(Name),
  1085. ok = connect_loop(Port, 1, 0),
  1086. {1, Pids1} = receive_loop(connected, 1000),
  1087. ranch:set_protocol_options(Name, #{msg => upgraded, pid => self()}),
  1088. ok = connect_loop(Port, 1, 0),
  1089. {1, Pids2} = receive_loop(upgraded, 1000),
  1090. ok = terminate_loop(stop, Pids1 ++ Pids2),
  1091. ok = ranch:stop_listener(Name).
  1092. tcp_error_eaddrinuse(_) ->
  1093. doc("Ensure that failure due to an eaddrinuse returns a compact readable error."),
  1094. Name = name(),
  1095. {ok, _} = ranch:start_listener(Name,
  1096. ranch_tcp, #{},
  1097. active_echo_protocol, []),
  1098. Port = ranch:get_port(Name),
  1099. {error, eaddrinuse} = ranch:start_listener({Name, fails},
  1100. ranch_tcp, [{port, Port}],
  1101. active_echo_protocol, []),
  1102. ok = ranch:stop_listener(Name),
  1103. %% Make sure the listener stopped.
  1104. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1105. ok.
  1106. tcp_error_eacces(_) ->
  1107. case os:type() of
  1108. {win32, nt} ->
  1109. {skip, "No privileged ports."};
  1110. {unix, darwin} ->
  1111. {skip, "No privileged ports."};
  1112. _ ->
  1113. doc("Ensure that failure due to an eacces returns a compact readable error."),
  1114. Name = name(),
  1115. {error, eacces} = ranch:start_listener(Name,
  1116. ranch_tcp, [{port, 283}],
  1117. active_echo_protocol, []),
  1118. ok
  1119. end.
  1120. %% Supervisor tests
  1121. connection_type_supervisor(_) ->
  1122. doc("The supervisor connection type must be reflected in the specifications."),
  1123. Name = name(),
  1124. {ok, _} = ranch:start_listener(Name,
  1125. ranch_tcp, #{connection_type => supervisor},
  1126. echo_protocol, []),
  1127. Port = ranch:get_port(Name),
  1128. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1129. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1130. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1131. [{echo_protocol, _, supervisor, [echo_protocol]}] = do_conns_which_children(Name),
  1132. ok = ranch:stop_listener(Name),
  1133. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1134. %% Make sure the listener stopped.
  1135. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1136. ok.
  1137. connection_type_supervisor_separate_from_connection(_) ->
  1138. doc("The supervisor connection type allows separate supervised and connection processes."),
  1139. Name = name(),
  1140. {ok, _} = ranch:start_listener(Name,
  1141. ranch_tcp, #{connection_type => supervisor},
  1142. supervisor_separate, []),
  1143. Port = ranch:get_port(Name),
  1144. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1145. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1146. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1147. [{supervisor_separate, _, supervisor, [supervisor_separate]}] = do_conns_which_children(Name),
  1148. ok = ranch:stop_listener(Name),
  1149. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1150. %% Make sure the listener stopped.
  1151. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1152. ok.
  1153. supervisor_10_acceptors_1_conns_sup(_) ->
  1154. doc("Ensure that using 10 acceptors and 1 connection supervisor works."),
  1155. ok = do_supervisor_n_acceptors_m_conns_sups(10, 1).
  1156. supervisor_9_acceptors_4_conns_sups(_) ->
  1157. doc("Ensure that using 9 acceptors and 4 connection supervisors works."),
  1158. ok = do_supervisor_n_acceptors_m_conns_sups(9, 4).
  1159. supervisor_10_acceptors_10_conns_sups(_) ->
  1160. doc("Ensure that using 10 acceptors and 10 connection supervisors works."),
  1161. ok = do_supervisor_n_acceptors_m_conns_sups(10, 10).
  1162. supervisor_1_acceptor_10_conns_sups(_) ->
  1163. doc("Ensure that using 1 acceptor and 10 connection supervisors works."),
  1164. ok = do_supervisor_n_acceptors_m_conns_sups(1, 10).
  1165. do_supervisor_n_acceptors_m_conns_sups(NumAcceptors, NumConnsSups) ->
  1166. Name = name(),
  1167. {ok, Pid} = ranch:start_listener(Name,
  1168. ranch_tcp, #{num_conns_sups => NumConnsSups, num_acceptors => NumAcceptors},
  1169. notify_and_wait_protocol, #{pid => self()}),
  1170. Port = ranch:get_port(Name),
  1171. ConnsSups = [ConnsSup || {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  1172. NumConnsSups = length(ConnsSups),
  1173. {ranch_acceptors_sup, AcceptorsSup, supervisor, _} =
  1174. lists:keyfind(ranch_acceptors_sup, 1, supervisor:which_children(Pid)),
  1175. AcceptorIds = [AcceptorId ||
  1176. {{acceptor, _, AcceptorId}, _, worker, _} <- supervisor:which_children(AcceptorsSup)],
  1177. NumAcceptors = length(AcceptorIds),
  1178. AcceptorConnsSups0 = [ranch_server:get_connections_sup(Name, AcceptorId) ||
  1179. AcceptorId <- AcceptorIds],
  1180. AcceptorConnsSups1 = lists:usort(AcceptorConnsSups0),
  1181. if
  1182. NumAcceptors > NumConnsSups ->
  1183. NumConnsSups = length(AcceptorConnsSups1),
  1184. [] = ConnsSups -- AcceptorConnsSups1;
  1185. NumAcceptors < NumConnsSups ->
  1186. NumAcceptors = length(AcceptorConnsSups1),
  1187. [] = AcceptorConnsSups1 -- ConnsSups;
  1188. NumAcceptors =:= NumConnsSups ->
  1189. NumConnsSups = length(AcceptorConnsSups1),
  1190. NumAcceptors = length(AcceptorConnsSups1),
  1191. [] = ConnsSups -- AcceptorConnsSups1,
  1192. [] = AcceptorConnsSups1 -- ConnsSups
  1193. end,
  1194. ok = connect_loop(Port, 100, 0),
  1195. {100, Pids} = receive_loop(connected, 1000),
  1196. 100 = ranch_server:count_connections(Name),
  1197. ok = terminate_loop(stop, Pids),
  1198. ok = ranch:stop_listener(Name),
  1199. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1200. ok.
  1201. supervisor_changed_options_restart(_) ->
  1202. doc("Ensure that a listener is restarted with changed transport options."),
  1203. Name = name(),
  1204. %% Start a listener using send_timeout as option change marker.
  1205. {ok, ListenerSupPid1} = ranch:start_listener(Name,
  1206. ranch_tcp, [{send_timeout, 300000}],
  1207. echo_protocol, []),
  1208. %% Ensure send_timeout is really set to initial value.
  1209. {ok, [{send_timeout, 300000}]}
  1210. = inet:getopts(do_get_listener_socket(ListenerSupPid1), [send_timeout]),
  1211. %% Change send_timeout option.
  1212. ok = ranch:suspend_listener(Name),
  1213. ok = ranch:set_transport_options(Name, [{send_timeout, 300001}]),
  1214. ok = ranch:resume_listener(Name),
  1215. %% Ensure send_timeout is really set to the changed value.
  1216. {ok, [{send_timeout, 300001}]}
  1217. = inet:getopts(do_get_listener_socket(ListenerSupPid1), [send_timeout]),
  1218. %% Crash the listener_sup process, allow a short time for restart to succeed.
  1219. %% We silence the expected log events coming from the relevant supervisors.
  1220. ListenerChilds = [ChildPid || {_, ChildPid, _, _} <- supervisor:which_children(ListenerSupPid1)],
  1221. FilterFun = fun (#{meta := #{pid := EventPid}}, _) ->
  1222. case lists:member(EventPid, ListenerChilds) of
  1223. true -> stop;
  1224. false -> ignore
  1225. end
  1226. end,
  1227. ok = logger:add_primary_filter(?MODULE, {FilterFun, undefined}),
  1228. try
  1229. exit(ListenerSupPid1, kill),
  1230. timer:sleep(1000)
  1231. after
  1232. ok = logger:remove_primary_filter(?MODULE)
  1233. end,
  1234. %% Obtain pid of restarted listener_sup process.
  1235. [ListenerSupPid2] = [Pid || {{ranch_listener_sup, Ref}, Pid, supervisor, _}
  1236. <- supervisor:which_children(ranch_sup), Ref =:= Name],
  1237. %% Ensure send_timeout is still set to the changed value.
  1238. {ok, [{send_timeout, 300001}]}
  1239. = inet:getopts(do_get_listener_socket(ListenerSupPid2), [send_timeout]),
  1240. ok = ranch:stop_listener(Name),
  1241. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1242. ok.
  1243. supervisor_clean_child_restart(Config) ->
  1244. case code:is_module_native(?MODULE) of
  1245. true -> doc("This test uses tracing and is not compatible with native code.");
  1246. false -> do_supervisor_clean_child_restart(Config)
  1247. end.
  1248. do_supervisor_clean_child_restart(_) ->
  1249. doc("Verify that only the relevant parts of the supervision tree restarted "
  1250. "when the listening socket is closed."),
  1251. Name = name(),
  1252. %% Trace socket allocations.
  1253. {module, ranch_tcp} = code:ensure_loaded(ranch_tcp),
  1254. _ = erlang:trace(new, true, [call]),
  1255. 1 = erlang:trace_pattern({ranch_tcp, listen, 1},
  1256. [{'_', [], [{return_trace}]}], [global]),
  1257. {ok, Pid} = ranch:start_listener(Name,
  1258. ranch_tcp, #{num_acceptors => 1},
  1259. echo_protocol, []),
  1260. %% Trace supervisor spawns.
  1261. 1 = erlang:trace(Pid, true, [procs, set_on_spawn]),
  1262. ConnsSups = ranch_server:get_connections_sups(Name),
  1263. %% Manually shut the listening socket down.
  1264. LSocket = receive
  1265. {trace, _, return_from, {ranch_tcp, listen, 1}, {ok, Socket}} ->
  1266. Socket
  1267. after 0 ->
  1268. error(lsocket_unknown)
  1269. end,
  1270. ok = gen_tcp:close(LSocket),
  1271. receive after 1000 -> ok end,
  1272. %% Verify that supervisor and its first two children are alive.
  1273. true = is_process_alive(Pid),
  1274. true = lists:all(fun erlang:is_process_alive/1, [ConnsSup || {_, ConnsSup} <- ConnsSups]),
  1275. %% Check that acceptors_sup is restarted properly.
  1276. AccSupPid = receive {trace, Pid, spawn, Pid1, _} -> Pid1 end,
  1277. receive {trace, AccSupPid, spawn, _, _} -> ok end,
  1278. %% No more traces then.
  1279. receive
  1280. {trace, _, spawn, _, _} -> error(invalid_restart)
  1281. after 1000 -> ok end,
  1282. %% Verify that children still registered right.
  1283. ConnsSups = ranch_server:get_connections_sups(Name),
  1284. _ = erlang:trace_pattern({ranch_tcp, listen, 1}, false, []),
  1285. _ = erlang:trace(all, false, [all]),
  1286. ok = clean_traces(),
  1287. ok = ranch:stop_listener(Name).
  1288. supervisor_clean_restart(Config) ->
  1289. case code:is_module_native(?MODULE) of
  1290. true -> doc("This test uses tracing and is not compatible with native code.");
  1291. false -> do_supervisor_clean_restart(Config)
  1292. end.
  1293. do_supervisor_clean_restart(_) ->
  1294. doc("Verify that killing ranch_conns_sup does not crash everything "
  1295. "and that it restarts properly."),
  1296. Name = name(),
  1297. NumAcc = 4,
  1298. {ok, Pid} = ranch:start_listener(Name,
  1299. ranch_tcp, #{num_acceptors => NumAcc},
  1300. echo_protocol, []),
  1301. %% Trace supervisor spawns.
  1302. 1 = erlang:trace(Pid, true, [procs, set_on_spawn]),
  1303. {_, ConnsSupSup0, _, _} = lists:keyfind(ranch_conns_sup_sup, 1, supervisor:which_children(Pid)),
  1304. exit(ConnsSupSup0, kill),
  1305. receive after 1000 -> ok end,
  1306. %% Verify that supervisor is alive
  1307. true = is_process_alive(Pid),
  1308. %% ...but children are dead.
  1309. false = is_process_alive(ConnsSupSup0),
  1310. %% Receive traces from newly started children
  1311. ConnsSupSup = receive {trace, Pid, spawn, Pid2, _} -> Pid2 end,
  1312. [receive {trace, ConnsSupSup, spawn, _Pid, _} -> ok end ||
  1313. _ <- lists:seq(1, NumAcc)],
  1314. AccSupPid = receive {trace, Pid, spawn, Pid3, _} -> Pid3 end,
  1315. %% ...and its acceptors.
  1316. [receive {trace, AccSupPid, spawn, _Pid, _} -> ok end ||
  1317. _ <- lists:seq(1, NumAcc)],
  1318. %% No more traces then.
  1319. receive
  1320. {trace, EPid, spawn, _, _} when EPid == Pid; EPid == AccSupPid ->
  1321. error(invalid_restart)
  1322. after 1000 -> ok end,
  1323. %% Verify that new children registered themselves properly.
  1324. _ = erlang:trace(all, false, [all]),
  1325. ok = clean_traces(),
  1326. ok = ranch:stop_listener(Name).
  1327. supervisor_conns_alive(Config) ->
  1328. case code:is_module_native(?MODULE) of
  1329. true -> doc("This test uses tracing and is not compatible with native code.");
  1330. false -> do_supervisor_conns_alive(Config)
  1331. end.
  1332. do_supervisor_conns_alive(_) ->
  1333. doc("Ensure that active connections stay open when the listening socket gets closed."),
  1334. Name = name(),
  1335. {module, ranch_tcp} = code:ensure_loaded(ranch_tcp),
  1336. _ = erlang:trace(new, true, [call]),
  1337. 1 = erlang:trace_pattern({ranch_tcp, listen, 1},
  1338. [{'_', [], [{return_trace}]}], [global]),
  1339. {ok, _} = ranch:start_listener(Name,
  1340. ranch_tcp, #{},
  1341. remove_conn_and_wait_protocol, [{remove, false, 2500}]),
  1342. %% Get the listener socket
  1343. LSocket = receive
  1344. {trace, _, return_from, {ranch_tcp, listen, 1}, {ok, S}} ->
  1345. S
  1346. after 500 ->
  1347. error(lsocket_unknown)
  1348. end,
  1349. TcpPort = ranch:get_port(Name),
  1350. {ok, Socket} = gen_tcp:connect("localhost", TcpPort,
  1351. [binary, {active, true}, {packet, raw}]),
  1352. receive after 500 -> ok end,
  1353. %% Shut the socket down
  1354. ok = gen_tcp:close(LSocket),
  1355. %% Assert that client is still viable.
  1356. receive {tcp_closed, _} -> error(closed) after 1500 -> ok end,
  1357. ok = gen_tcp:send(Socket, <<"poke">>),
  1358. receive {tcp_closed, _} -> ok end,
  1359. _ = erlang:trace(all, false, [all]),
  1360. ok = clean_traces(),
  1361. ok = ranch:stop_listener(Name).
  1362. supervisor_embedded_ranch_server_crash(_) ->
  1363. doc("Ensure that restarting ranch_server also restarts embedded listeners."),
  1364. Name = name(),
  1365. {ok, SupPid} = embedded_sup:start_link(),
  1366. {ok, EmbeddedSupPid} = embedded_sup:start_listener(SupPid, Name,
  1367. ranch_tcp, #{},
  1368. echo_protocol, []),
  1369. [{{ranch_listener_sup, Name}, ListenerPid, supervisor, _},
  1370. {ranch_server_proxy, ProxyPid, worker, _}] = supervisor:which_children(EmbeddedSupPid),
  1371. ProxyMonitor = monitor(process, ProxyPid),
  1372. ListenerMonitor = monitor(process, ListenerPid),
  1373. ok = supervisor:terminate_child(ranch_sup, ranch_server),
  1374. receive {'DOWN', ProxyMonitor, process, ProxyPid, shutdown} -> ok after 1000 -> exit(timeout) end,
  1375. receive {'DOWN', ListenerMonitor, process, ListenerPid, shutdown} -> ok after 1000 -> exit(timeout) end,
  1376. {ok, _} = supervisor:restart_child(ranch_sup, ranch_server),
  1377. receive after 1000 -> ok end,
  1378. [{{ranch_listener_sup, Name}, _, supervisor, _},
  1379. {ranch_server_proxy, _, worker, _}] = supervisor:which_children(EmbeddedSupPid),
  1380. embedded_sup:stop_listener(SupPid, Name),
  1381. embedded_sup:stop(SupPid),
  1382. ok.
  1383. supervisor_protocol_start_link_crash(_) ->
  1384. doc("Ensure a protocol start crash does not kill all connections."),
  1385. Name = name(),
  1386. {ok, _} = ranch:start_listener(Name,
  1387. ranch_tcp, #{},
  1388. crash_protocol, []),
  1389. ConnsSups = ranch_server:get_connections_sups(Name),
  1390. Port = ranch:get_port(Name),
  1391. {ok, _} = gen_tcp:connect("localhost", Port, [binary, {active, true}, {packet, raw}]),
  1392. receive after 500 -> ok end,
  1393. ConnsSups = ranch_server:get_connections_sups(Name),
  1394. ok = ranch:stop_listener(Name).
  1395. supervisor_server_recover_state(Config) ->
  1396. case code:is_module_native(?MODULE) of
  1397. true -> doc("This test uses tracing and is not compatible with native code.");
  1398. false -> do_supervisor_server_recover_state(Config)
  1399. end.
  1400. do_supervisor_server_recover_state(_) ->
  1401. doc("Ensure that when ranch_server crashes and restarts, it recovers "
  1402. "its state and continues monitoring the same processes."),
  1403. Name = name(),
  1404. _ = erlang:trace(new, true, [call]),
  1405. 1 = erlang:trace_pattern({ranch_server, init, 1},
  1406. [{'_', [], [{return_trace}]}], [global]),
  1407. {ok, _} = ranch:start_listener(Name,
  1408. ranch_tcp, #{},
  1409. echo_protocol, []),
  1410. ConnsSups = ranch_server:get_connections_sups(Name),
  1411. ServerPid = erlang:whereis(ranch_server),
  1412. {monitors, Monitors} = erlang:process_info(ServerPid, monitors),
  1413. erlang:exit(ServerPid, kill),
  1414. receive
  1415. {trace, ServerPid2, return_from, {ranch_server, init, 1}, _Result} ->
  1416. {monitors, Monitors2} = erlang:process_info(ServerPid2, monitors),
  1417. %% Check that ranch_server is monitoring the same processes.
  1418. true = (lists:usort(Monitors) == lists:usort(Monitors2))
  1419. after
  1420. 1000 ->
  1421. error(timeout)
  1422. end,
  1423. ConnsSups = ranch_server:get_connections_sups(Name),
  1424. ok = ranch:stop_listener(Name),
  1425. %% Check ranch_server has removed the ranch_conns_sup.
  1426. [] = (catch ranch_server:get_connections_sups(Name)),
  1427. _ = erlang:trace(all, false, [all]),
  1428. ok = clean_traces().
  1429. supervisor_unexpected_message(_) ->
  1430. doc("Ensure the connections supervisor stays alive when it receives "
  1431. "an unexpected message."),
  1432. Name = name(),
  1433. {ok, _} = ranch:start_listener(Name,
  1434. ranch_tcp, #{},
  1435. echo_protocol, []),
  1436. Port = ranch:get_port(Name),
  1437. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1438. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1439. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1440. %% Send the unexpected message to all ranch_conns_sups.
  1441. _ = [ConnSup ! hello || {_, ConnSup} <- ranch_server:get_connections_sups(Name)],
  1442. %% Connection is still up.
  1443. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1444. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1445. ok = ranch:stop_listener(Name),
  1446. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1447. %% Make sure the listener stopped.
  1448. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1449. ok.
  1450. %% Utility functions.
  1451. connect_loop(_, 0, _) ->
  1452. ok;
  1453. connect_loop(Port, N, Sleep) ->
  1454. {ok, _} = gen_tcp:connect("localhost", Port,
  1455. [binary, {active, false}, {packet, raw}]),
  1456. receive after Sleep -> ok end,
  1457. connect_loop(Port, N - 1, Sleep).
  1458. receive_loop(Message, Timeout) ->
  1459. receive_loop(Message, Timeout, 0, []).
  1460. receive_loop(Message, Timeout, N, Acc) ->
  1461. receive {Pid, Message} ->
  1462. receive_loop(Message, Timeout, N + 1, [Pid|Acc])
  1463. after Timeout ->
  1464. {N, Acc}
  1465. end.
  1466. terminate_loop(_, []) ->
  1467. ok;
  1468. terminate_loop(Message, [Pid|Pids]) ->
  1469. Pid ! Message,
  1470. terminate_loop(Message, Pids).
  1471. clean_traces() ->
  1472. receive
  1473. {trace, _, _, _} ->
  1474. clean_traces();
  1475. {trace, _, _, _, _} ->
  1476. clean_traces()
  1477. after 0 ->
  1478. ok
  1479. end.
  1480. do_get_listener_socket(ListenerSupPid) ->
  1481. [LSocket] = do_get_listener_sockets(ListenerSupPid),
  1482. LSocket.
  1483. do_get_listener_sockets(ListenerSupPid) ->
  1484. [AcceptorsSupPid] = [Pid || {ranch_acceptors_sup, Pid, supervisor, _}
  1485. <- supervisor:which_children(ListenerSupPid)],
  1486. {links, Links} = erlang:process_info(AcceptorsSupPid, links),
  1487. [P || P <- Links, is_port(P)].
  1488. do_conns_which_children(Name) ->
  1489. Conns = [supervisor:which_children(ConnsSup) ||
  1490. {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  1491. lists:flatten(Conns).
  1492. do_conns_count_children(Name) ->
  1493. lists:foldl(
  1494. fun
  1495. (Stats, undefined) ->
  1496. Stats;
  1497. (Stats, Acc) ->
  1498. lists:zipwith(
  1499. fun ({K, V1}, {K, V2}) -> {K, V1+V2} end,
  1500. Acc,
  1501. Stats
  1502. )
  1503. end,
  1504. undefined,
  1505. [supervisor:count_children(ConnsSup) ||
  1506. {_, ConnsSup} <- ranch_server:get_connections_sups(Name)]
  1507. ).
  1508. do_os_supports_reuseport() ->
  1509. case {os:type(), os:version()} of
  1510. {{unix, linux}, {Major, _, _}} when Major > 3 -> true;
  1511. {{unix, linux}, {3, Minor, _}} when Minor >= 9 -> true;
  1512. _ -> false
  1513. end.
  1514. do_os_supports_local_sockets() ->
  1515. case os:type() of
  1516. {unix, _} -> true;
  1517. _ -> false
  1518. end.
  1519. do_tempname() ->
  1520. list_to_binary(lists:droplast(os:cmd("mktemp -u"))).