Cowboy 源码分析(二十一)

　　大家好，今天继续跟大家分享Cowboy的源码分析，这一篇，我们看下cowboy_http_protocol:onrequest/2函数，完整代码如下：

%% Call the global onrequest callback. The callback can send a reply,
%% in which case we consider the request handled and move on to the next
%% one. Note that since we haven't dispatched yet, we don't know the
%% handler, host_info, path_info or bindings yet.
-spec onrequest(#http_req{}, #state{}) -> ok.
onrequest(Req, State=#state{onrequest=undefined}) ->
    dispatch(Req, State);
onrequest(Req, State=#state{onrequest=OnRequest}) ->
    Req2 = OnRequest(Req),
    case Req2#http_req.resp_state of
        waiting -> dispatch(Req2, State);
        _ -> next_request(Req2, State, ok)
    end.

　　这里我们从Debugger可以看到，onrequest=undefined，所以这里我们从第一个分支来看，另一个分支，等以后具体用到的时候再看。我们从代码中可以看到，第一个分支只是简单的调用了cowboy_http_protocol:dispatch/2 函数，代码如下：

-spec dispatch(#http_req{}, #state{}) -> ok.
dispatch(Req=#http_req{host=Host, path=Path},
        State=#state{dispatch=Dispatch}) ->
    case cowboy_dispatcher:match(Host, Path, Dispatch) of
        {ok, Handler, Opts, Binds, HostInfo, PathInfo} ->
            handler_init(Req#http_req{host_info=HostInfo, path_info=PathInfo,
                bindings=Binds}, State#state{handler={Handler, Opts}});
        {error, notfound, host} ->
            error_terminate(400, State);
        {error, notfound, path} ->
            error_terminate(404, State)
    end.

　　调用函数时，参数如下：
　　< Host = [<<"localhost">>]
　　< Path = []
　　< Dispatch = [{'_',[{[<<"websocket">>],websocket_handler,[]},
                    {[<<"eventsource">>],eventsource_handler,[]},
                    {[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
                    {'_',default_handler,[]}]}]

　　前面2个参数，之前都见过了，最后一个，不知道大家还记得吗？这个参数，是在cowboy_examples:start/2传递进来的，如下：

start(_Type, _Args) ->
    Dispatch = [
        {'_', [
            {[<<"websocket">>], websocket_handler, []},
            {[<<"eventsource">>], eventsource_handler, []},
            {[<<"eventsource">>, <<"live">>], eventsource_emitter, []},
            {'_', default_handler, []}
        ]}
    ],
    cowboy:start_listener(my_http_listener, 100,
        cowboy_tcp_transport, [{port, 8080}],
        cowboy_http_protocol, [{dispatch, Dispatch}]
    ),
    cowboy:start_listener(my_https_listener, 100,
        cowboy_ssl_transport, [
            {port, 8443}, {certfile, "priv/ssl/cert.pem"},
            {keyfile, "priv/ssl/key.pem"}, {password, "cowboy"}],
        cowboy_http_protocol, [{dispatch, Dispatch}]
    ),
    cowboy_examples_sup:start_link().

　　好，弄清楚了参数，我们来看具体逻辑：

    case cowboy_dispatcher:match(Host, Path, Dispatch) of

　　这里调用 cowboy_dispatcher:match/3 函数，代码如下：

%% @doc Match hostname tokens and path tokens against dispatch rules.
%%
%% It is typically used for matching tokens for the hostname and path of
%% the request against a global dispatch rule for your listener.
%%
%% Dispatch rules are a list of <em>{Hostname, PathRules}</em> tuples, with
%% <em>PathRules</em> being a list of <em>{Path, HandlerMod, HandlerOpts}</em>.
%%
%% <em>Hostname</em> and <em>Path</em> are match rules and can be either the
%% atom <em>'_'</em>, which matches everything for a single token, the atom
%% <em>'*'</em>, which matches everything for the rest of the tokens, or a
%% list of tokens. Each token can be either a binary, the atom <em>'_'</em>,
%% the atom '...' or a named atom. A binary token must match exactly,
%% <em>'_'</em> matches everything for a single token, <em>'...'</em> matches
%% everything for the rest of the tokens and a named atom will bind the
%% corresponding token value and return it.
%%
%% The list of hostname tokens is reversed before matching. For example, if
%% we were to match "www.ninenines.eu", we would first match "eu", then
%% "ninenines", then "www". This means that in the context of hostnames,
%% the <em>'...'</em> atom matches properly the lower levels of the domain
%% as would be expected.
%%
%% When a result is found, this function will return the handler module and
%% options found in the dispatch list, a key-value list of bindings and
%% the tokens that were matched by the <em>'...'</em> atom for both the
%% hostname and path.
-spec match(Host::tokens(), Path::tokens(), dispatch_rules())
    -> {ok, module(), any(), bindings(),
        HostInfo::undefined | tokens(),
        PathInfo::undefined | tokens()}
    | {error, notfound, host} | {error, notfound, path}.
match(_Host, _Path, []) ->
    {error, notfound, host};
match(_Host, Path, [{'_', PathMatchs}|_Tail]) ->
    match_path(Path, PathMatchs, [], undefined);
match(Host, Path, [{HostMatch, PathMatchs}|Tail]) ->
    case try_match(host, Host, HostMatch) of
        false ->
            match(Host, Path, Tail);
        {true, HostBinds, undefined} ->
            match_path(Path, PathMatchs, HostBinds, undefined);
        {true, HostBinds, HostInfo} ->
            match_path(Path, PathMatchs, HostBinds, lists:reverse(HostInfo))
    end.

　　函数的注释很清楚，本来想尝试翻译，无奈英文不好，就不给大家献丑了，我们看具体逻辑吧，如果有能坚持看到这里的朋友，而且你的英文不错，能翻译，那我在这麻烦你帮忙翻译下，也能帮助后来看这篇文字的朋友，不甚感激，回到代码：

　　我们根据上下文，能够知道代码将调用第二个分支，也就是执行：

match(_Host, Path, [{'_', PathMatchs}|_Tail]) ->
    match_path(Path, PathMatchs, [], undefined);

　　这里，参数的值分别为：

　　< _Host = [<<"localhost">>]
　　< Path = []
　　< PathMatchs = [{[<<"websocket">>],websocket_handler,[]},
                {[<<"eventsource">>],eventsource_handler,[]},
                {[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
                {'_',default_handler,[]}]
　　< _Tail = []

　　接着调用 cowboy_dispatcher:match_path/4 函数：

-spec match_path(tokens(), dispatch_path(), bindings(),
    HostInfo::undefined | tokens())
    -> {ok, module(), any(), bindings(),
        HostInfo::undefined | tokens(),
        PathInfo::undefined | tokens()}
    | {error, notfound, path}.
match_path(_Path, [], _HostBinds, _HostInfo) ->
    {error, notfound, path};
match_path(_Path, [{'_', Handler, Opts}|_Tail], HostBinds, HostInfo) ->
    {ok, Handler, Opts, HostBinds, HostInfo, undefined};
match_path('*', [{'*', Handler, Opts}|_Tail], HostBinds, HostInfo) ->
    {ok, Handler, Opts, HostBinds, HostInfo, undefined};
match_path(Path, [{PathMatch, Handler, Opts}|Tail], HostBinds, HostInfo) ->
    case try_match(path, Path, PathMatch) of
        false ->
            match_path(Path, Tail, HostBinds, HostInfo);
        {true, PathBinds, PathInfo} ->
            {ok, Handler, Opts, HostBinds ++ PathBinds, HostInfo, PathInfo}
    end.

　　同样，这里根据参数的值，我们也能知道，首先匹配的是最后一个分支，那么我们看下最后一个分支接受到的参数的值：

　　< Path = []
　　< PathMatch = [<<"websocket">>]
　　< Handler = websocket_handler
　　< Opts = []
　　< Tail = [{[<<"eventsource">>],eventsource_handler,[]},
          {[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
          {'_',default_handler,[]}]
　　< HostBinds = []
　　< HostInfo = undefined

　　而逻辑也比较简单，首先调用cowboy_dispatcher:try_match/3 函数，代码如下：

-spec try_match(host | path, tokens(), match_rule())
    -> {true, bindings(), undefined | tokens()} | false.
try_match(host, List, Match) ->
    list_match(lists:reverse(List), lists:reverse(Match), []);
try_match(path, List, Match) ->
    list_match(List, Match, []).

　　由于 case try_match(path, Path, PathMatch) of 第一个参数传递的是path，所以匹配的是下面这个分支，接受到的参数值为：

　　< List = []
　　< Match = [<<"websocket">>]

　　逻辑也很简单，就调用了 cowboy_dispatcher:list_match/3 函数，代码如下：

-spec list_match(tokens(), match_rule(), bindings())
    -> {true, bindings(), undefined | tokens()} | false.
%% Atom '...' matches any trailing path, stop right now.
list_match(List, ['...'], Binds) ->
    {true, Binds, List};
%% Atom '_' matches anything, continue.
list_match([_E|Tail], ['_'|TailMatch], Binds) ->
    list_match(Tail, TailMatch, Binds);
%% Both values match, continue.
list_match([E|Tail], [E|TailMatch], Binds) ->
    list_match(Tail, TailMatch, Binds);
%% Bind E to the variable name V and continue.
list_match([E|Tail], [V|TailMatch], Binds) when is_atom(V) ->
    list_match(Tail, TailMatch, [{V, E}|Binds]);
%% Match complete.
list_match([], [], Binds) ->
    {true, Binds, undefined};
%% Values don't match, stop.
list_match(_List, _Match, _Binds) ->
    false.

　　跟之前的分析方法一样，都是根据参数的值去匹配对应的分支，很简单，这里匹配到最后一个分支，返回 false。

　　接着回到 cowboy_dispatcher:match_path/4 函数：

match_path(Path, [{PathMatch, Handler, Opts}|Tail], HostBinds, HostInfo) ->
    case try_match(path, Path, PathMatch) of
        false ->
            match_path(Path, Tail, HostBinds, HostInfo);
        {true, PathBinds, PathInfo} ->
            {ok, Handler, Opts, HostBinds ++ PathBinds, HostInfo, PathInfo}
    end.

　　我们看下这里返回 false，递归调用cowboy_dispatcher:match_path/4，其实就是依次遍历处理：

　　< PathMatchs = [{[<<"websocket">>],websocket_handler,[]},
                {[<<"eventsource">>],eventsource_handler,[]},
                {[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
                {'_',default_handler,[]}]

　　我详细把每次调用cowboy_dispatcher:match_path/4时的参数都列出来，如下：

　　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

　　< Path = []
　　< PathMatch = [<<"websocket">>]
　　< Handler = websocket_handler
　　< Opts = []
　　< Tail = [{[<<"eventsource">>],eventsource_handler,[]},
          {[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
          {'_',default_handler,[]}]
　　< HostBinds = []
　　< HostInfo = undefined

　　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

　　< Path = []
　　< PathMatch = [<<"eventsource">>]
　　< Handler = eventsource_handler
　　< Opts = []
　　< Tail = [{[<<"eventsource">>,<<"live">>],eventsource_emitter,[]},
          {'_',default_handler,[]}]
　　< HostBinds = []
　　< HostInfo = undefined　　

　　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

　　< Path = []
　　< PathMatch = [<<"eventsource">>,<<"live">>]
　　< Handler = eventsource_emitter
　　< Opts = []
　　< Tail = [{'_',default_handler,[]}]
　　< HostBinds = []
　　< HostInfo = undefined

　　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

　　< _Path = []
　　< Handler = default_handler
　　< Opts = []
　　< _Tail = []
　　< HostBinds = []
　　< HostInfo = undefined

　　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

　　不知道大家能不能明白，当然，最后一次，很明显不会匹配cowboy_dispatcher:match_path/4 函数最后一个分支，而是匹配第二个分支，代码如下：

match_path(_Path, [{'_', Handler, Opts}|_Tail], HostBinds, HostInfo) ->
    {ok, Handler, Opts, HostBinds, HostInfo, undefined};

　　这里就一行代码，返回由这几个参数组合成的元组。

　　接着回到cowboy_http_protocol:dispatch/2 函数实现：

    case cowboy_dispatcher:match(Host, Path, Dispatch) of
        {ok, Handler, Opts, Binds, HostInfo, PathInfo} ->
            handler_init(Req#http_req{host_info=HostInfo, path_info=PathInfo,
                bindings=Binds}, State#state{handler={Handler, Opts}});
        {error, notfound, host} ->
            error_terminate(400, State);
        {error, notfound, path} ->
            error_terminate(404, State)
    end.

　　这里我们已经知道了case cowboy_dispatcher:match(Host, Path, Dispatch) of 这里正确的情况下会返回 {ok, Handler, Opts, Binds, HostInfo, PathInfo}，那么函数接下来将调用cowboy_http_protocol:handler_init/2函数。

　　好了，今天就到这里，下一篇，我们将从cowboy_http_protocol:handler_init/2函数继续往下看。

　　最后，谢谢大家支持。北京今天下了一天雨，现在还在继续，好反常，不过总算凉快了，大家好梦吧。