porta（Port）Erlang

In Erlang, le porte vengono utilizzate per la comunicazione tra diversi programmi. Un socket è un punto di comunicazione che permette ai computer di comunicare tramite protocolli di rete (IP) attraverso Internet.

Tipo di protocollo utilizzato nella porta

Ci sono due protocolli disponibili per la comunicazione. Uno è UDP, l'altro è TCP. UDP permette alle applicazioni di inviarsi messaggi brevi (detti pacchetti di dati), ma non garantisce la trasmissione di questi messaggi. Potrebbero anche verificarsi errori. D'altra parte, TCP fornisce un flusso di byte affidabile, dove i byte vengono trasmessi in ordine non appena viene stabilito il collegamento.

Vediamo un esempio semplice di come aprire una porta UDP.

Esempio

-module(helloworld).　
-export([start/0]).　
start() ->
　　　{ok, Socket} = gen_udp:open(8789),　
　　　io:fwrite("~p",[Socket]),　
　　　io:fwrite("~p",[gen_udp:send　
　　　(Socket,"localhost",8789,"Hello")).

output

L'output del programma sopra è il seguente.

#Port<0.376>ok

Ricezione di messaggi sulla porta

Dopo aver aperto la porta, è possibile ricevere un altro messaggio sulla porta. Questo viene fatto tramite il metodo recv. Vediamo la sintassi e l'esempio seguente.

Sintassi

recv(Socket, length)

Parametro

• Socket −Questo è il socket creato con il comando gen_udp:open.

• Lunghezza −Questa è la lunghezza del messaggio da ricevere.

Valore di ritorno

Se il messaggio viene inviato correttamente, viene restituito un messaggio di conferma.

Esempio

-module(helloworld).　
-export([start/0]).　
start() ->
　　　{ok, Socket} = gen_udp:open(8789),　
　　　io:fwrite("~p",[Socket]),　
　　　io:fwrite("~p",[gen_udp:send(Socket,"localhost",8789,"Hello")]),
　　　io:fwrite("~p",[gen_udp:recv(Socket, 20)]).

Programma completo

Ora, ovviamente, non possiamo avere lo stesso messaggio inviato e ricevuto nello stesso programma. Dobbiamo definirli in programmi diversi. Quindi, creiamo il seguente codice, che crea un componente server in ascolto dei messaggi e un componente client per l'invio dei messaggi.

Esempio

-module(helloworld).　
-export([start/0,client/1]).　
start() ->　
　　　spawn(fun() -> server(4000) end).
server(Port) ->
　　　{ok, Socket} = gen_udp:open(Port, [binary, {active, false}]),　
　　　io:format("server opened socket:~p~n",[Socket]),　
　　　loop(Socket).　
loop(Socket) ->
　　　inet:setopts(Socket, [{active, once}]),　
　　　receive　
　　　　　　{udp, Socket, Host, Port, Bin} ->　
　　　　　　io:format("server received:~p~n",[Bin]),　
　　　　　　gen_udp:send(Socket, Host, Port, Bin),　
　　　　　　loop(Socket)　
　　　end.　
client(N) ->　
　　　{ok, Socket} = gen_udp:open(0, [binary]),　
　　　io:format("client opened socket=~p~n",[Socket]),　
　　　ok = gen_udp:send(Socket, "localhost", 4000, N), Value = receive　
　　　　　　{udp, Socket, _, _, Bin} ->
　　　　　　　　　io:format("client received:~p~n",[Bin]) after 2000 ->
　　　　　　0　
　　　fine,　
　　　
gen_udp:close(Socket),　
Valore.

Per il programma sopra riportato, è necessario notare i seguenti punti.

• Abbiamo definito due funzioni, la prima è la funzione server. Questa viene utilizzata per ascoltare la porta 4000. La seconda è il client, che viene utilizzato per inviare il messaggio “Hello” al componente server.

• Il ciclo di ricezione viene utilizzato per leggere i messaggi inviati all'interno del ciclo definito.

output

Ora devi eseguire il programma da entrambe le finestre. La prima finestra eseguirà il componente server eseguendo il seguente codice nella finestra di comando erl.

helloworld:start().

Questo mostrerà la seguente uscita nella finestra di comando.

server aperto socket:#Port<0.2314>

Ora, nella seconda finestra di comando erl, esegui il seguente comando.

Helloworld:client(“<<Hello>>”).

Quando si invia questo comando, la seguente uscita verrà visualizzata nella prima finestra di comando.

server ricevuto:<<"Hello">>