Transferencia de archivo de socket de Python Enviar
Diagrama de configuración básica:
Aquí está el diagrama de configuración básico para ejecutar este programa.
Para simplificar, llamaremos al sistema A como a_client y sistema B como b_server a lo largo del artículo.
Requisitos del archivo:
Nosotros necesitamos servidor.py y este archivo debe estar presente en el sistema de servidor. En nuestro servidor de casos.Py debe estar en el sistema B_Server.
Otros dos archivos cliente.py y muestra.TXT debe estar presente en el sistema de clientes. En nuestro caso, esos dos archivos deben estar presentes en el sistema A_Client.
Suposiciones:
Aquí están los supuestos:
- Deberíamos tener dos sistemas Linux con acceso terminal.
- El sabor de Linux preferible es Ubuntu.
- Se debe instalar python3.
- Ambos sistemas de Linux deberían hacer ping entre sí. Usar silbido comandar para verificar ping.
- Un sistema debe actuar como servidor y otro sistema debe actuar como cliente en un momento particular.
Limitaciones:
Antes de continuar, debemos saber que hay algunas limitaciones de este programa.
- Python3+ debe instalarse para ejecutar este programa. Puede observar un error o un comportamiento diferente si se ejecuta en las versiones anteriores de Python.
- Solo el archivo de texto se puede transferir a través de este programa a partir de ahora. Cualquier otro archivo de formato que no contenga texto puede fallar.
- Se han manejado excepciones de programación básicas en el programa.
- El programa puede o no ejecutarse en otro sistema operativo que no sea Ubuntu.
- El archivo de texto debe ser corto en el lado del cliente, ya que se ha utilizado el tamaño del búfer de 1024 bytes.
Requisitos de configuración:
- Necesitamos al menos un sistema de Linux para probar este programa. Pero la recomendación es usar dos sistemas de Linux diferentes que están conectados a través de la red.
- Se deben conectar dos sistemas a través de Ethernet o Wi-Fi o cualquier otra conexión.
Código fuente del servidor:
https: // github.com/linuxhintcode/webSAMPLES/blob/master/python_send_file/servidor.py
Código fuente del cliente:
https: // github.com/linuxhintcode/websamples/blob/master/python_send_file/cliente.py
#!/usr/bin/env python3# Importar bibliotecas
TOCKETOR DE IMPORTA
Sys de importación
# Vamos a ver el primer argumento como IP del servidor
if (len (sys.argv)> 1):
Serverip = sys.Argv [1]
demás:
imprimir ("\ n \ n ejecutar como \ n python3 cliente.py \ n \ n ")
Salir (1)
# Ahora podemos crear el objeto Socket
s = enchufe.enchufe()
# Vamos a elegir un puerto y conectarnos a ese puerto
Puerto = 9898
# Vamos a conectarnos a ese puerto donde el servidor puede estar ejecutado
s.Connect ((ServerIP, Port))
# Podemos enviar una muestra de archivo.TXT
archivo = abre ("muestra.txt "," rb ")
SendData = archivo.Leer (1024)
Mientras que SendData:
# Ahora podemos recibir datos del servidor
Imprimir ("\ n \ n ################ El mensaje de abajo se recibe del servidor ############### \ n \ n ", s.Recv (1024).Decode ("UTF-8"))
#Ahora envíe el contenido de la muestra.txt al servidor
s.Enviar (SendData)
SendData = archivo.Leer (1024)
# Cierre la conexión desde el lado del cliente
s.cerca()
Cómo ejecutar programas y salida esperada:
Estos son los pasos para ejecutar el programa.
Paso 1: vaya al sistema B_Server y abra un terminal. Cortado cortado para abrir una terminal es Alt+ctrl+t.
Paso 2: ahora vaya a la ruta donde el servidor.Py está presente.
Paso 3: ahora ejecutar servidor.Py como abajo
servidor python3.py
No debe haber ningún error y debe ver las impresiones a continuación
El servidor está listando en el puerto: 9898
El nombre del archivo copiado será RECV.txt en el lado del servidor
Paso 4: ahora abra el terminal en el sistema A_Client.
Paso 5: vaya a la ruta donde el cliente.Py y muestra.txt están presentes.
Paso 6: ahora ejecuta el cliente.Py como abajo
Cliente de Python3.pyHemos observado que necesitamos conocer la dirección IP del servidor. Podemos ejecutar el siguiente comando para conocer la dirección IP del sistema B_Server.
ifconfig
Ahora la salida del sistema A_Client debería ser así
################ El mensaje de abajo se recibe del servidor ################
| --------------------------------- |
Hola Cliente [Dirección IP: 192.168.1.102],
** Bienvenido al servidor **
-Servidor
| --------------------------------- |
Paso 7: Ahora vaya a B_Server y busque la salida a continuación
El archivo ha sido copiado con éxito
El servidor Cerro La conexion
Paso 8: debe haber un nombre de archivo RECV.txt en la carpeta del servidor. El contenido de este RECV.TXT debería ser la misma muestra.TXT.
Por lo tanto, hemos copiado con éxito un archivo de cliente a servidor a través de la red a través del programa Python.
Explicaciones del código:
Hay dos archivos de Python servidor.py y cliente.py.
Tenga en cuenta que explicaremos una vez si algún código es el mismo dentro del servidor.Py y cliente.py.
- servidor.PY:
Esta es la línea shebang, lo que significa que, por defecto, este servidor.Py debe usar python3. Veamos una ventaja de esta línea.
Hemos ejecutado el servidor.py o cliente.Py como python3 . Ahora, sin usar Python3, podemos ejecutar el archivo de Python. Sigue a continuación los comandos
Ir al modo de supervisión de Super:
SU
Dar permiso para .Archivo PY:
servidor chmod 777.py
Ejecutar servidor.PY:
./servidor.pyTOCKETOR DE IMPORTA
#Importación de la biblioteca de socket en el programa Python, ya que vamos a usar Socket para la conexión.
s = enchufe.enchufe()
Estamos creando un objeto "s" Para acceder a todos los métodos de socket. Este es un concepto de oops.
Puerto = 9898Ahora elegimos un puerto donde el servidor estará escuchando. Podemos usar puerto no reservado en lugar de este.
s.Bind ((", puerto))Utilizamos el método de enlace para vincular la dirección IP del servidor a ese puerto [9898]. Una observación es que podríamos haber utilizado la dirección IP exacta del servidor en lugar del primer argumento del método de enlace, pero elegimos dejarlo en blanco ya que esto funciona bien.
s.Bind ((dirección IP, puerto))file = open ("Recv.txt "," wb ")
Hemos abierto un nombre de archivo "Recv.txt ”en el servidor para el modo de escritura y obtuvo el puntero de archivo. Esto se requiere ya que tenemos que copiar un archivo de texto del cliente.
Mientras que es cierto:Comencemos una infinita mientras el trabajo de bucle como servidor es esperar hasta que un cliente se comunique con el servidor en ese puerto 9898. Entonces este bucle se requiere.
Conn, ADDR = S.aceptar()Este código es aceptar cualquier solicitud de conexión entrante del cliente. Conn usará "Conn " para comunicarse con el cliente y "Addr" es la dirección IP del cliente que ha enviado una solicitud de conmoción a este servidor en el puerto 9898.
msg = "\ n \ n | --------------------------------- | \ n HI CLIENTE [Dirección IP:" + addr [0] +"], \ n ** Bienvenido al servidor ** \ n -server \ n
| --------------------------------- | \ n \ n \ n "
Este código es crear un mensaje para enviar al cliente. Este mensaje debe imprimirse en la terminal del cliente. Esto confirma que el cliente puede comunicarse con el servidor.
conn.Enviar (MSG.codificar())Ahora tenemos el mensaje listo y luego lo enviamos al cliente usando eso "Conn". Este código realmente envía un mensaje al cliente.
RecvData = Conn.Recv (1024)Este código está recibiendo cualquier dato que se envíe desde el lado del cliente. En nuestro caso esperamos el contenido de la muestra.txt en "Recvdata".
Mientras que Recvdata:Uno más mientras que el bucle con condición recvData no está vacío. En nuestro caso no está vacío.
archivo.escribir (recvdata)Una vez que tengamos contenido en el interior "Recvdata" Entonces estamos escribiendo en ese archivo "Recv.TXT" Usando el puntero de archivo "archivo".
RecvData = Conn.Recv (1024)Nuevamente tratando de recibir si hay algún dato del cliente. Una vez "Recvdata" no tiene datos, el código romperá el bucle while.
archivo.cerca()Esto cerrará el puntero del archivo a medida que terminemos con el archivo Write.
conn.cerca()Esto cerrará la conexión con el cliente.
romperEsto es para salir de Infinite mientras bucle en b_server.
- cliente.PY:
Importar la biblioteca SYS como queremos usar la instalación de argumentos en Python.
if (len (sys.argv)> 1):Serverip = sys.Argv [1]
demás:
imprimir ("\ n \ n ejecutar como \ n python3 cliente.py \ n \ n ")
Salir (1)
A medida que pasamos, la dirección IP de B_Server después del cliente de nombre de archivo.PY Mientras se ejecuta, necesitamos atrapar esa dirección IP del servidor dentro del cliente.
… Si (Len (sys.argv)> 1): => para asegurarse de que el usuario pase al menos un argumento como dirección IP y captura esa dirección IP insdie "Servidor IP".
Si el usuario no pasa al menos un código de argumento muestra ayuda y sale del código.
Puerto = 9898Este tiene que ser el mismo puerto que se menciona en el lado b_server.
s.Connect ((ServerIP, Port))Este código hará la conexión TCP a la IP del servidor con ese puerto. Cualquier cosa mal en este pont resulta en fallas en conexión.
archivo = abre ("muestra.txt "," rb ")Estamos abriendo "Muestra.txt ”en modo de lectura para leer solo contenido.
SendData = archivo.Leer (1024)Leer el contenido del archivo y poner dentro "Enviar datos" variable.
Mientras que SendData:Estamos comenzando uno mientras bucle si "Enviar datos" tiene datos. En nuestro caso si "muestra.txt "no está vacío, debería tener datos.
s.Enviar (SendData)Ahora podemos enviar contenido de "muestra.TXT" al servidor usando el objeto Socket "s".
SendData = archivo.Leer (1024)Nuevamente leyendo si queda algo. Entonces no habrá nada que leer del archivo "Enviar datos" estará vacío y saldrá de bucle.
s.cerca()Esto no es cerrar la conexión desde el lado del cliente.
Ubuntu capturas de capturas de pantalla del servidor
Ubuntu Capturas de pantalla Lado del cliente
Combinaciones probadas:
- Linux como servidor y Linux como cliente: pase
- Linux como cliente y Linux como servidor: pase
- Linux como servidor y windows10 como cliente: pase
- Linux como cliente y Windows10 como servidor: pase
La recomendación es usar dos sistemas Linux para servidor y cliente.
Errores esperados:
- Puede ver a continuación un error si el servidor no se ejecuta en el puerto 9898
Rastreo (llamadas recientes más última):
Archivo "cliente.py ", línea 22, en
s.Connect ((ServerIP, Port))
ConnectionRefusedError: [Errno 111] Conexión rechazada
- El siguiente error se ve si la dirección IP no se pasa al lado del cliente
Correr como
Cliente de Python3.py < serverip address >
- El siguiente error se ve si 1calle El argumento al lado del cliente no es una dirección IP
Rastreo (llamadas recientes más última):
Archivo "cliente.py ", línea 22, en
s.Connect ((ServerIP, Port))
enchufe.Gaierror: [errno -2] nombre o servicio no se sabe
- El siguiente error se ve si el puerto se usa como 98980
Rastreo (llamadas recientes más última):
Archivo "cliente.py ", línea 22, en
s.Connect ((ServerIP, Port))
Overflowerror: GetSockAddrarg: El puerto debe ser 0-65535.
- El siguiente error se ve si "muestra.txt "no está presente en el lado del cliente.
Rastreo (llamadas recientes más última):
Archivo "cliente.py ", línea 25, en
archivo = abre ("muestra.txt "," rb ")
FileNotFoundError: [Errno 2] No hay dicho archivo o directorio: 'Muestra.TXT'
Conclusión:
Usando este programa, podemos enviar un archivo de texto simple de un sistema a otro sistema a través de la red utilizando el programa Python. Esto nos da un aprendizaje básico de la programación de Python y Socket también para enviar datos a través de la red.