接上

上次讲到了ranch_conns_sup和ranch_acceptors_sup这2个ranch的核心模块，我们接着分析

首先查看ranch_conns_sup.erl

-module(ranch_conns_sup).%% API.-export([start_link/6]).-export([start_protocol/2]).-export([active_connections/1]).%...... 省略若干行%% API.-spec start_link(ranch:ref(), conn_type(), shutdown(), module(),    timeout(), module()) -> {ok, pid()}.start_link(Ref, ConnType, Shutdown, Transport, AckTimeout, Protocol) ->    proc_lib:start_link(?MODULE, init,        [self(), Ref, ConnType, Shutdown, Transport, AckTimeout, Protocol]).%...... 省略若干行%% Supervisor internals.-spec init(pid(), ranch:ref(), conn_type(), shutdown(),    module(), timeout(), module()) -> no_return().init(Parent, Ref, ConnType, Shutdown, Transport, AckTimeout, Protocol) ->    process_flag(trap_exit, true),    ok = ranch_server:set_connections_sup(Ref, self()),    MaxConns = ranch_server:get_max_connections(Ref),    Opts = ranch_server:get_protocol_options(Ref),    ok = proc_lib:init_ack(Parent, {ok, self()}),    loop(#state{parent=Parent, ref=Ref, conn_type=ConnType,        shutdown=Shutdown, transport=Transport, protocol=Protocol,        opts=Opts, ack_timeout=AckTimeout, max_conns=MaxConns}, 0, 0, []).loop(State=#state{parent=Parent, ref=Ref, conn_type=ConnType,        transport=Transport, protocol=Protocol, opts=Opts,        max_conns=MaxConns}, CurConns, NbChildren, Sleepers) ->    receive        {
    ?MODULE, start_protocol, To, Socket} ->            try Protocol:start_link(Ref, Socket, Transport, Opts) of                {ok, Pid} ->                    shoot(State, CurConns, NbChildren, Sleepers, To, Socket, Pid, Pid);                {ok, SupPid, ProtocolPid} when ConnType =:= supervisor ->                    shoot(State, CurConns, NbChildren, Sleepers, To, Socket, SupPid, ProtocolPid);%...... 省略若干行shoot(State=#state{ref=Ref, transport=Transport, ack_timeout=AckTimeout, max_conns=MaxConns},        CurConns, NbChildren, Sleepers, To, Socket, SupPid, ProtocolPid) ->    case Transport:controlling_process(Socket, ProtocolPid) of        ok ->            ProtocolPid ! {shoot, Ref, Transport, Socket, AckTimeout},            put(SupPid, true),            CurConns2 = CurConns + 1,            if CurConns2 < MaxConns ->                    To ! self(),                    loop(State, CurConns2, NbChildren + 1, Sleepers);                true ->                    loop(State, CurConns2, NbChildren + 1, [To|Sleepers])            end;        {error, _} ->            Transport:close(Socket),            %% Only kill the supervised pid, because the connection's pid,            %% when different, is supposed to be sitting under it and linked.            exit(SupPid, kill),            loop(State, CurConns, NbChildren, Sleepers)    end.%...... 省略若干行

可以看到ranch_conns_sup不是一个典型的gen_tcp模块，

start_link/6启动init后直接使用了loop来循环，

init/7函数主要是获取了一些参数，

loop后等待消息（我们主要看start_protocol消息），loop函数根据start_protocol消息启动Protocol:start_link/4（用户编写的应用模块，这里表示echo_protocol），后面注意谁发这个消息给它

启动正常后，记录下ProtocolPid

 

继续查看ranch_acceptors_sup.erl

-module(ranch_acceptors_sup).-behaviour(supervisor).-export([start_link/4]).-export([init/1]).-spec start_link(ranch:ref(), non_neg_integer(), module(), any())    -> {ok, pid()}.start_link(Ref, NbAcceptors, Transport, TransOpts) ->    supervisor:start_link(?MODULE, [Ref, NbAcceptors, Transport, TransOpts]).init([Ref, NbAcceptors, Transport, TransOpts]) ->    ConnsSup = ranch_server:get_connections_sup(Ref),    LSocket = case proplists:get_value(socket, TransOpts) of        undefined ->            TransOpts2 = proplists:delete(ack_timeout,                proplists:delete(connection_type,                proplists:delete(max_connections,                proplists:delete(shutdown,                proplists:delete(socket, TransOpts))))),            case Transport:listen(TransOpts2) of                {ok, Socket} -> Socket;                {error, Reason} -> listen_error(Ref, Transport, TransOpts2, Reason)            end;        Socket ->            Socket    end,    {ok, Addr} = Transport:sockname(LSocket),    ranch_server:set_addr(Ref, Addr),    Procs = [        {
    {acceptor, self(), N}, {ranch_acceptor, start_link, [            LSocket, Transport, ConnsSup        ]}, permanent, brutal_kill, worker, []}            || N <- lists:seq(1, NbAcceptors)],    {ok, {
    {one_for_one, 1, 5}, Procs}}.-spec listen_error(any(), module(), any(), atom()) -> no_return().listen_error(Ref, Transport, TransOpts2, Reason) ->    error_logger:error_msg(        "Failed to start Ranch listener ~p in ~p:listen(~p) for reason ~p (~s)~n",        [Ref, Transport, TransOpts2, Reason, inet:format_error(Reason)]),    exit({listen_error, Ref, Reason}).

 

这里进行最主要的操作有

打开端口Transport:listen/1开始监听端口

启动NbAcceptors个ranch_accetor:start_link进程等待连接，

 

接下来就是查看ranch_acceptor.erl

 

-module(ranch_acceptor).-export([start_link/3]).-export([loop/3]).-spec start_link(inet:socket(), module(), pid())    -> {ok, pid()}.start_link(LSocket, Transport, ConnsSup) ->    Pid = spawn_link(?MODULE, loop, [LSocket, Transport, ConnsSup]),    {ok, Pid}.-spec loop(inet:socket(), module(), pid()) -> no_return().loop(LSocket, Transport, ConnsSup) ->    _ = case Transport:accept(LSocket, infinity) of        {ok, CSocket} ->            case Transport:controlling_process(CSocket, ConnsSup) of                ok ->                    %% This call will not return until process has been started                    %% AND we are below the maximum number of connections.                    ranch_conns_sup:start_protocol(ConnsSup, CSocket);                {error, _} ->                    Transport:close(CSocket)            end;        %% Reduce the accept rate if we run out of file descriptors.        %% We can't accept anymore anyway, so we might as well wait        %% a little for the situation to resolve itself.        {error, emfile} ->            receive after 100 -> ok end;        %% We want to crash if the listening socket got closed.        {error, Reason} when Reason =/= closed ->            ok    end,    flush(),    ?MODULE:loop(LSocket, Transport, ConnsSup).flush() ->    receive Msg ->        error_logger:error_msg(            "Ranch acceptor received unexpected message: ~p~n",            [Msg]),        flush()    after 0 ->        ok    end.

 

当客户端端连接，accept返回ok，ranch_conns_sup:start_protocol/2发送{?MODULE, start_protocol, self(), Socket}给ConnsSup，

 

-module(ranch_conns_sup).%% API.-export([start_link/6]).-export([start_protocol/2]).-export([active_connections/1]).%%.......省略若干行-spec start_protocol(pid(), inet:socket()) -> ok.start_protocol(SupPid, Socket) ->    SupPid ! {?MODULE, start_protocol, self(), Socket},    receive SupPid -> ok end.%%.......省略若干行

 

启动Protocol:start_link/4的详细过程，参考上面的ranch_conns_sup分析

好，这个时候基本ranch的大致结构就分析出来了，还有一些其他的细节留以后慢慢添加。