Transferência de arquivo de soquete python
Diagrama de configuração básico:
Aqui está o diagrama de configuração básico para executar este programa.
Por simplicidade, chamaremos o sistema A como A_CLIENT e SYSTEM B como B_SERVER Durante o artigo.
Requisitos de arquivo:
Nós precisamos servidor.py e este arquivo deve estar presente no sistema de servidor. Em nosso servidor de caso.PY deve estar no sistema B_Server.
Outros dois arquivos cliente.py e amostra.TXT deve estar presente no sistema de clientes. No nosso caso, esses dois arquivos devem estar presentes no sistema A_Client.
Premissas:
Aqui estão as suposições:
- Devemos ter dois sistemas Linux com acesso ao terminal.
- O sabor Linux preferível é Ubuntu.
- Python3 deve ser instalado.
- Ambos. Usar ping comando para verificar ping.
- Um sistema deve atuar como servidor e outro sistema deve atuar como cliente em um momento específico.
Limitações:
Antes de prosseguir, devemos saber que existem algumas limitações deste programa.
- Python3+ deve ser instalado para executar este programa. Você pode observar erro ou comportamento diferente se for executado em versões mais antigas do Python.
- Somente o arquivo de texto pode ser transferido através deste programa a partir de agora. Qualquer outro arquivo de formato que não contenha texto pode falhar.
- Exceções de programação básica foram tratadas no programa.
- O programa pode ou não ser executado em outro sistema operacional que não o ubuntu.
- O arquivo de texto deve ser curto no lado do cliente, pois o tamanho do buffer de 1024 bytes foi usado.
Requisitos de configuração:
- Precisamos de pelo menos um sistema Linux para experimentar este programa. Mas a recomendação é usar dois sistemas Linux diferentes que são conectados através da rede.
- Dois sistemas devem ser conectados através da Ethernet ou Wi-Fi ou qualquer outra conexão.
Código -fonte do servidor:
https: // github.com/linuxhintcode/websamles/blob/master/python_send_file/servidor.py
Código -fonte do cliente:
https: // github.com/linuxhintcode/web amostras/blob/master/python_send_file/cliente.py
#!/usr/bin/Env Python3# Importação de bibliotecas
soquete de importação
Importar sistemas
# Vamos pegar o 1º argumento como IP do servidor
If (Len (SYS.argv)> 1):
Serverip = sys.argv [1]
outro:
print ("\ n \ n Run como \ n python3 cliente.py \ n \ n ")
saída (1)
# Agora podemos criar objeto de soquete
s = soquete.soquete ()
# Vamos escolher uma porta e conectar -se a essa porta
Porta = 9898
# Vamos nos conectar a essa porta onde o servidor pode estar em execução
s.Connect ((Serverip, Port))
# Podemos enviar amostra de arquivo.TXT
arquivo = aberto ("amostra.txt "," rb ")
SendData = arquivo.Leia (1024)
Enquanto senddata:
# Agora podemos receber dados do servidor
Print ("\ n \ n ##################ou n \ n ", s.RECV (1024).Decode ("UTF-8"))
#Agora envie o conteúdo da amostra.txt para servidor
s.send (sendData)
SendData = arquivo.Leia (1024)
# Feche a conexão do lado do cliente
s.fechar()
Como executar programas e saída esperada:
Aqui estão as etapas para executar o programa.
Etapa 1: vá para o sistema B_SERVER e abra um terminal. Atalho para abrir um terminal é ALT+CTRL+T.
Etapa2: agora siga o caminho onde o servidor.Py está presente.
Etapa 3: agora execute o servidor.py como abaixo
servidor python3.py
Não deve haver erros e você deve ver as impressões abaixo
O servidor está listando na porta: 9898
O nome do arquivo copiado será RECV.txt no lado do servidor
Etapa 4: agora aberto terminal no sistema A_CLIENT.
Etapa 5: vá para o caminho onde o cliente.py e amostra.txt estão presentes.
Etapa 6: agora execute o cliente.py como abaixo
cliente python3.pyObservamos que precisamos conhecer o endereço IP do servidor. Podemos executar o comando abaixo para saber o endereço IP do sistema B_SERVER.
ifconfig
Agora a saída do sistema A_Client deve ser assim
################# A mensagem abaixo é recebida do servidor ####################
| ----------------------------------- |
Olá cliente [Endereço IP: 192.168.1.102],
** Bem -vindo ao servidor **
-Servidor
| ----------------------------------- |
Etapa 7: Agora vá para B_Server e procure por saída abaixo
O arquivo foi copiado com sucesso
Servidor fechou a conexão
Etapa 8: deve haver um nome de arquivo recv.txt na pasta do servidor. O conteúdo deste RECV.txt deve ser o mesmo amostra.TXT.
Por isso, copiamos com sucesso um arquivo do cliente para o servidor por rede através do programa Python.
Explicações de código:
Existem dois arquivos python servidor.py e cliente.py.
Observe que explicaremos uma vez se algum código for o mesmo servidor interno.py e cliente.py.
- servidor.PY:
Esta é a linha Shebang, que significa que, por padrão, este servidor.py deve usar python3. Vamos ver uma vantagem desta linha.
Nós executamos o servidor.py ou cliente.py como Python3 . Agora, sem usar o python3, podemos executar o arquivo python. Siga os comandos abaixo
Vá para o Modo Super Usuário:
su
Dar toda a permissão para .arquivo py:
Servidor CHMOD 777.py
Executar servidor.PY:
./servidor.pysoquete de importação
#Importing Socket Library no programa Python, pois vamos usar o soquete para conexão.
s = soquete.soquete ()
Estamos criando um objeto "S" Para acessar todos os métodos de soquete. Este é um conceito OOPS.
Porta = 9898Agora escolhemos uma porta onde o servidor estará ouvindo. Podemos usar porta não reservada em vez disso.
s.bind ((", porta))Usamos o método de ligação para vincular o endereço IP do servidor a essa porta [9898]. Uma observação é que poderíamos ter usado o endereço IP exato do servidor no lugar do primeiro argumento do método de ligação, mas optamos por deixar em branco, pois isso funciona bem.
s.vincular ((endereço IP, porta))arquivo = aberto ("RECV.txt "," wb ")
Abrimos um nome de arquivo “RECV.txt ”no servidor para o modo de gravação e obteve ponteiro de arquivo. Isso é necessário, pois temos que copiar um arquivo de texto do cliente.
enquanto é verdade:Vamos iniciar um infinito enquanto o loop como o trabalho do servidor é esperar até que um cliente se comunique com o servidor nessa porta 9898. Então isso enquanto o loop é necessário.
Conn, addr = s.aceitar()Este código é aceitar qualquer solicitação de conexão recebida do cliente. Conn usará “Conn ” para se comunicar com o cliente e “Addr” é o endereço IP do cliente que enviou uma solicitação de comoção para este servidor na porta 9898.
msg = "\ n \ n | --------------------------------- | \ n oi cliente [endereço IP:" + addr [0] +"], \ n ** bem -vindo ao servidor ** \ n -server \ n
| ----------------------------------- | \ n \ n \ n "
Este código é criar uma mensagem para enviar para o cliente. Esta mensagem deve ser impressa no terminal do cliente. Isso confirma que o cliente é capaz de se comunicar com o servidor.
Conn.Send (msg.codificar())Agora temos a mensagem pronta e depois a enviamos para o cliente usando isso "Conn". Este código realmente envia mensagem para o cliente.
Recvdata = Conn.RECV (1024)Este código está recebendo quaisquer dados enviados do lado do cliente. No nosso caso, estamos esperando o conteúdo da amostra.txt in “Recvdata”.
enquanto recvdata:Mais um enquanto o loop com a condição recvdata não está vazio. No nosso caso, não está vazio.
arquivo.Escreva (recvdata)Uma vez que temos conteúdo dentro “Recvdata” Então estamos escrevendo para esse arquivo “Recv.TXT" usando o ponteiro do arquivo "arquivo".
Recvdata = Conn.RECV (1024)Novamente tentando receber se houver algum dados do cliente. Uma vez “Recvdata” não tem dados que o código quebrará o loop while.
arquivo.fechar()Isso apenas fechará o ponteiro do arquivo, como terminamos com a gravação do arquivo.
Conn.fechar()Isso fechará a conexão com o cliente.
quebrarIsso é para sair de infinito enquanto loop em b_server.
- cliente.PY:
Importar a Biblioteca SYS, como queremos usar o Facility de argumento em Python.
If (Len (SYS.argv)> 1):Serverip = sys.argv [1]
outro:
print ("\ n \ n Run como \ n python3 cliente.py \ n \ n ")
saída (1)
À medida que passamos pelo endereço IP do B_Server após o nome do arquivo.Py durante a execução, precisamos pegar o endereço IP do servidor dentro do cliente.
… If (Len (Sys.argv)> 1): => Para garantir que o usuário passe pelo menos um argumento como endereço IP e pegue esse endereço IP Insdie "IP do servidor".
Se o usuário não passar pelo menos um código de argumento, mostrar ajuda e sair do código.
Porta = 9898Esta deve ser a mesma porta mencionada no lado B_Server.
s.Connect ((Serverip, Port))Este código fará a conexão TCP com o IP do servidor com essa porta. Qualquer coisa errada neste ponint resulta em falhas em conexão.
arquivo = aberto ("amostra.txt "," rb ")Estamos abrindo “amostra.txt ”no modo de leitura para ler apenas conteúdo.
SendData = arquivo.Leia (1024)Lendo o conteúdo do arquivo e colocando dentro “SendData ” variável.
Enquanto senddata:Estamos começando um enquanto loop se “SendData ” tem dados. No nosso caso, se “amostra.txt ”não está vazio, ele deve ter dados.
s.send (sendData)Agora podemos enviar conteúdo de "amostra.TXT" para servidor usando objeto de soquete "S".
SendData = arquivo.Leia (1024)Novamente lendo se houver algo restante. Portanto, não haverá nada para ler do arquivo “SendData” estará vazio e sairá de enquanto o loop.
s.fechar()Isso não está próximo da conexão do lado do cliente.
Lado do servidor de captura de tela do Ubuntu
Screenshots do Ubuntu Lado do cliente
Combinações testadas:
- Linux como servidor e Linux como cliente: Passe
- Linux como cliente e Linux como servidor: Passe
- Linux como servidor e Windows10 como cliente: Passe
- Linux como cliente e Windows10 como servidor: Passe
A recomendação é usar dois sistemas Linux para servidor e cliente.
Erros esperados:
- Você pode ver o erro abaixo se o servidor não estiver em execução na porta 9898
Traceback (chamada mais recente):
Arquivo "cliente.py ", linha 22, em
s.Connect ((Serverip, Port))
ConnectionRefusedError: [Errno 111] Conexão recusada
- O erro abaixo é visto se o endereço IP não for passado no lado do cliente
Correr como
cliente python3.py < serverip address >
- O erro abaixo é visto se 1st Argumento no lado do cliente não é um endereço IP
Traceback (chamada mais recente):
Arquivo "cliente.py ", linha 22, em
s.Connect ((Serverip, Port))
soquete.Gaierror: [Errno -2] Nome ou serviço não conhecido
- O erro abaixo é visto se a porta for usada como 98980
Traceback (chamada mais recente):
Arquivo "cliente.py ", linha 22, em
s.Connect ((Serverip, Port))
OverflowerRor: getsockaddRarg: a porta deve ser 0-65535.
- O erro abaixo é visto se “amostra.txt ”não está presente no lado do cliente.
Traceback (chamada mais recente):
Arquivo "cliente.py ", linha 25, em
arquivo = aberto ("amostra.txt "," rb ")
FileNotFoundError: [Errno 2] Nenhum arquivo ou diretório: 'Amostra.TXT'
Conclusão:
Usando este programa, podemos enviar um arquivo de texto simples de um sistema para outro sistema através da rede usando o programa Python. Isso nos dá aprendizado básico da programação Python e Socket também para enviar dados sobre a rede.