erlang高性能网络库esockd的编译和使用（三）-keepalive

-module(echo_server).
-include("../deps/esockd/include/esockd.hrl").
-behaviour(gen_server).
%% start
-export([start/0, start/1]).
-export([start_link/1]).
%% gen_server Function Exports
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
         terminate/2, code_change/3]).
-record(state, {conn, connname, peername, peerhost, peerport, keepalive}).
-define(TCP_OPTIONS, [
  binary,
        {packet, raw},
        {buffer, 1024},
  {reuseaddr, true},
  {backlog, 512},
  {nodelay, false}]).
-define(TCP_PORT, 5000).
-define(TIMEOUT_SEC, 30).%unit:s
%% API
start() ->
    start(?TCP_PORT).
start([Port]) when is_atom(Port) ->
    start(list_to_integer(atom_to_list(Port)));
start(Port) when is_integer(Port) ->
    %% application:start(sasl),
    %% ok = esockd:start(),
    Access = application:get_env(esockd, access, [{allow, all}]),
    SockOpts = [{access, Access},
                {acceptors, 32},
                {max_clients, 1000000},
                {sockopts, ?TCP_OPTIONS}],
    MFArgs = {?MODULE, start_link, []},
    esockd:open(echo, Port, SockOpts, MFArgs).
%% eSockd Callbacks
start_link(Conn) ->
    {ok, proc_lib:spawn_link(?MODULE, init, [Conn])}.
init(Conn) ->
    {ok, Conn1} = Conn:wait(),
    {PeerHost, PeerPort, PeerName} =
    case Conn1:peername() of
        {ok, Peer = {Host, Port}} ->
            {Host, Port, Peer};
        {error, enotconn} ->
            Conn1:fast_close(),
            exit(normal);
        {error, Reason} ->
            Conn1:fast_close(),
            exit({shutdown, Reason})
    end,
    ConnName = esockd_net:format(PeerName),
    %%io:format("~s~n", [esockd_net:format(peername, PeerName)]),
    io:format("tcp_connected,~s~n", [esockd_net:format({PeerHost, PeerPort})]),
    start_keepalive(?TIMEOUT_SEC),
    Conn1:setopts([{active, once}]),
    gen_server:enter_loop(?MODULE, [], #state{conn       = Conn1,
                                              connname   = ConnName,
                                              peername   = PeerName,
                                              peerhost   = PeerHost,
                                              peerport   = PeerPort}).
handle_call(_Request, _From, State) ->
    {reply, ok, State}.
handle_cast(_Msg, State) ->
    {noreply, State}.
handle_info({tcp, Sock, Data}, State = #state{conn = ?ESOCK(Sock) = Conn}) ->
    {ok, PeerName} = Conn:peername(),
    io:format("~s - ~s~n", [esockd_net:format(peername, PeerName), Data]),
    Conn:send(Data),
    Conn:setopts([{active, once}]),
    {noreply, State};
handle_info({tcp_error, Sock, Reason}, State = #state{conn = ?ESOCK(Sock)}) ->
    io:format("tcp_error: ~s~n", [Reason]),
    {stop, {shutdown, {tcp_error, Reason}}, State};
handle_info({tcp_closed, Sock}, State = #state{conn = ?ESOCK(Sock), peername = PeerName}) ->
    io:format("tcp_closed,~s~n", [esockd_net:format(peername, PeerName)]),
    {stop, normal, State};
handle_info({keepalive, start, Interval}, State = #state{conn = Conn1}) ->
    io:format("Keepalive at the interval of ~p~n", [Interval]),
    {ok, KeepAlive} = esockd_keepalive:start(Conn1, Interval, {keepalive, check}),
    hibernate(State#state{keepalive = KeepAlive});
handle_info({keepalive, check}, State = #state{peername = PeerName, keepalive = KeepAlive}) ->
    io:format("Keepalive check,~s,", [esockd_net:format(peername, PeerName)]),
    case esockd_keepalive:resume(KeepAlive) of
        {resumed, KeepAlive1} ->
            io:format("Keepalive resumed~n"),
            hibernate(State#state{keepalive = KeepAlive1});
        {error, timeout} ->
            io:format("Keepalive timeout~n"),
            shutdown(keepalive_timeout, State);
        {error, Error} ->
            io:format("Keepalive error - ~p~n", [Error]),
            shutdown(Error, State)
    end;
handle_info(_Info, State) ->
    {noreply, State}.
%terminate(_Reason, _State) ->
%    ok.
terminate(_Reason, #state{conn     = Conn1,
                         keepalive = KeepAlive}) ->
    Conn1:fast_close(),
    esockd_keepalive:cancel(KeepAlive),
    ok.
code_change(_OldVsn, State, _Extra) ->
    {ok, State}.
%%--------------------------------------------------------------------
%% Internal functions
%%--------------------------------------------------------------------
start_keepalive(0) -> ignore;
start_keepalive(Sec) when Sec > 0 ->
    self() ! {keepalive, start, round(Sec * 1.20)}.
hibernate(State) ->
    {noreply, State, hibernate}.
shutdown(Reason, State) ->
    stop({shutdown, Reason}, State).
stop(Reason, State) ->
    {stop, Reason, State}.

init(Conn) ->
    {ok, Conn1} = Conn:wait(),
    {PeerHost, PeerPort, PeerName} =
    case Conn1:peername() of
        {ok, Peer = {Host, Port}} ->
            {Host, Port, Peer};
        {error, enotconn} ->
            Conn1:fast_close(),
            exit(normal);
        {error, Reason} ->
            Conn1:fast_close(),
            exit({shutdown, Reason})
    end,
    ConnName = esockd_net:format(PeerName),
    %%io:format("~s~n", [esockd_net:format(peername, PeerName)]),
    io:format("tcp_connected,~s~n", [esockd_net:format({PeerHost, PeerPort})]),
    start_keepalive(?TIMEOUT_SEC),
    Conn1:setopts([{active, once}]),
    %% method 1:
    lists:foreach(fun({{Protocol, ListenOn}, Pid}) ->
                Info = [{acceptors,      esockd:get_acceptors(Pid)},
                        {max_clients,    esockd:get_max_clients(Pid)},
                        {current_clients,esockd:get_current_clients(Pid)},
                        {shutdown_count, esockd:get_shutdown_count(Pid)}],
                io:format("listener on ~s:~s~n", [Protocol, esockd:to_string(ListenOn)]),
                lists:foreach(fun({Key, Val}) ->
                            io:format("  ~-16s: ~w~n", [Key, Val])
                        end, Info)
            end, esockd:listeners()),
    %% method 2:
    Pid1 = esockd:listener({echo, ?TCP_PORT}),
    Count1 = esockd:get_current_clients(Pid1),
    io:format("current_clients:~p~n", [Count1]),
    %% method 3:
    Count2 = esockd:get_current_clients({echo, ?TCP_PORT}),
    io:format("current_clients:~p~n", [Count2]),
    gen_server:enter_loop(?MODULE, [], #state{conn       = Conn1,
                                              connname   = ConnName,
                                              peername   = PeerName,
                                              peerhost   = PeerHost,
                                              peerport   = PeerPort}).