Diferenças entre as versões de 1 e 2

Receita: SocketBasico

Esta receita é baseada em um material que preparei para uso em aulas para demostrar a programação básica para redes usando socket com a intensão de ser uma "prova de conceitos" sobre o TCP/UDP.

Estrutura Básica de Programas para Rede

O Python implementa a interface de rede utilizando os fundamentos da API de Socket.
Todo socket pode estar em modo ativo ou passivo.
Quando ele é criado ele esta no modo ativo.
Para o servidor poder ficar “escutando” um porta é necessário colocar o socket do servidor em modo passivo.
Seqüência no Cliente:
1. Se foi fornecido um nome de hospedeiro converter em endereço IP;
2. Se foi fornecido um nome de protocolo de transporte converter em número;
3. Criar o socket (função socket);
4. Conecta com o servidor (função connect);
5. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
6. Fechar o socket.
Seqüência no Servidor:
1. Se foi fornecido um nome de protocolo de transporte converter em número;
2. Criar o socket (função socket);
3. Coloca um endereço local, endereço IP e porta, no socket (função bind);
4. Instrui o sistema operacional para colocar o socket em modo passivo (função listen);
5. Aceita uma nova conexão (função accept);
6. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
7. Fechar o socket.
8. Volta ao passo 5 para aceitar outra conexão.
Os passos 4 e 5 do servidor são feito quando utilizamos protocolo de transporte orientado a conexão (TCP).
O servidor tipicamente fica em laço infinito aceitando novas conexões.
Enquanto o servidor atende uma conexão ele fica dedicado a ela. Para evitar isso é possível fazer um passo intermediário entre o 5 e o 6 para criar um novo processo ou thread para tratar da nova conexão que esta chegando. Com isso o processo/thread pai fica somente recebendo as conexões e o processo/thread filho trata das requisições dos clientes.

Cliente e Servidor com UDP

Cliente UDP

   1 import socket
   2 HOST = '192.168.1.10'  # Endereco IP do Servidor
   3 PORT = 5000            # Porta que o Servidor esta
   4 udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
   5 dest = (HOST, PORT)
   6 print 'Para sair use CTRL+X\n'
   7 msg = raw_input()
   8 while msg <> '\x18':
   9     udp.sendto (msg, dest)
  10     msg = raw_input()
  11 udp.close()

=== Servidor UDP===

   1 import socket
   2 HOST = ''              # Endereco IP do Servidor
   3 PORT = 5000            # Porta que o Servidor esta
   4 udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
   5 orig = (HOST, PORT)
   6 udp.bind(orig)
   7 while True:
   8     msg, cliente = udp.recvfrom(1024)
   9     print cliente, msg
  10 udp.close()

Cliente e Servidor com TCP

Cliente TCP

   1 import socket
   2 HOST = '127.0.0.1'     # Endereco IP do Servidor
   3 PORT = 5000            # Porta que o Servidor esta
   4 tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   5 dest = (HOST, PORT)
   6 tcp.connect(dest)
   7 print 'Para sair use CTRL+X\n'
   8 msg = raw_input()
   9 while msg <> '\x18':
  10     tcp.send (msg)
  11     msg = raw_input()
  12 tcp.close()

Servidor TCP

   1 import socket
   2 HOST = ''              # Endereco IP do Servidor
   3 PORT = 5000            # Porta que o Servidor esta
   4 tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   5 orig = (HOST, PORT)
   6 tcp.bind(orig)
   7 tcp.listen(1)
   8 while True:
   9     con, cliente = tcp.accept()
  10     print 'Concetado por', cliente
  11     while True:
  12         msg = con.recv(1024)
  13         if not msg: break
  14         print cliente, msg
  15     print 'Finalizando conexao do cliente', cliente
  16     con.close()

Servidor TCP Concorrente

   1 import socket
   2 import os
   3 import sys
   4 HOST = ''              # Endereco IP do Servidor
   5 PORT = 5000            # Porta que o Servidor esta
   6 tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   7 orig = (HOST, PORT)
   8 tcp.bind(orig)
   9 tcp.listen(1)
  10 while True:
  11     con, cliente = tcp.accept()
  12     pid = os.fork()
  13     if pid == 0:
  14         tcp.close()
  15         print 'Conectado por', cliente
  16         while True:
  17             msg = con.recv(1024)
  18             if not msg: break
  19             print cliente, msg
  20         print 'Finalizando conexao do cliente', cliente
  21         con.close()
  22         sys.exit(0)
  23     else:
  24         con.close()

Usando Thread para Concorrência

   1 import socket
   2 import thread
   3 HOST = ''              # Endereco IP do Servidor
   4 PORT = 5000            # Porta que o Servidor esta
   5 def conectado(cliente, con):
   6     print 'Conectado por', cliente
   7     while True:
   8         msg = con.recv(1024)
   9         if not msg: break
  10         print cliente, msg
  11     print 'Finalizando conexao do cliente', cliente
  12     con.close()
  13     thread.exit()
  14 tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  15 orig = (HOST, PORT)
  16 tcp.bind(orig)
  17 tcp.listen(1)
  18 while True:
  19     con, cliente = tcp.accept()
  20     thread.start_new_thread(conectado, tuple([cliente, con]))
  21 tcp.close()

Volta para CookBook.

MarcioMinicz

-  ⇤ ← Revisão  1e 2006-05-07 16:49:00 → 
  Tamanho: 5238
  Editor: MarcioMinicz
  Comentário:
+   ← Revisão  2e 2007-01-19 18:13:18 → ⇥
  Tamanho: 5174
  Editor: AllanLima
  Comentário: Quando vários client's se conectavam ao servidor as mensagens se referiam ao último cliente conectado.
-Deleções são marcadas assim.
+Adições são marcadas assim.
 Linha 2:
-Linha 6:
+Linha 5:
-Linha 13:
+Linha 11:
-. Se foi fornecido um nome de protocolo de transporte converter em número;
  3. Criar o socket (função socket);
  4. Conecta com o servidor (função connect);
  5. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
  6. Fechar o socket.
+. Se foi fornecido um nome de protocolo de transporte converter em número;
  1. Criar o socket (função socket);
  1. Conecta com o servidor (função connect);
  1. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
  1. Fechar o socket.
-Linha 21:
+Linha 18:
-. Criar o socket (função socket);
  3. Coloca um endereço local, endereço IP e porta, no socket (função bind);
  4. Instrui o sistema operacional para colocar o socket em modo passivo (função listen);
  5. Aceita uma nova conexão (função accept);
  6. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
  7. Fechar o socket.
  8. Volta ao passo 5 para aceitar outra conexão.
+. Criar o socket (função socket);
  1. Coloca um endereço local, endereço IP e porta, no socket (função bind);
  1. Instrui o sistema operacional para colocar o socket em modo passivo (função listen);
  1. Aceita uma nova conexão (função accept);
  1. Enviar/Receber dados (permanecer nesse passo enquanto tiver dados para enviar/receber);
  1. Fechar o socket.
  1. Volta ao passo 5 para aceitar outra conexão.
-Linha 32:
+Linha 28:
-Linha 35:
+Linha 29:
-Linha 37:
+Linha 30:
-{{{#!python
+{{{
#!python
-Linha 39:
+Linha 33:
-Linha 42:
+Linha 35:
-Linha 45:
+Linha 37:
-Linha 47:
+Linha 38:
-Linha 52:
+Linha 42:
-Linha 55:
+Linha 44:
+=== Servidor UDP===
-Linha 56:
+Linha 46:
-=== Servidor UDP===
{{{#!python
+{{{
#!python
-Linha 59:
+Linha 49:
-Linha 62:
+Linha 51:
-Linha 65:
+Linha 53:
-Linha 67:
+Linha 54:
-Linha 71:
+Linha 57:
-Linha 74:
+Linha 59:
-Linha 76:
+Linha 60:
-Linha 78:
+Linha 61:
-{{{#!python
+{{{
#!python
-Linha 80:
+Linha 64:
-Linha 83:
+Linha 66:
-Linha 86:
+Linha 68:
-Linha 88:
+Linha 69:
-Linha 90:
+Linha 70:
-Linha 95:
+Linha 74:
-Linha 98:
+Linha 76:
-Linha 100:
+Linha 77:
-{{{#!python
+{{{
#!python
-Linha 102:
+Linha 80:
-Linha 105:
+Linha 82:
-Linha 108:
+Linha 84:
-Linha 111:
+Linha 86:
-Linha 122:
+Linha 96:
-Linha 124:
+Linha 97:
-{{{#!python
+{{{
#!python
-Linha 129:
+Linha 102:
-Linha 132:
+Linha 104:
-Linha 135:
+Linha 106:
-Linha 138:
+Linha 108:
-Linha 144:
+Linha 113:
-        print 'Concetado por', cliente
+        print 'Conectado por', cliente
-Linha 155:
+Linha 124:
-Linha 157:
+Linha 125:
-{{{#!python
+{{{
#!python
-Linha 160:
+Linha 129:
-Linha 163:
+Linha 131:
-def conectado(con):
    print 'Concetado por', cliente
+def conectado(cliente, con):
    print 'Conectado por', cliente
-Linha 174:
+Linha 140:
-Linha 177:
+Linha 142:
-Linha 180:
+Linha 144:
-Linha 183:
+Linha 146:
-    thread.start_new_thread(conectado, tuple([con]))
+    thread.start_new_thread(conectado, tuple([cliente, con]))
-Linha 187:
+Linha 149:
-Linha 192:
+Linha 152:

Veja também:

Diferenças para "SocketBasico"