Erlang - OTP

OTP è l'acronimo di Open Telecom Platform. È un sistema operativo dell'applicazione e un insieme di librerie e procedure utilizzate per la creazione di applicazioni distribuite su larga scala, a tolleranza di errore. Se vuoi programmare le tue applicazioni usando OTP, il concetto centrale che troverai molto utile è il comportamento OTP. Un comportamento incapsula schemi comportamentali comuni: pensalo come un framework applicativo parametrizzato da un modulo di callback.

La potenza di OTP deriva dalle proprietà come tolleranza agli errori, scalabilità, aggiornamento del codice dinamico e così via, che possono essere fornite dal comportamento stesso. Quindi il primo concetto di base è creare un componente server che imiti le basi di un ambiente OTP, diamo un'occhiata al seguente esempio per lo stesso.

Esempio

-module(server). 
-export([start/2, rpc/2]). 

start(Name, Mod) -> 
   register(Name, spawn(fun() -> loop(Name, Mod, Mod:init()) end)). 
rpc(Name, Request) -> 
   Name ! {self(), Request}, 
   receive 
      {Name, Response} -> Response 
   end. 
   
loop(Name, Mod, State) ->
   receive 
      {From, Request} ->
         {Response, State1} = Mod:handle(Request, State), 
         From ! {Name, Response}, 
         loop(Name, Mod, State1) 
   end.

Le seguenti cose devono essere annotate sul programma di cui sopra:

• Il processo se registrato con il sistema utilizzando la funzione di registrazione.

• Il processo genera una funzione loop che gestisce l'elaborazione.

Ora scriviamo un programma client che utilizzerà il programma server.

Esempio

-module(name_server). 
-export([init/0, add/2, whereis/1, handle/2]). 
-import(server1, [rpc/2]). 

add(Name, Place) -> rpc(name_server, {add, Name, Place}). 
whereis(Name) -> rpc(name_server, {whereis, Name}). 

init() -> dict:new().
handle({add, Name, Place}, Dict) -> {ok, dict:store(Name, Place, Dict)}; 
handle({whereis, Name}, Dict) -> {dict:find(Name, Dict), Dict}.

Questo codice esegue effettivamente due attività. Serve come un modulo di callback che viene chiamato dal codice del framework del server e, allo stesso tempo, contiene le routine di interfacciamento che verranno chiamate dal client. La consueta convenzione OTP consiste nel combinare entrambe le funzioni nello stesso modulo.

Quindi ecco come deve essere eseguito il programma di cui sopra:

Nel erl, eseguire prima il programma server eseguendo il comando seguente.

server(name_server,name_server)

Otterrai il seguente output:

Produzione

true

Quindi, esegui il seguente comando

name_server.add(erlang,”Tutorialspoint”).

Otterrai il seguente output:

Produzione

Ok

Quindi, esegui il seguente comando:

name_server.whereis(erlang).

Otterrai il seguente output:

Produzione

{ok,"Tutorialspoint"}