Erlang：一个通用的网络服务器

原文: [url=http://20bits.com/2008/06/16/erlang-a-generalized-tcp-server/]Erlang: A Generalized TCP Server[/url]

前面几篇文章里谈到了Erlang的[url=http://20bits.com/2008/05/02/network-programming-in-erlang/]gen_tcp网络编程[/url]和Erlang/OPT的[url=http://20bits.com/2008/06/09/erlang-a-generic-server-tutorial/]gen_server[/url]模块，现在让我们将它们两者绑定在一起

大多数人认为“服务器”意味着网络服务器，但Erlang使用这个术语时表达的是更抽象的意义
gen_serer在Erlang里是基于它的消息传递协议来操作的服务器，我们可以在此基础上嫁接一个TCP服务器，但这需要一些工作

[b]网络服务器的结构[/b]
大部分网络服务器有相似的架构
首先它们创建一个监听socket来监听接收的连接
然后它们进入一个接收状态，在这里一直循环接收新的连接，直到结束（结束表示连接已经到达并开始真正的client/server工作）

先看看前面网络编程里的echo server的例子：
[code]
-module(echo).
-author('Jesse E.I. Farmer <jesse@20bits.com>').
-export([listen/1]).

-define(TCP_OPTIONS, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]).

% Call echo:listen(Port) to start the service.
listen(Port) ->
{ok, LSocket} = gen_tcp:listen(Port, ?TCP_OPTIONS),
accept(LSocket).

% Wait for incoming connections and spawn the echo loop when we get one.
accept(LSocket) ->
{ok, Socket} = gen_tcp:accept(LSocket),
spawn(fun() -> loop(Socket) end),
accept(LSocket).

% Echo back whatever data we receive on Socket.
loop(Socket) ->
case gen_tcp:recv(Socket, 0) of
{ok, Data} ->
gen_tcp:send(Socket, Data),
loop(Socket);
{error, closed} ->
ok
end.
[/code]
你可以看到，listen会创建一个监听socket并马上调用accept
accept会等待进来的连接，创建一个新的worker（loop）来处理真正的工作，然后等待下一个连接

在这部分代码里，父进程拥有listen socket和accept loop两者
后面我们会看到，如果我们集成accept/listen loop和gen_server的话这样做并不好

[b]抽象网络服务器[/b]
网络服务器有两部分：连接处理和业务逻辑
上面讲到，连接处理对每个网络服务器都是几乎一样的
理想状态下我们可以这样做：
[code]
-module(my_server).
start(Port) ->
connection_handler:start(my_server, Port, businees_logic).

business_logic(Socket) ->
% Read data from the network socket and do our thang!
[/code]
让我们继续完成它

[b]实现一个通用网络服务器[/b]
使用gen_server来实现一个网络服务器的问题是，gen_tcp:accept调用是堵塞的
如果我们在服务器的初始化例程里调用它，那么整个gen_server机制都会堵塞，直到客户端建立连接

有两种方式来绕过这个问题
一种方式为使用低级连接机制来支持非堵塞（或异步）accept
有许多方法来支持这样做，最值得注意的是gen_tcp:controlling_process，它帮你管理当客户端建立连接时谁接受了什么消息

我认为另一种比较简单而更优雅的方式是，[color=red]一个单独的进程来监听socket[/color]
该进程做两件事：监听“接收连接”消息以及分配新的接收器
当它接收一条新的“接收连接”的消息时，就知道该分配新的接收器了

接收器可以任意调用堵塞的gen_tcp:accept，因为它允许在自己的进程里
当它接受一个连接后，它发出一条异步消息传回给父进程，并且立即调用业务逻辑方法

这里是代码，我加了一些注释，希望可读性还可以：
[code]
-module(socket_server).
-author('Jesse E.I. Farmer <jesse@20bits.com>').
-behavior(gen_server).

-export([init/1, code_change/3, handle_call/3, handle_cast/2, handle_info/2, terminate/2]).
-export([accept_loop/1]).
-export([start/3]).

-define(TCP_OPTIONS, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]).

-record(server_state, {
port,
loop,
ip=any,
lsocket=null}).

start(Name, Port, Loop) ->
State = #server_state{port = Port, loop = Loop},
gen_server:start_link({local, Name}, ?MODULE, State, []).

init(State = #server_state{port=Port}) ->
case gen_tcp:listen(Port, ?TCP_OPTIONS) of
{ok, LSocket} ->
NewState = State#server_state{lsocket = LSocket},
{ok, accept(NewState)};
{error, Reason} ->
{stop, Reason}
end.

handle_cast({accepted, _Pid}, State=#server_state{}) ->
{noreply, accept(State)}.

accept_loop({Server, LSocket, {M, F}}) ->
{ok, Socket} = gen_tcp:accept(LSocket),
% Let the server spawn a new process and replace this loop
% with the echo loop, to avoid blocking
gen_server:cast(Server, {accepted, self()}),
M:F(Socket).

% To be more robust we should be using spawn_link and trapping exits
accept(State = #server_state{lsocket=LSocket, loop = Loop}) ->
proc_lib:spawn(?MODULE, accept_loop, [{self(), LSocket, Loop}]),
State.

% These are just here to suppress warnings.
handle_call(_Msg, _Caller, State) -> {noreply, State}.
handle_info(_Msg, Library) -> {noreply, Library}.
terminate(_Reason, _Library) -> ok.
code_change(_OldVersion, Library, _Extra) -> {ok, Library}.
[/code]
[color=red]我们使用gen_server:cast来传递异步消息给监听进程，当监听进程接受accepted消息后，它分配一个新的接收器[/color]

目前，这个服务器不是很健壮，因为如果无论什么原因活动的接收器失败以后，服务器会停止接收新的连接
为了让它变得更像OTP，我们因该捕获异常退出并且在连接失败时分配新的接收器

[b]一个通用的echo服务器[/b]
echo服务器是最简单的服务器，让我们使用我们新的抽象socket服务器来写它:
[code]
-module(echo_server).
-author('Jesse E.I. Farmer <jesse@20bits.com>').

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

% echo_server specific code
start() ->
socket_server:start(?MODULE, 7000, {?MODULE, loop}).
loop(Socket) ->
case gen_tcp:recv(Socket, 0) of
{ok, Data} ->
gen_tcp:send(Socket, Data),
loop(Socket);
{error, closed} ->
ok
end.
[/code]
你可以看到，服务器只含有自己的业务逻辑
连接处理被封装到socket_server里面
而这里的loop方法也和最初的echo服务器一样

希望你可以从中学到点什么，[color=red]我觉得我开始理解Erlang了[/color]

欢迎回复，特别关于是如何改进我的代码，cheers！