🕹️ 🎼 🧕🏼 OTP सिद्धांतों का उपयोग करके एक गैर-अवरुद्ध टीसीपी सर्वर बनाना 🅰️ 👋🏻 👴🏼

प्रविष्टि

यह माना जाता है कि इस मैनुअल के पाठक पहले से ही gen_server और gen_fsm के व्यवहार, TCP सॉकेट इंटरैक्शन के साथ gen_tcp मॉड्यूल, सक्रिय और निष्क्रिय सॉकेट मोड और "OTP सुपरवाइजर" के सिद्धांत से परिचित हैं।

ओटीपी मजबूत अनुप्रयोगों के निर्माण के लिए सुविधाजनक उपकरण प्रदान करता है। भाग में, यह सामान्य कार्यक्षमता को व्यवहार में पूरा करके पूरा किया जाता है, जैसे कि gen_server और gen_fsm , जो ओटीपी पर्यवेक्षकों के एक पदानुक्रम द्वारा जुड़े होते हैं।

कई प्रसिद्ध टीसीपी सर्वर टेम्पलेट हैं। हम जिस पर विचार करने जा रहे हैं, उसमें एक सुनने की प्रक्रिया और प्रत्येक जुड़े ग्राहक के लिए एक नई FSM प्रक्रिया बनाने की प्रक्रिया शामिल है। यद्यपि gen_tcp मॉड्यूल के माध्यम से OTP में TCP कनेक्शन के लिए समर्थन है, लेकिन OTP के सिद्धांतों के आधार पर एक गैर-अवरुद्ध टीसीपी सर्वर बनाने के लिए कोई मानक व्यवहार नहीं है। एक नॉन-ब्लॉकिंग सर्वर द्वारा, हमारा मतलब है कि सुनने की प्रक्रिया और FSM प्रक्रिया को किसी भी अवरोधक कॉल नहीं करना चाहिए और आने वाले संदेशों (उदाहरण के लिए, कॉन्फ़िगरेशन परिवर्तन, पुनरारंभ, आदि) के लिए बिना टाइमआउट के जवाब देना चाहिए। ध्यान दें कि Erlang संदर्भ में लॉक करने का अर्थ है, Erlang प्रक्रिया को लॉक करना, न कि ऑपरेटिंग सिस्टम प्रक्रिया।

इस गाइड में, हम दिखाते हैं कि gen_server और gen_fsm का उपयोग करके एक गैर-अवरुद्ध टीसीपी सर्वर कैसे बनाया जाए , जो एप्लिकेशन के व्यवहार पर नियंत्रण प्रदान करता है और ओटीपी के सिद्धांतों का पूरी तरह से पालन करता है।

एक पाठक जो ओटीपी से परिचित नहीं है, उसे सलाह दी जाती है कि ब्लॉकिंग कॉल gen_tcp: connect / 3 और gen_tcp: acceept / 1 का उपयोग ओटीपी के बिना किए जाने वाले दोष-सहिष्णु सर्वर का निर्माण करने के लिए जो आर्मस्ट्रांग के गाइड पर ध्यान दें।

सर्वर संरचना

हमारे सर्वर के डिज़ाइन में tcp_server_app मुख्य अनुप्रयोग पर्यवेक्षक प्रक्रिया को पुनरारंभ करने की रणनीति one_for_one और दो बच्चे प्रक्रियाओं के साथ शामिल किया जाएगा। जिनमें से पहला जीन_सर्वर के रूप में लागू एक सुनने की प्रक्रिया है, जो क्लाइंट कनेक्शन के बारे में अतुल्यकालिक सूचनाओं की प्रतीक्षा करेगा। दूसरा एक और tcp_client_sup एप्लिकेशन पर्यवेक्षक है और क्लाइंट SAS के प्रसंस्करण के लिए FSM प्रक्रिया शुरू करने और मानक एसएएसएल त्रुटि रिपोर्ट का उपयोग करके असामान्य शटडाउन रिकॉर्ड करने के लिए जिम्मेदार है।

इस सामग्री की सादगी के लिए, क्लाइंट अनुरोध हैंडलर (tcp_echo_fsm) एक "इको" सर्वर प्रदान करेगा जो क्लाइंट अनुरोध वापस करेगा।

आवेदन व्यवहार और पर्यवेक्षकों

अपना एप्लिकेशन बनाने के लिए, हमें "सुपरवाइज़र" और "एप्लिकेशन" व्यवहार कॉलबैक फ़ंक्शन को लागू करने वाले मॉड्यूल लिखना होगा। यद्यपि परंपरागत रूप से इन कार्यों को अलग-अलग मॉड्यूल में लागू किया जाता है, उनकी संक्षिप्तता को देखते हुए, हम उन्हें एक में जोड़ देंगे।

एक अतिरिक्त बोनस के रूप में, हम get_app_env फ़ंक्शन को कार्यान्वित करते हैं, जो दिखाता है कि कॉन्फ़िगरेशन मापदंडों को कैसे संसाधित किया जाए, साथ ही स्टार्टअप पर एमुलेटर की कमांड लाइन पैरामीटर।

पर्यवेक्षक पदानुक्रम के दो स्तरों के लिए init / 1 फ़ंक्शन के दो उदाहरणों की आवश्यकता होती है। चूंकि दो अलग-अलग पुनरारंभ रणनीतियों का उपयोग किया जाता है, इसलिए हम उन्हें विभिन्न स्तरों पर लागू करते हैं।

आवेदन शुरू करने के बाद, tcp_server_app: start / 2 कॉलबैक फ़ंक्शन पर्यवेक्षक को कॉल करता है : start_link / 2 फ़ंक्शन, जो tcp_server_app: init ([पोर्ट, मॉड्यूल]) को कॉल करके मुख्य एप्लिकेशन पर्यवेक्षक बनाता है। यह पर्यवेक्षक tcp_listener प्रक्रिया बनाता है और tcp_client_sup चाइल्ड सुपरवाइज़र जो क्लाइंट कनेक्शन को संभालने के लिए जिम्मेदार होता है। Init फ़ंक्शन में मॉड्यूल तर्क FSM क्लाइंट कनेक्शन हैंडलर का नाम है (इस मामले में, tcp_echo_fsm )।

टीसीपी सर्वर अनुप्रयोग (tcp_server_app.erl):

-module(tcp_server_app). -author('saleyn@gmail.com'). -behaviour(application). %% Internal API -export([start_client/0]). %% Application and Supervisor callbacks -export([start/2, stop/1, init/1]). -define(MAX_RESTART, 5). -define(MAX_TIME, 60). -define(DEF_PORT, 2222). %% A startup function for spawning new client connection handling FSM. %% To be called by the TCP listener process. start_client() -> supervisor:start_child(tcp_client_sup, []). %%---------------------------------------------------------------------- %% Application behaviour callbacks %%---------------------------------------------------------------------- start(_Type, _Args) -> ListenPort = get_app_env(listen_port, ?DEF_PORT), supervisor:start_link({local, ?MODULE}, ?MODULE, [ListenPort, tcp_echo_fsm]). stop(_S) -> ok. %%---------------------------------------------------------------------- %% Supervisor behaviour callbacks %%---------------------------------------------------------------------- init([Port, Module]) -> {ok, {_SupFlags = {one_for_one, ?MAX_RESTART, ?MAX_TIME}, [ % TCP Listener { tcp_server_sup, % Id = internal id {tcp_listener,start_link,[Port,Module]}, % StartFun = {M, F, A} permanent, % Restart = permanent | transient | temporary 2000, % Shutdown = brutal_kill | int() >= 0 | infinity worker, % Type = worker | supervisor [tcp_listener] % Modules = [Module] | dynamic }, % Client instance supervisor { tcp_client_sup, {supervisor,start_link,[{local, tcp_client_sup}, ?MODULE, [Module]]}, permanent, % Restart = permanent | transient | temporary infinity, % Shutdown = brutal_kill | int() >= 0 | infinity supervisor, % Type = worker | supervisor [] % Modules = [Module] | dynamic } ] } }; init([Module]) -> {ok, {_SupFlags = {simple_one_for_one, ?MAX_RESTART, ?MAX_TIME}, [ % TCP Client { undefined, % Id = internal id {Module,start_link,[]}, % StartFun = {M, F, A} temporary, % Restart = permanent | transient | temporary 2000, % Shutdown = brutal_kill | int() >= 0 | infinity worker, % Type = worker | supervisor [] % Modules = [Module] | dynamic } ] } }. %%---------------------------------------------------------------------- %% Internal functions %%---------------------------------------------------------------------- get_app_env(Opt, Default) -> case application:get_env(application:get_application(), Opt) of {ok, Val} -> Val; _ -> case init:get_argument(Opt) of [[Val | _]] -> Val; error -> Default end end.

सुनने की प्रक्रिया

Gen_tcp मॉड्यूल की कमियों में से एक यह है कि यह केवल अवरुद्ध कनेक्शन के लिए एक इंटरफ़ेस प्रदान करता है।

Prim_inet मॉड्यूल के परीक्षण ने एक दिलचस्प तथ्य दिखाया कि क्लाइंट कनेक्शन को स्वीकार करने के लिए नेटवर्क ड्राइवर को कमांड अतुल्यकालिक है। हालांकि यह प्रलेखित नहीं है, जिसका अर्थ है कि ओटीपी टीम कभी भी इसे बदल सकती है, हम इस कार्यक्षमता का उपयोग अपने सर्वर को बनाने के लिए करेंगे।

सुनने की प्रक्रिया gen_server के रूप में कार्यान्वित की जाती है ।

टीसीपी श्रोता प्रक्रिया (tcp_listener.erl):

 -module(tcp_listener). -author('saleyn@gmail.com'). -behaviour(gen_server). %% External API -export([start_link/2]). %% gen_server callbacks -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]). -record(state, { listener, % Listening socket acceptor, % Asynchronous acceptor's internal reference module % FSM handling module }). %%-------------------------------------------------------------------- %% @spec (Port::integer(), Module) -> {ok, Pid} | {error, Reason} % %% @doc Called by a supervisor to start the listening process. %% @end %%---------------------------------------------------------------------- start_link(Port, Module) when is_integer(Port), is_atom(Module) -> gen_server:start_link({local, ?MODULE}, ?MODULE, [Port, Module], []). %%%------------------------------------------------------------------------ %%% Callback functions from gen_server %%%------------------------------------------------------------------------ %%---------------------------------------------------------------------- %% @spec (Port::integer()) -> {ok, State} | %% {ok, State, Timeout} | %% ignore | %% {stop, Reason} %% %% @doc Called by gen_server framework at process startup. %% Create listening socket. %% @end %%---------------------------------------------------------------------- init([Port, Module]) -> process_flag(trap_exit, true), Opts = [binary, {packet, 2}, {reuseaddr, true}, {keepalive, true}, {backlog, 30}, {active, false}], case gen_tcp:listen(Port, Opts) of {ok, Listen_socket} -> %%Create first accepting process {ok, Ref} = prim_inet:async_accept(Listen_socket, -1), {ok, #state{listener = Listen_socket, acceptor = Ref, module = Module}}; {error, Reason} -> {stop, Reason} end. %%------------------------------------------------------------------------- %% @spec (Request, From, State) -> {reply, Reply, State} | %% {reply, Reply, State, Timeout} | %% {noreply, State} | %% {noreply, State, Timeout} | %% {stop, Reason, Reply, State} | %% {stop, Reason, State} %% @doc Callback for synchronous server calls. If `{stop, ...}' tuple %% is returned, the server is stopped and `terminate/2' is called. %% @end %% @private %%------------------------------------------------------------------------- handle_call(Request, _From, State) -> {stop, {unknown_call, Request}, State}. %%------------------------------------------------------------------------- %% @spec (Msg, State) ->{noreply, State} | %% {noreply, State, Timeout} | %% {stop, Reason, State} %% @doc Callback for asyncrous server calls. If `{stop, ...}' tuple %% is returned, the server is stopped and `terminate/2' is called. %% @end %% @private %%------------------------------------------------------------------------- handle_cast(_Msg, State) -> {noreply, State}. %%------------------------------------------------------------------------- %% @spec (Msg, State) ->{noreply, State} | %% {noreply, State, Timeout} | %% {stop, Reason, State} %% @doc Callback for messages sent directly to server's mailbox. %% If `{stop, ...}' tuple is returned, the server is stopped and %% `terminate/2' is called. %% @end %% @private %%------------------------------------------------------------------------- handle_info({inet_async, ListSock, Ref, {ok, CliSocket}}, #state{listener=ListSock, acceptor=Ref, module=Module} = State) -> try case set_sockopt(ListSock, CliSocket) of ok -> ok; {error, Reason} -> exit({set_sockopt, Reason}) end, %% New client connected - spawn a new process using the simple_one_for_one %% supervisor. {ok, Pid} = tcp_server_app:start_client(), gen_tcp:controlling_process(CliSocket, Pid), %% Instruct the new FSM that it owns the socket. Module:set_socket(Pid, CliSocket), %% Signal the network driver that we are ready to accept another connection case prim_inet:async_accept(ListSock, -1) of {ok, NewRef} -> ok; {error, NewRef} -> exit({async_accept, inet:format_error(NewRef)}) end, {noreply, State#state{acceptor=NewRef}} catch exit:Why -> error_logger:error_msg("Error in async accept: ~p.\n", [Why]), {stop, Why, State} end; handle_info({inet_async, ListSock, Ref, Error}, #state{listener=ListSock, acceptor=Ref} = State) -> error_logger:error_msg("Error in socket acceptor: ~p.\n", [Error]), {stop, Error, State}; handle_info(_Info, State) -> {noreply, State}. %%------------------------------------------------------------------------- %% @spec (Reason, State) -> any %% @doc Callback executed on server shutdown. It is only invoked if %% `process_flag(trap_exit, true)' is set by the server process. %% The return value is ignored. %% @end %% @private %%------------------------------------------------------------------------- terminate(_Reason, State) -> gen_tcp:close(State#state.listener), ok. %%------------------------------------------------------------------------- %% @spec (OldVsn, State, Extra) -> {ok, NewState} %% @doc Convert process state when code is changed. %% @end %% @private %%------------------------------------------------------------------------- code_change(_OldVsn, State, _Extra) -> {ok, State}. %%%------------------------------------------------------------------------ %%% Internal functions %%%------------------------------------------------------------------------ %% Taken from prim_inet. We are merely copying some socket options from the %% listening socket to the new client socket. set_sockopt(ListSock, CliSocket) -> true = inet_db:register_socket(CliSocket, inet_tcp), case prim_inet:getopts(ListSock, [active, nodelay, keepalive, delay_send, priority, tos]) of {ok, Opts} -> case prim_inet:setopts(CliSocket, Opts) of ok -> ok; Error -> gen_tcp:close(CliSocket), Error end; Error -> gen_tcp:close(CliSocket), Error end.

इस मॉड्यूल में, init / 1 दो पैरामीटर लेता है - पोर्ट नंबर जिसे सुनने की प्रक्रिया को खोलना चाहिए और क्लाइंट कनेक्शन हैंडलर का नाम। इनिशियलाइज़ेशन फ़ंक्शन सॉकेट को निष्क्रिय मोड में खोलता है। ऐसा इसलिए किया जाता है ताकि क्लाइंट से प्राप्त डेटा के प्रवाह पर हमारा नियंत्रण हो।

इस कोड का सबसे दिलचस्प हिस्सा prim_inet: async_accept / 2 के लिए कॉल है। इस काम को करने के लिए, हमें set_sockopt / 2 फ़ंक्शन से OTP आंतरिक कोड का हिस्सा कॉपी करने की आवश्यकता है, जो सॉकेट को पंजीकृत करने और क्लाइंट सॉकेट के लिए कुछ विकल्पों की प्रतिलिपि बनाने का काम करता है।

जैसे ही क्लाइंट सॉकेट जुड़ा होता है, नेटवर्क ड्राइवर इस संदेश की श्रवण प्रक्रिया को {inet_async, ListSock, Ref, {OK, CliSocket}} का उपयोग करके सूचित करेगा। फिलहाल, हम क्लाइंट अनुरोधों को संसाधित करने और इसे CliSocket पर स्थानांतरित करने के लिए प्रक्रिया का एक उदाहरण लॉन्च कर रहे हैं।

क्लाइंट संदेशों को संसाधित करने की प्रक्रिया

जबकि tcp_listener एक सामान्य कार्यान्वयन है, tcp_echo_fsm एक TCP सर्वर बनाने के तरीके का वर्णन करने के लिए FSM ठूंठ से अधिक कुछ नहीं है। इस मॉड्यूल से दो फ़ंक्शन का निर्यात किया जाना चाहिए - tcp_client_sup पर्यवेक्षक और सुनने की प्रक्रिया के लिए set_socket / 2 के लिए start_link / ताकि क्लाइंट संदेश प्रसंस्करण प्रक्रिया को बाद में सूचित किया जाए कि यह सॉकेट का स्वामी बन जाता है और {सक्रिय, एक बार} सेट करके संदेश प्राप्त करना शुरू कर सकता है। {सक्रिय, सत्य} विकल्प।

हम श्रवण प्रक्रिया और ग्राहक के बीच उपयोग किए जाने वाले सिंक्रनाइज़ेशन पैटर्न पर जोर देना चाहते हैं, ताकि गलत (सुनने) प्रक्रिया में उनके स्थानांतरण के कारण संभावित संदेश हानि से बचा जा सके। सॉकेट का स्वामित्व करने वाली प्रक्रिया इसे निष्क्रिय मोड में खुला रखती है। अगला, क्लाइंट प्रक्रिया एक सॉकेट प्राप्त करती है जो सुनने की प्रक्रिया से विकल्प (निष्क्रिय मोड सहित) विरासत में मिलती है। सॉकेट स्वामित्व को ग्राहक प्रक्रिया में gen_tcp: control_process / 2 और set_socket / 2 कहकर स्थानांतरित किया जाता है, जो क्लाइंट प्रक्रिया को सूचित करता है कि यह सॉकेट से संदेश प्राप्त करना शुरू कर सकता है। जब तक सॉकेट को सक्रिय मोड पर सेट नहीं किया जाता है, तब तक प्राप्त सभी डेटा सॉकेट बफर में संग्रहीत किए जाएंगे।

जब सॉकेट का स्वामित्व WAIT_FOR_SOCKET राज्य में क्लाइंट FSM प्रक्रिया में स्थानांतरित हो जाता है, तो नेटवर्क ड्राइवर को एक बार में एक संदेश भेजने में सक्षम करने के लिए {सक्रिय, एक बार} मोड सेट किया जाता है। यह ओटीपी सिद्धांत है जिसका उपयोग डेटा के प्रवाह पर नियंत्रण बनाए रखने और प्रक्रिया कतार में संदेशों और टीसीपी ट्रैफ़िक को मिलाने से बचने के लिए किया जाता है।

FSM राज्यों को tcp_echo_fsm मॉड्यूल में विशेष कार्यों का उपयोग करके कार्यान्वित किया जाता है, जो नामकरण सम्मेलन का उपयोग करता है। FSM में दो राज्य होते हैं। WAIT_FOR_SOCKET प्रारंभिक अवस्था है जिसमें FSM सॉकेट के स्वामित्व की प्रतीक्षा कर रहा है, और WAIT_FOR_DATA , जो क्लाइंट से एक टीसीपी संदेश के इंतजार की स्थिति है। इस स्थिति में, FSM एक विशेष "टाइमआउट" संदेश भी संसाधित करता है, जिसका अर्थ है कि क्लाइंट की कोई गतिविधि नहीं है और यह क्लाइंट के साथ कनेक्शन को बंद करने का कारण बनता है।

 -module(tcp_echo_fsm). -author('saleyn@gmail.com'). -behaviour(gen_fsm). -export([start_link/0, set_socket/2]). %% gen_fsm callbacks -export([init/1, handle_event/3, handle_sync_event/4, handle_info/3, terminate/3, code_change/4]). %% FSM States -export([ 'WAIT_FOR_SOCKET'/2, 'WAIT_FOR_DATA'/2 ]). -record(state, { socket, % client socket addr % client address }). -define(TIMEOUT, 120000). %%%------------------------------------------------------------------------ %%% API %%%------------------------------------------------------------------------ %%------------------------------------------------------------------------- %% @spec (Socket) -> {ok,Pid} | ignore | {error,Error} %% @doc To be called by the supervisor in order to start the server. %% If init/1 fails with Reason, the function returns {error,Reason}. %% If init/1 returns {stop,Reason} or ignore, the process is %% terminated and the function returns {error,Reason} or ignore, %% respectively. %% @end %%------------------------------------------------------------------------- start_link() -> gen_fsm:start_link(?MODULE, [], []). set_socket(Pid, Socket) when is_pid(Pid), is_port(Socket) -> gen_fsm:send_event(Pid, {socket_ready, Socket}). %%%------------------------------------------------------------------------ %%% Callback functions from gen_server %%%------------------------------------------------------------------------ %%------------------------------------------------------------------------- %% Func: init/1 %% Returns: {ok, StateName, StateData} | %% {ok, StateName, StateData, Timeout} | %% ignore | %% {stop, StopReason} %% @private %%------------------------------------------------------------------------- init([]) -> process_flag(trap_exit, true), {ok, 'WAIT_FOR_SOCKET', #state{}}. %%------------------------------------------------------------------------- %% Func: StateName/2 %% Returns: {next_state, NextStateName, NextStateData} | %% {next_state, NextStateName, NextStateData, Timeout} | %% {stop, Reason, NewStateData} %% @private %%------------------------------------------------------------------------- 'WAIT_FOR_SOCKET'({socket_ready, Socket}, State) when is_port(Socket) -> % Now we own the socket inet:setopts(Socket, [{active, once}, {packet, 2}, binary]), {ok, {IP, _Port}} = inet:peername(Socket), {next_state, 'WAIT_FOR_DATA', State#state{socket=Socket, addr=IP}, ?TIMEOUT}; 'WAIT_FOR_SOCKET'(Other, State) -> error_logger:error_msg("State: 'WAIT_FOR_SOCKET'. Unexpected message: ~p\n", [Other]), %% Allow to receive async messages {next_state, 'WAIT_FOR_SOCKET', State}. %% Notification event coming from client 'WAIT_FOR_DATA'({data, Data}, #state{socket=S} = State) -> ok = gen_tcp:send(S, Data), {next_state, 'WAIT_FOR_DATA', State, ?TIMEOUT}; 'WAIT_FOR_DATA'(timeout, State) -> error_logger:error_msg("~p Client connection timeout - closing.\n", [self()]), {stop, normal, State}; 'WAIT_FOR_DATA'(Data, State) -> io:format("~p Ignoring data: ~p\n", [self(), Data]), {next_state, 'WAIT_FOR_DATA', State, ?TIMEOUT}. %%------------------------------------------------------------------------- %% Func: handle_event/3 %% Returns: {next_state, NextStateName, NextStateData} | %% {next_state, NextStateName, NextStateData, Timeout} | %% {stop, Reason, NewStateData} %% @private %%------------------------------------------------------------------------- handle_event(Event, StateName, StateData) -> {stop, {StateName, undefined_event, Event}, StateData}. %%------------------------------------------------------------------------- %% Func: handle_sync_event/4 %% Returns: {next_state, NextStateName, NextStateData} | %% {next_state, NextStateName, NextStateData, Timeout} | %% {reply, Reply, NextStateName, NextStateData} | %% {reply, Reply, NextStateName, NextStateData, Timeout} | %% {stop, Reason, NewStateData} | %% {stop, Reason, Reply, NewStateData} %% @private %%------------------------------------------------------------------------- handle_sync_event(Event, _From, StateName, StateData) -> {stop, {StateName, undefined_event, Event}, StateData}. %%------------------------------------------------------------------------- %% Func: handle_info/3 %% Returns: {next_state, NextStateName, NextStateData} | %% {next_state, NextStateName, NextStateData, Timeout} | %% {stop, Reason, NewStateData} %% @private %%------------------------------------------------------------------------- handle_info({tcp, Socket, Bin}, StateName, #state{socket=Socket} = StateData) -> % Flow control: enable forwarding of next TCP message inet:setopts(Socket, [{active, once}]), ?MODULE:StateName({data, Bin}, StateData); handle_info({tcp_closed, Socket}, _StateName, #state{socket=Socket, addr=Addr} = StateData) -> error_logger:info_msg("~p Client ~p disconnected.\n", [self(), Addr]), {stop, normal, StateData}; handle_info(_Info, StateName, StateData) -> {noreply, StateName, StateData}. %%------------------------------------------------------------------------- %% Func: terminate/3 %% Purpose: Shutdown the fsm %% Returns: any %% @private %%------------------------------------------------------------------------- terminate(_Reason, _StateName, #state{socket=Socket}) -> (catch gen_tcp:close(Socket)), ok. %%------------------------------------------------------------------------- %% Func: code_change/4 %% Purpose: Convert process state when code is changed %% Returns: {ok, NewState, NewStateData} %% @private %%------------------------------------------------------------------------- code_change(_OldVsn, StateName, StateData, _Extra) -> {ok, StateName, StateData}.

आवेदन विवरण

OTP एप्लिकेशन बनाने का एक और आवश्यक हिस्सा एक कॉन्फ़िगरेशन फ़ाइल बनाना है जिसमें एप्लिकेशन नाम, संस्करण, प्रारंभ मॉड्यूल और पर्यावरण चर शामिल हैं।

आवेदन फ़ाइल (tcp_server.app):

 {application, tcp_server, [ {description, "Demo TCP server"}, {vsn, "1.0"}, {id, "tcp_server"}, {modules, [tcp_listener, tcp_echo_fsm]}, {registered, [tcp_server_sup, tcp_listener]}, {applications, [kernel, stdlib]}, %% %% mod: Specify the module name to start the application, plus args %% {mod, {tcp_server_app, []}}, {env, []} ] }.

संकलन

इस एप्लिकेशन के लिए निम्न निर्देशिका संरचना बनाएं:

 ./tcp_server ./tcp_server/ebin/ ./tcp_server/ebin/tcp_server.app ./tcp_server/src/tcp_server_app.erl ./tcp_server/src/tcp_listener.erl ./tcp_server/src/tcp_echo_fsm.erl

 $ cd tcp_server/src $ for f in tcp*.erl ; do erlc +debug_info -o ../ebin $f

लांच

हम एसएएसएल समर्थन के साथ एक एरलांग शेल लॉन्च करने जा रहे हैं ताकि हम अपने आवेदन के लिए प्रक्रियाओं और त्रुटि रिपोर्ट की स्थिति देख सकें। इसके अलावा, हम पर्यवेक्षकों के पदानुक्रम को नेत्रहीन रूप से जांचने के लिए appmon ऐप लॉन्च करने जा रहे हैं।

 $ cd ../ebin $ erl -boot start_sasl ... 1> appmon:start(). {ok,<0.44.0>} 2> application:start(tcp_server). ok

अब एप्लिकेशन सुपरवाइज़र के पदानुक्रम को प्रदर्शित करने के लिए appmon एप्लिकेशन में tcp_server बटन पर क्लिक करें।

 3> {ok,S} = gen_tcp:connect({127,0,0,1},2222,[{packet,2}]). {ok,#Port<0.150>}

हमने अभी एक नया इको सर्वर क्लाइंट कनेक्शन शुरू किया है।

 4> gen_tcp:send(S,<<"hello">>). ok 5> f(M), receive M -> M end. {tcp,#Port<0.150>,"hello"}

हमने जाँच की कि इको सर्वर अपेक्षित रूप से काम कर रहा था। अब चलो सर्वर पर एक क्लाइंट कनेक्शन को "डालने" की कोशिश करें और त्रुटि संदेश की पीढ़ी को देखें।

 6> [{_,Pid,_,_}] = supervisor:which_children(tcp_client_sup). [{undefined,<0.64.0>,worker,[]}] 7> exit(Pid,kill). true =SUPERVISOR REPORT==== 31-Jul-2007::14:33:49 === Supervisor: {local,tcp_client_sup} Context: child_terminated Reason: killed Offender: [{pid,<0.77.0>}, {name,undefined}, {mfa,{tcp_echo_fsm,start_link,[]}}, {restart_type,temporary}, {shutdown,2000}, {child_type,worker}]

ध्यान दें कि यदि आप सर्वर बड़ी संख्या में कनेक्शन के साथ लोड हो जाते हैं, तो ऑपरेटिंग सिस्टम में एक निश्चित सीमा के बाद सुनने की प्रक्रिया नए कनेक्शन को स्वीकार नहीं कर सकती है। इस स्थिति में, आपको एक त्रुटि संदेश दिखाई देगा:

 "too many open files"

निष्कर्ष

OTP गैर-अवरुद्ध टीसीपी सर्वर के निर्माण के लिए बिल्डिंग ब्लॉक प्रदान करता है। यह गाइड दिखाता है कि मानक ओटीपी व्यवहार का उपयोग करके एक सरल सर्वर कैसे बनाया जाए।

OTP सिद्धांतों का उपयोग करके एक गैर-अवरुद्ध टीसीपी सर्वर बनाना