Немного о сетевом движке на Erlang

-module(myserver_app).

-behaviour(application).

-export([start/0, start/2, stop/1]).

start() ->
    application:start(ranch),
    application:start(myserver).

start(_StartType, _StartArgs) ->
    AcceptorCount = 100,
    Port = 8080,
    {ok, _} = ranch:start_listener(myserver_pool, AcceptorCount,
        ranch_tcp, [{port, Port}], myserver_sup, []),
    myserver_sup:start_link().

stop(_State) ->
    ok.

-module(myserver_sup).

-behaviour(supervisor).

-export([start_link/0, start_link/4]).
-export([init/1]).

start_link() ->
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).

start_link(Ref, Socket, Transport, Opts) ->
    supervisor:start_child(?MODULE, [Ref, Socket, Transport, Opts]).

init([]) ->
    AChild = {myserver_connection_server, {myserver_connection_server, start_link, []},
        temporary, 2000, worker, [myserver_connection_server]},
    Children = [AChild],
    RestartStrategy = {simple_one_for_one, 10, 10},
    {ok, {RestartStrategy, Children}}.

-module(myserver_connection_server).

-behaviour(gen_server).
-behaviour(ranch_protocol).

-export([stop/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
-export([start_link/4]).

-define(SERVER, ?MODULE).

-record(state, {type = undefined, ref, socket, transport, opts}).

stop() ->
    gen_server:cast(self(), stop).

start_link(Ref, Socket, Transport, Opts) ->
    gen_server:start_link(?MODULE, [Ref, Socket, Transport, Opts], []).

init(Args) ->
    [Ref, Socket, Transport, Opts] = Args,
    {ok, #state{type = accept_client, ref = Ref, socket = Socket, transport = Transport, opts = Opts}, 0}.

handle_call(Request, _From, State) ->
    io:format("Unknown handle_call request in module '~p'. Request = ~w~n", [?MODULE, Request]),
    Reply = ok,
    {reply, Reply, State}.

handle_cast(Request, State) ->
    case Request of
        stop ->
            {stop, normal, State};
        _ ->
            io:format("Unknown handle_cast request in module '~p'. Request = ~w~n", [?MODULE, Request]),
            {noreply, State}
    end.

handle_info(Info, State) ->
    Socket = State#state.socket,
    Transport = State#state.transport,
    {OK, Closed, Error} = Transport:messages(),
    {RemoteIP, RemotePort} = get_ip_and_port(Transport, Socket),
    case Info of
        timeout ->
            Type = State#state.type,
            case Type of
                accept_client ->
                    Ref = State#state.ref,
                    ok = ranch:accept_ack(Ref),
                    ok = Transport:setopts(Socket, [{active, once}]),
                    io:format(">>> Client did connect ~w:~w ('~w'). ~n", [RemoteIP, RemotePort, self()]),
                    send_data_to_client(State, [<<60, 60, 60, " Hello! Your name is ">>, erlang:pid_to_list(self()), <<"\r\n">>]),
                    NewState = State#state{type = undefined},
                    {noreply, NewState};
                _ ->
                    io:format("Unknown handle_info #state.type in module '~p'. #state.type = ~w~n", [?MODULE, Type]),
                    {noreply, State}
            end;
        {OK, Socket, Data} ->
            ok = Transport:setopts(Socket, [{active, once}]),
            io:format(">>> Data received from ~w:~w ('~w'). Data = ~p~n", [RemoteIP, RemotePort, self(), Data]),
            parse_data(Data),
            {noreply, State};
        {Closed, Socket} ->
            io:format(">>> Client '~w' did disconnected.~n", [self()]),
            {stop, normal, State};
        {Error, Socket, Reason} ->
            io:format(">>> Error happend. Client ~w:~w ('~w'). Reason = ~p~n", [RemoteIP, RemotePort, self(), Reason]),
            ok = Transport:setopts(Socket, [{active, once}]),
            {noreply, State};
        _ ->
            io:format("Unknown handle_info info. Info = ~w~n", [Info]),
            {noreply, State}
    end.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

send_data_to_client(State, Packet) ->
    Socket = State#state.socket,
    Transport = State#state.transport,
    case Transport:send(Socket, Packet) of
        ok ->
            ok;
        Error ->
            {RemoteIP, RemotePort} = get_ip_and_port(Transport, Socket),
            case Error of
                {error, closed} ->
                    io:format(">>> Client '~w' did disconnected.~n", [self()]),
                    stop();
                _ ->
                    io:format("Unknown error send data to ~w:~w ('~w'). Error = ~w. Data = ~p~n", [RemoteIP, RemotePort, self(), Error, Packet])
            end,
            ok
    end.

get_ip_and_port(Transport, Socket) ->
    PeerName = Transport:peername(Socket),
    {RemoteIP, RemotePort} = case PeerName of
                                 {ok, {Address, Port}} ->
                                     {Address, Port};
                                 _ ->
                                     {unknown_ip, unknown_port}
                             end,
    {RemoteIP, RemotePort}.
   
parse_data(Data) ->
    F = fun() ->
        <<Type:8, CommandCode:16, Parameters/binary>> = Data,
        {Type, CommandCode, Parameters}
    end,
    try F() of
        {Type, CommandCode, Parameters} ->
            io:format(">>> Get request of type '~p'. Command code '~p'. Parameters '~p'~n", [Type, CommandCode, Parameters]),
            ok
    catch
        _:_ ->
            ok
    end,
    ok.

REBAR = `which rebar`
REBAR_GET_DEPS = $(REBAR) get-deps
REBAR_UPDATE_DEPS = $(REBAR) update-deps
REBAR_COMPILE = $(REBAR) compile
REBAR_CLEAN = $(REBAR) clean

all: deps compile

deps:
	@( $(REBAR_GET_DEPS) )

update:
	@( $(REBAR_CLEAN) $(REBAR_UPDATE_DEPS) $(REBAR_COMPILE) )

compile: clean
	@( $(REBAR_COMPILE))

clean:
	@( $(REBAR_CLEAN) )

run:
	@(erl -pa ebin deps/*/ebin \
	      -s application start myserver)

.PHONY: all deps update compile clean run