Hola
a todos los que aun siguen este pequeño blog olvidado, espero
inyectarle un poco de vida a este blog con nuevas entradas, en esta
ocacion explicare un poco lo que son los sockets en python y haremos
unos pequeños scripts en python de un cliente y servidor, los cuales
enviaran y recibirán instrucciones, en pocas palabras cadenas de
textos.
Sockets
De
acuerdo con wikipedia los sockets son 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.
El
termino socket es también usado como el nombre de una interfaz de
programación de aplicaciones para la familia de protocolos de
internet TCP/IP, provista usualmente por el sistema operativo.
Los
sockets de internet constituyen el mecanismo para la entrega de
paquetes de datos provenientes de las tarjetas de red a los procesos
o hilos apropiados. Un socket queda
definido por un par de direcciones IP local y remota, un protocolo de
transporte y un par de números de puerto local y remoto.
El
modelo de programación distribuida que sería popularizado por el
API de sockets era el modelo cliente/servidor,
en donde hay un servidor y un grupo de clientes. Los clientes envían
mensajes al servidor pidiéndole que haga trabajo en su nombre,
esperan que el servidor realice el trabajo pedido, y en algún
momento posterior reciben una respuesta. Hoy en día este modelo
computacional es tan utilizado que a menudo es el único modelo con
el que muchos ingenieros de software están familiarizados. Sin
embargo, en el momento que fue diseñado, era visto como una manera
de extender el modelo de I/O de Unix a través de una red. Otro
factor que llevó al API de sockets hacia el modelo cliente/servidor
fue que el protocolo más popular que soportaba, TCP, era un modelo
comunicacional 1:1.
El
API de sockets hizo que el modelo cliente/servidor fuera fácil de
implementar, porque el programador podía usar una pequeña cantidad
de llamadas de sistema y agregarlas a su código existente
("desconectado") para aprovechar otros recursos
computacionales. Aunque era posible usar otros modelos, el API de
sockets hizo que el modelo cliente/servidor dominara al mundo de las
redes.
Programando
los sockets
Ahora
que ya sabemos que son los sockets, explicare mediante un ejemplo
sencillo como programarlos en python, la forma de explicacion sera
como habitual mente se hace en este blog, colocare el codigo y
seguidamente explicare cada una de sus sentencias para que el lector
pueda entender claramente el codigo, bueno comencemos.
script
cliente:
1.- #!/usr/bin/python
2.- import
socket
3.-
4.- sock
= socket.socket()
5.- sock.connect((“localhost”,
5000))
6.-
7.- while
True:
8.- mensaje
= raw_input(“#>”)
9.- sock.send(mensaje)
10.- if
mensaje == “exit”:
11.- break
12.- print
“Bye”
13.- sock.close()
En
la linea 1 colocamos el shebang para el interprete de python en
gnu/linux:
#!/usr/bin/python
En
la linea 2 se encuentra la importacion del modulo socket, para el
manejo de sockers en python
import
socket
En
la linea 4 se encuentra la instanciacion del objeto socket en la
variable sock
sock
= socket.socket()
En
la linea 5 realizamos la conexión con el servidor, la sentencia
connect, esta compuesta de una tupla que pide como parametro el host
y el puerto del servidor para realizar la conexión, en este ejemplo
usaremos como host el localhost, que para el despistado el localhost
es nuestro propio ordenador que igual es representado por 127.0.0.1,
y utilizaremos el puerto 5000, para el que no sabe esto la cantidad
maxima de puestos logicos en un ordenador es de 65535 puertos, pero
eso ya es otro tema que abordaremos en una entrada relacionada con
redes o sistemas operativos.
sock.connect((“localhost”,
5000))
En
la linea 7 iniciamos un bucle infinito mediante la sentencia while y
el valor booleano True con el fin de poder repetir indefinidamente
las sentencias siguientes.
while
True:
En
la linea 8 inicializamos la variable mensaje con el valor de retorno
del metodo raw_input, el metodo raw_input retorna el buffer de
entrada, que podrian ser datos del teclado.
mensaje
= raw_input(“#> ”)
En
la linea 9 utilizamos en metodo send del modulo socket el cual
anteriormente inicializamos, la finalidad de este metodo es enviar
datos por la conexión del socket hacia el servidor, asi que
enviaremos la variable mensaje
sock.send(mensaje)
En
la linea 10 y 11 se encuentra la condicion if que determinara si la
variable mensaje es igual a “exit” si en dado caso lo es se
ejecuta la sentencia break que rompe el bucle infinito y termina el
programa.
if
mensaje == “exit”:
break
En
la linea 12 se encuentra la sentencia print que enviara un mensaje de
Bye si se concluye el while
print “Bye”
En
la linea 13 se encuentra el metodo close del objeto socket, este
metodos finaliza la conexión del socket con el servidor.
sock.close()
script
servidor:
1.- #!/usr/bin/python
2.- import
socket
3.-
4.- sock
= socket.socket()
5.- sock.bind((“localhost”,
5000))
6.- sock.listen(1)
7.-
8.- source,
adreess = sock.accept()
9.-
10.- while
True:
11.- datos
= source.recv(1024)
12.- if
datos == “exit”:
13.- break
14.- print
“Se recibio:”, datos
15.- source.send(datos)
16.- print
“Bye”
17.- source.close()
18.- sock.close()
En
la linea 1 colocamos el shebang para el interprete de python en
gnu/linux:
#!/usr/bin/python
En
la linea 2 se encuentra la importacion del modulo socket, para el
manejo de sockers en python
import
socket
En
la linea 4 se encuentra la instanciacion del objeto socket en la
variable sock
sock
= socket.socket()
En
la linea 5 especificamos mediante una tupla el cliente que tendra
acceso al servidor y el puerto por el cual el servidor se mantendra a
la escucha a espera de el cliente, si en dado caso queremos que
cualquier cliente se pueda conectar dejamos el primer campo vacio
entre comillas pero en este caso especificaremos al localhost como el
unico que puede conectarse al servidor , ademas de eso especificamos
que escucharemos a los clientes en el puerto 5000.
sock.bind((“localhost”,
5000))
En
la linea 6 especificamos cuantos clientes aceptara el servidor,
mediante la sentencia listen, en este caso solo aceptamoas un solo
cliente.
sock.listen(1)
En
la linea 8 aceptamos la conexión entrante del cliente.
source,
adreess = sock.accept()
En
la linea 10 iniciamos un bucle infinito mediante la sentencia while y
el valor booleano True con el fin de poder repetir indefinidamente
las sentencias siguientes.
while
True:
En
la linea 11 inicializamos la variable datos con los datos provenientes
del cliente, que en este caso es el valor de la variable mensaje en
el script del cliente socket
datos
= source.recv(1024)
En
la linea 12 y 13 especificamos una condicion if que verifica que el
dato recibido sea igual a “exit”, en dado caso de que sea igual a
exit, ejecuta la sentencia break y termina el bucle infinito.
if
datos == “exit”:
break
En
la linea 14 mandamos a imprimir en pantalla el mensaje “Se recibio:
” seguido del dato proveniente de la comunicación con el clientes
print
“Se recibio:”, datos
En
la linea 15 se envia el valor de la variable datos al cliente
conectado al servidor.
source.send(datos)
En
la linea 16 ya fuera del bucle infinito se imprime en pantalla el
mensaje Bye indicando que se concluira el script.
print
“Bye”
En
la linea 17 y 18 indicamos el cierre de la conexión con el cliente
conectado al servidor y el cierre de servidor creado.
source.close()
sock.close()
con
eso concluye esta nueva entrada, creo que aplazar una entrada por dos
semanas en contraproducente asi que cada semana lanzare una nueva, en
esta ocacion el tiempo y la falta de microfono no ayudo en realizar
un videotutorial de este tema, pero espero que la proxima entrada
pueda lanzar junto con su version escrita una version en video,
ademas de esto la encuenta para el proximo tema en abordar quedo en
un triple empate por eso, omitire para la proxima un tema de
programacion y tomare como el siguiente tema, los sistemas
operativos.
