erlang tcp服务器和客户端的简单实现

看了《erlang程序设计》的lib_chan代码，自己也试着写了一个，不过大部分代码都摘自lib_chan，做了一个改编。

-module(lib_comm).

-export([start_server/1, stop_server/1, start_client/2, send/2]).

stop_server(Port) when is_integer(Port) ->
    ServerName = list_to_atom("portServer" ++ integer_to_list(Port)),
    case whereis(ServerName) of
	undefined ->
	    not_started;
	Pid ->
	    exit(Pid, kill),
	    (catch unregister(ServerName)),
	    stopped
    end.

start_server(Port) ->
	io:format("start_server(), Pid: ~p~n", [self()]),
	spawn(fun() -> start_port_server(Port) end).

start_port_server(Port) ->
	io:format("start_port_server(), Pid: ~p~n", [self()]),
	start_raw_server(Port, fun(Socket) -> start_port_instance(Socket) end, 100, 4).

start_raw_server(Port, Fun, Max, PacketLength) ->
	io:format("start_raw_server(), Pid: ~p~n", [self()]),
	ServerName = list_to_atom("portServer" ++ integer_to_list(Port)),
	case whereis(ServerName) of
		undefined ->
			Self = self(),
			Pid = spawn_link(fun() -> cold_start(Self,Port,Fun,Max,PacketLength) end),
			receive
				{Pid, ok} ->
					register(ServerName, Pid),
					{ok, self()};
				{Pid, Error} ->
					Error
			end;
		_Pid ->
	    	{error, already_started}
    end.

cold_start(Master,Port,Fun,Max,PacketLength) ->
	io:format("cold_start(), Pid: ~p~n", [self()]),

	process_flag(trap_exit, true),
	io:format("Starting a port server on ~p...~n",[Port]),
	case gen_tcp:listen(Port, [binary, {nodelay,true}, {packet, PacketLength}, {reuseaddr, true}, {active, true}]) of
		{ok, Listen} ->
			io:format("Listening to:~p~n",[Listen]),
			Master ! {self(), ok},
			_New = start_accept(Listen, Fun),
			
			io:format("New 1 : ~p~n", [_New]),
	    	socket_loop(Listen, Master, [], Fun, Max);
		Error ->
			Master ! {self(), Error}
	end.

start_accept(Listen, Fun) ->
    S = self(),
    spawn_link(fun() -> start_child(S, Listen, Fun) end).	

start_child(Parent, Listen, Fun) ->
	io:format("Pid: ~p gen_tcp:accept ~n", [self()]),
	case gen_tcp:accept(Listen) of
		{ok, Socket} ->
			io:format("Pid: ~p accepted ~n", [self()]),
			Parent ! {istarted, self()},		    % tell the controller
			inet:setopts(Socket, [ {packet,4}, binary, {nodelay,true}, {active, true}]), 
			io:format("running the child:~p Fun=~p~n", [Socket, Fun]),
			process_flag(trap_exit, true),
			case (catch Fun(Socket)) of
				{'EXIT', normal} ->
		    		true;
				{'EXIT', Why} ->
				    io:format("Port process dies with exit:~p~n",[Why]),
				    true;
				_ -> 
		    		true %% not an exit so everything's ok
	    	end
	end.

socket_loop(Listen, Master, Active, Fun, Max) ->
	receive
		{istarted, Pid} ->
			io:format("Pid = ~p istarted ~n", [Pid]),
	    	Active1 = [Pid|Active],
	    	possibly_start_another(Master, Listen,Active1,Fun,Max);
	    {'EXIT', Master, _Why} ->
	    	io:format("Pid = ~p master exit, reason: ~p ~n", [Master, _Why]),
	    	socket_loop(Listen, Master, Active, Fun, Max);
	    {'EXIT', Pid, _Why} ->
	    	io:format("Pid = ~p exit, reason: ~p ~n", [Pid, _Why]),
	    	Active1 = lists:delete(Pid, Active),
	    	possibly_start_another(Master, Listen,Active1,Fun,Max);
	    _Other ->
	    	io:format("socket_loop() _Other = ~p~n", [_Other]),
	    	socket_loop(Listen, Master, Active, Fun, Max)
	end.

possibly_start_another(Master, Listen, Active, Fun, Max) ->
    case length(Active) of
	N when N < Max ->
	    _New = start_accept(Listen, Fun),
	    io:format("New 2: ~p~n", [_New]),
	    socket_loop(Master, Listen, Active, Fun,Max);
	_ ->
	    socket_loop(Master, Listen, Active, Fun, Max)
    end.

start_port_instance(Socket) ->
	process_flag(trap_exit, true),
	MessageHandler = spawn_link(fun() -> start_server_biz() end),
	message_loop(Socket, MessageHandler).

start_server_biz() ->
	server_biz_loop().

server_biz_loop() ->
	receive
		{recv, Pid, Term} ->
			io:format("server recv message ~p~n", [Term]),
			Pid ! {send, Term},
			server_biz_loop();
		{closed, Pid} ->
			Pid ! close
	end.

message_loop(Socket, Pid) ->
	receive
		{tcp, Socket, Bin} ->
		    Term = binary_to_term(Bin),
		    Pid ! {recv, self(), Term},
		    message_loop(Socket, Pid);

		{tcp_closed, Socket} ->
		    Pid ! {closed, self()};

		{'EXIT', Pid, _Why} ->
		    gen_tcp:close(Socket);

		close ->
		    gen_tcp:close(Socket);

		{send, Term}  ->
		    gen_tcp:send(Socket, term_to_binary(Term)),
		    message_loop(Socket, Pid);

		UUg ->
		    io:format("protocol error:~p~n",[UUg]),
		    message_loop(Socket, Pid)
    end.

start_client(Host, Port) ->
	Self = self(),
	spawn(fun() -> start_raw_client(Self, Host, Port) end),
	receive
		{ok, Pid} ->
			Pid;
		Error ->
			io:format("client connect failure, ~p~n", [Error]),
			Error
	end.


start_raw_client(Master, Host, Port) ->
	PacketLength = 4,
	Self = self(),
	Pid = spawn(fun() -> connect(Self, Host, Port, PacketLength) end),
	client_biz_loop(Master, Pid).

connect(Parent, Host, Port, PacketLength) ->
	case gen_tcp:connect(Host, Port, [binary, {active, true}, {packet, PacketLength}]) of
		{ok, Socket} ->
    		Parent ! {ok, self()},
    		message_loop(Socket, Parent);
		Error ->
    		Parent ! {self(), Error}
	end.

client_biz_loop(Master, Pid) ->
	receive
		{ok, Pid} ->
			Pid ! {send, "hello world"},
			Master ! {ok, Pid},
			client_biz_loop(Master, Pid);
		{recv, Pid, Term} ->
			io:format("client recv message: ~p~n", [Term]),
			client_biz_loop(Master, Pid);
		Error ->
			Master ! Error,
			Error
	end.

send(Pid, Term) -> 
	Pid ! {send, Term}.


		
    	

按照下面方式调用：

lib_comm:start_server(8080).

Pid = lib_comm:start_client("localhost", 8080).

lib_comm:send(Pid, "aaaaa").