Porta (Port) do Erlang

No Erlang, as portas são usadas para comunicação entre diferentes programas. Um soquete é um ponto de comunicação que permite que um computador use o protocolo de Internet (IP) para se comunicar através da Internet.

Tipo de protocolo usado na porta

Existem dois protocolos disponíveis para comunicação. Um é UDP e o outro é TCP. O UDP permite que aplicações enviem mensagens curtas (conhecidas como datagramas) entre si, mas não garante a entrega dessas mensagens. Elas também podem falhar. Por outro lado, o TCP oferece um fluxo de bytes confiável, onde os bytes são transmitidos em ordem desde que a conexão seja estabelecida.

Vamos ver um exemplo simples de como abrir uma porta usando UDP.

Exemplo

-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")]).

Saída

A saída do programa acima é a seguinte.

#Port<0.376>ok

Receber mensagens na porta

Após abrir a porta, ainda é possível receber uma mensagem na porta. Isso é feito através do método recv. Vamos ver a sintaxe e o exemplo a seguir.

Sintaxe

recv(Socket, length)

Parâmetros

• Socket −É um soquete criado usando o comando gen_udp:open.

• Length −É o comprimento da mensagem que precisa ser recebida.

Retorno

Se a mensagem for enviada corretamente, retornará uma mensagem de confirmação.

Por exemplo

-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)]).

Programa completo

Agora, claramente, não podemos ter a mesma mensagem de envio e recebimento no mesmo programa. Você precisa defini-las em programas diferentes. Portanto, vamos criar o seguinte código, que cria um componente de servidor de escuta de mensagens e um componente de cliente de envio de mensagens.

Exemplo

-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　
　　　end,　
　　　
gen_udp:close(Socket),　
Value.

A respeito do programa acima, há alguns pontos a serem notados.

• Definimos duas funções, a primeira é a função do servidor. Isso será usado para ouvir a porta4000. O segundo é o cliente, que será usado para enviar a mensagem "Hello" para o componente do servidor.

• O loop de recebimento é usado para ler mensagens enviadas dentro do loop definido.

Saída

Agora você precisa executar o programa nas duas janelas. A primeira janela executará o componente do servidor, digitando o seguinte código na janela de linha de comando do erl.

helloworld:start().

Isso exibirá a seguinte saída na janela de linha de comando.

server　opened　socket:#Port<0.2314>

Agora, na segunda janela de linha de comando do erl, execute o seguinte comando.

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

Quando você emitir este comando, a seguinte saída será exibida na primeira janela de linha de comando.

server　received:<<"Hello">>