Universidad Popular Autónoma del Estado de Puebla
Reporte de Práctica

Asignatura: Microprocesadores
Nombre del Profesor: Casimiro Gómez González
No. De Práctica: 5 Nombre De Práctica: Servidor/Cliente Multihilos
Nombre del Alumno: Oliver Franco Vega, Ana Michelle López Hernández

Objetivos: Diseñar un servidor/cliente multihilos en Python que se conectan mediante sockets, intercambias cadenas de texto y cierran la conexión. .
Marco Teórico:
Socket designa un concepto abstracto por el cual dos programas (posiblemente situados en computadoras distintas) pueden intercambiar cualquier flujo de datos, generalmente de manera fiable y ordenada.
Un socket queda definido por una dirección IP, un protocolo de transporte y un número de puerto.
Para que dos programas puedan comunicarse entre sí es necesario que se cumplan ciertos requisitos: * Que un programa sea capaz de localizar al otro. * Que ambos programas sean capaces de intercambiarse cualquier secuencia de octetos, es decir, datos relevantes a su finalidad.
Para ello son necesarios los tres recursos que originan el concepto de socket: * Un protocolo de comunicaciones, que permite el intercambio de octetos. * Una dirección del Protocolo de Red (Dirección IP, si se utiliza el Protocolo TCP/IP), que identifica una computadora. * Un número de puerto, que identifica a un programa dentro de una computadora.
Los sockets permiten implementar una arquitectura cliente-servidor. La comunicación ha de ser iniciada por uno de los programas que se denomina programa cliente. El segundo programa espera a que otro inicie la comunicación, por este motivo se denomina programa servidor.
Un socket es un fichero existente en la máquina cliente y en la máquina servidora, que sirve en última instancia para que el programa servidor y el cliente lean y escriban la información. Esta información será la transmitida por las diferentes capas de red.

Procedimiento:
En el servidor, primero establecemos el socket servidor. Para ello, usamos el módulo socket de python, haciendo el import correspondiente. Damos los siguientes pasos: * Llamada a la función socket(), a la que le pasamos el tipo de socket que queremos abrir (en el ejemplo, AF_INET, SOCK_STREAM que es el habitual). * Llamada a la función bind(), pasándole un address compuesto por (host, puerto). Como hacemos de servidor, pasamos "" como host y puerto el que queramos que esté libre (en nuestro caso el 6667). La llamada a bind() le indica al sistema operativo que nosotros vamos a atender las conexiones por el puerto 6667. * Llamada a listen(). Esta llamada indica al sistema operativo que ya estamos listos para admitir conexiones. El número 1 de parámetro indica cuantos clientes podemos tener encolados en espera simultáneamente. Este número no debería ser grande, puesto que es el número máximo de clientes que quedarán encolados desde que aceptamos un cliente hasta que estamos dispuestos a aceptar el siguiente. Si el código está bien hecho, este tiempo debería ser realmente pequeño, ya que al conectarse un cliente, deberíamos lanzar un hilo para atenderlo y entrar inmediatamente a la espera de otro cliente.
Ahora nos metemos en un ciclo eterno, esperando clientes y atendiéndolos. Para esperar un cliente, la llamada es accept(), que nos devuelve un par (socket_cliente, datos_cliente) del que obtenemos el socket para hablar con el cliente y sus datos (ip, puerto).
Ahora hacemos otro ciclo para recibir y atender los datos del cliente.
Para leer los datos del cliente, usamos recv(), pasando como parámetro el número máximo de bytes que queremos leer.
Para contestar usamos send(), enviando la cadena de respuesta. Si es "adios", además de contestar, cerramos el socket. import socket import threading

HOST=socket.gethostbyname(socket.gethostname())
PORT=6667
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr=s.accept()

def enviar(): while True: mensaje=input("") conn.send(mensaje.encode('utf-8')) def recibir(): while True: data=conn.recv(1024) a=bytes.decode(data) if not data: break print(a) t = threading.Thread(target=recibir)
t.daemon = True
t.start()

t2 = threading.Thread(target=enviar) t2.daemon = True t2.start() print('Connected by', addr) while True: pass conn.sendall(data) conn.close() Para el cliente, creamos el socket con la llamada a socket(), igual que en el servidor, pero establecemos la conexión con connect(), indicando el host servidor (localhost en nuestro ejemplo) y el puerto.
El resto es más sencillo que en el servidor. Envíamos mensajes con send(), esperamos y escribimos la respuesta con recv(), enviamos con send() la cadena "adios", esperamos y escribimos respuesta con recv() y finalmente cerramos el socket con close(). import socket import threading

s=socket.socket()
HOST=socket.gethostbyname(socket.gethostname())
s.connect((HOST, 6667))

def enviar(): while True: mensaje=input("") s.send(mensaje.encode('utf-8'))

def recibir(): while True: data=s.recv(1024) a=bytes.decode(data) if not data: break print(a) t = threading.Thread(target=recibir)
t.daemon = True
t.start()

t2 = threading.Thread(target=enviar) t2.daemon = True t2.start() while True: pass

s.close()

Observaciones y resultados

Conclusiones
Los sockets son mecanismos que permiten una comunicación sencilla entre procesos remotos, otorgando distintos niveles de fiabilidad de acuerdo al tipo de socket que se use, es decir, que dependiendo de la aplicación y del tipo de socket que se use en ella, la comunicación siempre se realizará dentro de los parámetros predefinidos.
El uso de sockets se ha extendido debido a que han sido diseñadas para servir en la comunicación en el protocolo IP; resultando eficientes al momento de su aplicación.

Bibliografía
Socket de Internet, recuperado el 12-Abril-2015 de
http://es.wikipedia.org/wiki/Socket_de_Internet