Download ¿Qué es un socket?

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO
Facultad De Ingeniería
División De Ingeniería Eléctrica
Departamento En Computación
Arquitecturas Cliente servidor
Sockets en Python
Bautista Neri Alejandro
Corona Falcon Juan
Gonzalez Castillo Ignacio
Quiroz Martinez Ezequiel
Fecha de entrega: 08 de septiembre del 2009
Índice
Historia ......................................................................................................................... 4
La última versión liberada fue Python 1.2. En 1995 ............................................... 4
Características ....................................................................................................... 5
¿Qué es un socket?...................................................................................................... 5
Dominios de comunicación .................................................................................... 5
Rapido vistazo a algunos elementos de los sockets en Python. ............................ 6
Creación del socket ...................................................................................................... 6
Ejemplo. ....................................................................................................................... 8
Servidor ................................................................................................................. 8
Cliente ................................................................................................................... 9
Referencias .................................................................................................................. 9
Historia
Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países Bajos como
un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el
sistema operativo Amoeba.
En 1991, van Rossum publicó el código (versión 0.9.0) en alt.sources. En esta etapa del desarrollo
ya estaban presentes clases con herencia, manejo de excepciones, funciones, y los tipos modulares:
list, dict, str.
El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else
En el año 1994 se formó comp.lang.python, el foro de discusión principal de Python
Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las
herramientas de la programación funcional: lambda, map, filter y reduce.
La última versión liberada fue Python 1.2. En 1995
Durante su estancia en CNRI, van Rossum lanzó la iniciativa Computer Programming for Everybody,
con el fin de hacer la programación más accesible, con un nivel de 'alfabetización' básico en
lenguajes de programación, similar a la alfabetización básica en inglés y habilidades matemáticas
indispensables para los trabajadores.
Python tuvo un papel crucial en este proceso: debido a su orientación hacia una sintaxis limpia,
presentaban similitudes con su predecesor, ABC.
Python 2.0 tomó una característica del lenguaje de programación Haskell: list comprehensions.
Python tiene una sintaxis muy similar a la de Haskell, salvo por la preferencia de los caracteres de
puntuación en Haskell.
Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias
cíclicas.
Python License, incluía una cláusula estipulando que estaba gobernada por el estado de Virginia,
bajo la óptica de los abogados de Free Software Foundation (FSF), se hacía incompatible con GNU
GPL. CNRI y FSF se relacionaron para cambiarla a software libre de Python y hacerla compatible
con GPL.
En Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos
en Python) dentro de una jerarquía. Esa unificación logró un modelo de objetos de Python puro y
consistente. También se agregaron generadores para el lenguaje Icon.
Las adiciones a la biblioteca estándar de Python y las decisiones sintácticas fueron influenciadas
fuertemente por Java en algunos casos: el package logging, en la versión 2.3, el parser SAX, en 2.0,
y la sintaxis del patrón decorator que usa el @, agregado en la versión 2.4.
Características
Se compara habitualmente con Tcl, Perl, Scheme, Java y Ruby. En la actualidad Python se
desarrolla como un proyecto de código abierto, administrado por la Python Software Foundation. La
última versión estable del lenguaje es 3.1.
Python permite dividir el programa en módulos reutilizables desde otros programas Python. Viene
con una gran colección de módulos estándar que se pueden utilizar como base a los programas.
También hay módulos incluidos que proporcionan E/S de ficheros, llamadas al sistema, sockets y
hasta interfaces a GUI (interfaz gráfica con el usuario) como Tk, GTK, Qt entre otros.
Python se utiliza como lenguaje de programación interpretado, ahorrando un tiempo considerable en
el desarrollo del programa, no es necesario compilar ni enlazar. El intérprete se puede utilizar de
modo interactivo, lo que facilita experimentar las características del lenguaje.
Otro objetivo del diseño del lenguaje es la facilidad de extensión. Nuevos módulos se pueden
escribir fácilmente en C o C++. Python puede utilizarse como un lenguaje de extensión para módulos
y aplicaciones que necesitan de una interfaz programable.
¿Qué es un socket?
Un socket nos permite comunicarnos con otras computadoras, de esta manera la información puede
viajar libremente por todos lados.Los sockets son las tuberías de plomo de las redes
computacionales que le permiten conectarse con otros dispositivos para que la información fluya
libremente. As you might expect, they're widely used on the Internet. Como es de esperar, son
ampliamente utilizados en Internet.
Los programas utilizan sockets para comunicarse con otros programas, que pueden estar situados
en computadoras distintas.
Un socket queda definido por la dirección IP de la máquina, el puerto en el que escucha, y el
protocolo que utiliza.
Los sockets se clasifican en sockets de flujo (socket.SOCK_STREAM) o sockets de datagramas
(socket.SOCK_DGRAM) dependiendo de si el servicio utiliza TCP, que es orientado a conexión y
fiable, o UDP, respectivamente. En esta lección sólo cubriremos los sockets de flujo, que cubren un
90% de las necesidades comunes.
Dominios de comunicación
Existen tres dominios de comunicación para un socket:



a) El dominio de UNIX. (AF_UNIX)
b) El dominio de internet. (AF_INET)
c) El dominio NS.
El dominio de UNIX. (AF_UNIX)
Se utiliza para la comunicación entre procesos del sistema.
El dominio de internet. (AF_INET)
Se utiliza en procesos que se están comunicando a través de TCP(UDP)/IP, es el que veremos.
El dominio NS.
Se utilizaba sobre los procesos que se comunicaban sobre el protocolo de
comunicación de Xerox.
Python solo soporta los dos primeros tipos de comunicación, como mencionamos
solamente trataremos con la familia AF_INET en este documento.
Rapido vistazo a algunos elementos de los sockets en Python.
Socket
Descripcion
socket
Crea un socket del tipo y familia especificada.
socket.accept
Acepta nuevas conexiones.
socket.connect
Conecta el socket a la dirección dada en el puerto dado.
socket.send
Envia datos al socket especificado.
socket.recv
Recive información.
Creación del socket
Los tipos y funciones necesarios para trabajar con sockets se encuentran en Python en el módulo
socket.
Los sockets se clasifican en sockets de flujo (socket.SOCK_STREAM) o sockets de datagramas
(socket.SOCKET_DGRAM) dependiendo de si el servicio utiliza TCP o UDP.
Veremos los sockets de flujo que cubren un 90% de las necesidades comunes.
Utilizaremos sockets UNIX: socket.AF_UNIX
Para crear un socket se utiliza el constructor socket.socket( ) que puede tomar como parámetros
opcionales la familia, el tipo y el protocolo. Por default se utiliza la familia AF_INET y el tipo
SOCK_STREAM.
Lo primero que se hace es crear un objeto socket para el servidor
Socket_s=socket.socket( )
Tenemos ahora que indicar en qué puerto se va a mantener a la escucha nuestro servidor
utilizando el método bind. Para sockets IP, como es nuestro caso, el argumento de bind es una tupla
que contiene el host y el puerto. El host se puede dejar vacío, indicando al método que se puede
utilizar cualquier nombre que esté disponible.
Socket_s.bind((“Local host”, 9999))
Por último utilizamos listen para hacer que el socket acepte conexiones entrantes y accept para
comenzar a escuchar. El método listen requiere de un parámetro que indica el número de
conexiones máximas que queremos aceptar.
El método accept se mantiene a la espera de conexiones entrantes, bloqueando la ejecución hasta
que llega un mensaje.
Cuando llega un mensaje, accept desbloquea la ejecución, devolviendo un objeto socket que
representa la conexión del cliente y una tupla que contiene el host y puerto de dicha conexión.
socket_s.listen(10)
socket_c, (host_c, puerto_c)=socket_s.accept( )
Una vez que tenemos este objeto socket podemos comunicarnos con el cliente a través suyo,
mediante los métodos recv y send (o recvfrom y sendfrom en UDP) que permiten recibir o enviar
mensajes respectivamente. El método send toma como parámetros los datos a enviar, mientras que
el método recv toma como parámetro el número máximo de bytes a aceptar.
recibido=socket_c.recv(1024)
print “Recibido: ”, recibio
socket_c.send(recibido)
Una vez que hemos terminado de trabajar con el socket, lo cerramos con close.
Crear un cliente es aún más sencillo. Sólo tenemos que crear el objeto socket, utilizar el método
connect para conectarnos al servidor y utilizar los métodos send y recv. El argumento de connect es
una tupla con host y puerto, exactamente igual que bind.
socket_c=socket.socket( )
socket_c.connect((“localhost”, 9999))
socket_c.send(“hola”)
Ejemplo.
//El cliente manda al servidor cualquier mensaje que escriba el usuario y el servidor no hace más
que repetir el mensaje recibido. La ejecución termina cuando el usuario escribe quit
Servidor
//en el lado del servidor
Import socket
s=socket.socket()
s.bind((“Localhost”, 9999))
s.listen(1)
sc, addr=s.accept( )
while True:
recibido=sc.recv(1024)
if recibido==”quit”
break
print “Recibido: ”, recibido
sc.send(recibido)
print “adios”
sc.close()
s.close()
Cliente
//en el lado del CLIENTE
import socket
c=socket.socket
c.connect((“Localhost”, 9999))
Referencias
http://es.wikipedia.org/wiki/Python
http://mundogeek.net/archivos/2008/04/12/sockets-en-python/
http://www.slideshare.net/mephistodark/sockets-en-python-por-antoni-luque-delgado-presentation891002
http://www.xinug.org/drupal/files/charlas/intro-python.pdf
http://wiki.python.org/moin/HowTo/Sockets
http://www.slideshare.net/mephistodark/sockets-en-python-por-antoni-luque-delgado-presentation891002