Comunicação TCP/IP
Conceitos elementares de comunicação TCP/IP e camadas de rede
Vamos supor que um determinado computador "A", chamado client, queira enviar uma mensagem a outro computador "B", chamado server. A mensagem que o client envia, também chamada de request, precisa ser transportada através de algum tipo de rede, ou network. O server, por sua vez, pode enviar uma resposta ao client, chamada de response.

Rede

Mas o quê é esta "rede" que fica ali no meio de dois computadores distintos? Podem ser diversos tipos de redes, públicas e privadas, mas quando estamos falando de uma rede global e descentralizada, nos referimos à Internet, onde computadores conectados de lugares distintos no planeta podem se comunicar.
Mas do quê a Internet é composta? Quais são as ferramentas e conceitos existentes na Internet que garantem que as mensagens são entregues da forma esperada?
Vamos dividir estes conceitos e ferramentas em camadas.

Camada 1: Física

Para criamos uma rede, precisamos definir a infra estrutura física através de arquitetura de rede, utilizando o cabeamento correto e roteamento de mensagens dentro da rede. Esta camada envolve apenas a parte física e envolve tecnologias como Ethernet, Bluetooth, ondas de rádio, fibra optica, entre outros.

Camada 2: Rede (IP)

Como um client poderia enviar uma mensagem a um server? E se enviarmos num formato que muitos de nós já conhecemos, como as correspondências?
E se por acaso algum computador na rede, mal-intencionado ou esquecido, resolve enviar uma mensagem com formato errado, difícil de interpretar?
Neste caso a mensagem talvez nem conseguiria ser entregue ao destino, pois tem um formato inválido.
No caso da Internet, esta camada se chama Internet Protocol, ou IP, e define um protocolo para que as mensagens tenham um determinado padrão de envio.

Camada 3: Transporte (TCP, UDP)

Como então garantir que as mensagens chegam de um lado para o outro? Serão transportadas de forma correta? Na ordem correta?
Esta camada define o formato de transmissão das mensagens, onde pode ser definido se há confirmações ou não de envio, tentativas em caso de falhas, dentre outras formas de garantia de envio. Nesta camada, fica um dos protocolos de envio mais conhecidos, o TCP.

Camada 4: Aplicação

E se quisermos criar uma abstração por cima do formato da mensagem onde podemos suportar outros formatos e protocolos de mensagens? Como suportar multi-formatos? Envio de "correspondências virtuais" (e-mails) com garantia de entrega?
A camada de aplicação é responsável por definir protocolos de formatos de mensagens que serão enviados através de TCP/IP. Dentre estes protocolos, podemos destacar HTTP, SMTP, FTP dentre outros.
Então aqui temos o resumo das 4 camadas definidas no standard TCP/IP:

Computadores e TCP/IP

Como um computador consegue enviar e receber mensagens na rede? Indo além, como um computador consegue conectar com outro computador?
Os sistemas operacionais fornecem uma funcionalidade para que possamos utilizar recursos de rede em diversos "pontos". Tais pontos são chamados de "endpoints", ou sockets.
Com sockets conseguimos conectar a outro computador, e também enviar e receber mensagens. O sistema operacional também permite que alguns endpoints possam receber um identificador único no computador, também chamado de porta.
1
=> lsof -i tcp:3000
2
3
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
4
com.docke 21027 leandro 104u IPv6 0xd7f6748eef91a4e7 0t0 TCP localhost:hbci->localhost:53696 (CLOSED)
5
com.docke 21027 leandro 106u IPv6 0xd7f6748ee3098827 0t0 TCP localhost:hbci->localhost:53697 (CLOSED)
6
com.docke 21027 leandro 112u IPv6 0xd7f6748ef2704e87 0t0 TCP localhost:hbci->localhost:53702 (CLOSED)
7
com.docke 21027 leandro 124u IPv6 0xd7f6748ef0efbe87 0t0 TCP *:hbci (LISTEN)
Copied!
Destaque para a coluna FD, que representa o endpoint, ou socket. E a DEVICE, que representa o dispositivo físico de rede do computador.

Comunicação TCP/IP em Ruby

Ruby fornece uma API já incluída no pacote standard para manipulacão de sockets TCP/IP.
Vamos criar um TCP server muito simples em Ruby, que abre um socket na porta 3000:
server.rb
1
require 'socket'
2
3
# Abre o socket e atribui na porta 3000
4
socket = TCPServer.new('0.0.0.0', 3000)
5
6
# Socket aberto à espera de novas conexões na rede
7
# O programa fica bloqueado nesta linha enquanto não houver nova conexão
8
client = socket.accept
9
10
# Uma vez que uma nova conexão chega, o programa continua
11
# E aqui podemos fazer a leitura de mensagens que chegaram no socket
12
request = client.gets
13
14
# Envia uma mensagem para o client através do socket aberto
15
client.puts('Yo, client')
16
17
# Fecha a conexão com o client
18
client.close
19
20
# Encerra o socket e liberta a porta 3000 para ficar livre no sistema operacional
21
socket.close
Copied!
Agora, um client TCP simples em Ruby:
client.rb
1
require 'socket'
2
3
# Conecta em algum socket já aberto na porta 3000
4
server = TCPSocket.new('0.0.0.0', 3000)
5
6
# Envia mensagem ao server através do socket
7
server.puts('Yo, server!')
8
9
# Recebe mensagem do server através do docket
10
response = server.gets
11
12
# Fecha o socket deste lado do client
13
server.close
Copied!

Server em loop

Obviamente, não podemos ter um servidor que encerra o socket na porta a cada conexão. Para resolver isto, podemos colocar o server em loop, onde a cada vez que uma conexão é fechada, o server volta para o início do loop e fica bloqueado a espera de uma nova conexão.
server.rb
1
...
2
loop do
3
client = server.accept
4
request = client.gets
5
6
client.puts 'My response'
7
client.close
8
end
Copied!

Padrão TCP/IP

Podemos reparar que o padrão de envio de mensagens através de TCP/IP é:
  1. 1.
    server abre socket em alguma porta de rede
  2. 2.
    server fica bloqueado a espera de conexão no socket
  3. 3.
    server recebe mensagem do client
  4. 4.
    server envia mensagem para o client
  5. 5.
    server fecha conexão com client
  6. 6.
    server fica novamente bloqueado a espera de nova conexão
O quê acontece quando o mesmo client tenta novamente conectar no servidor? Nosso servidor consegue se "lembrar" quem era o primeiro client?
Por definição, o server não guarda informações dos clients nesta camada de rede, não há estado, o que caracteriza que o TCP/IP é stateless pode definição. Este conceito será importante para que possamos entender, posteriormente, as particularidades de aplicações Web que rodam através de HTTP.

Pull Request