Índice
O tomadas Eles são a interface que nos permite comunicar dois ou mais computadores em uma rede. Graças a isso, podemos criar diferentes tipos de aplicativos que nos ajudam a transmitir dados pela Internet e, assim, ver resultados que de outra forma não teríamos em tempo real.Uma das maneiras mais comuns de implementar sockets é por meio do protocolo TCPIsso ajuda que com o suporte do sistema operacional a transmissão via Internet seja normal e sem problemas.
Como sabemos um pouco sobre o conceito básico do que são soquetes, vamos começar manipulando suas características, uma delas é o tempo de espera.
Tempo de esperaO Tempo de espera Permite-nos estabelecer quanto tempo o socket pode ficar atento para receber ou enviar dados, isto é muito importante pois se houver um bloqueio da aplicação durante este tempo podemos correr o risco de atrasar todo o sistema . É por isso que precisamos saber qual é o tempo de espera pré-determinado e também poder estabelecê-lo para nossa comodidade.
Para conseguir isso, podemos usar alguns métodos que existem para esse fim na biblioteca padrão tomada do Pitão.
gettimeout ()O primeiro método é gettimeout () e como o próprio nome indica, oferece-nos o tempo de espera inicial da tomada que passamos como parâmetro.
settimeout ()O segundo método é settimeout () e sua funcionalidade é estabelecer um tempo limite para o soquete em questão expresso em milissegundos.
Vamos agora criar um pequeno programa que nos permite colocar em ação o que aprendemos, para isso vamos primeiro criar um objeto do tipo socket que servirá como nosso sujeito de teste, para isso vamos passar a família e o tipo de socket para o construtor e com isso podemos aplicar os métodos.
A fim de ver as mudanças uma vez que tenhamos criado nosso soquete, iremos imprimir seu tempo de espera que deve ser nulo porque é um novo objeto, então com o método settimeout () Estabeleceremos um novo tempo de espera e por fim imprimiremos as informações, confirmando assim que tudo funcionou como deveria.
Para conseguir tudo isso, devemos garantir que temos Pitão instalado em nosso sistema, em sua versão 2.7, e ter um editor de texto para poder criar os arquivos com os programas, embora também possamos fazer o exercício no console, porém é um pouco mais incômodo e não é persistente, o que significa que perderíamos nosso trabalho. Vejamos o código-fonte deste exemplo:
#! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "O tempo limite inicial é:% s"% s.gettimeout () s. settimeout (100 ) print "O novo tempo limite é:% s"% s.gettimeout () if __name__ == '__main__': time_out_socket ()
Vamos salvar isso em um novo arquivo chamado socketTimeWait.py e vamos executá-lo no console, o resultado deve ser algo semelhante ao seguinte:
setsockopt ()Para nos ajudar a manipular o buffer, a biblioteca tomada do Pitão nos oferece o método setsockopt(), que devemos aplicar a uma instância da classe de soquete. Se quisermos alterar o tamanho do buffer, com certeza devemos primeiro saber o tamanho original do buffer de socket, para isso também temos o método getockopt () e é usado da mesma maneira que o método que descrevemos acima.
Vamos criar um pequeno programa para demonstrar o que explicamos anteriormente, no código que veremos iremos primeiro para crie um par de constantes que usaremos em nosso programa e será definido para 4096 que é um valor para o tamanho dos buffers que iremos estabelecer.
Em seguida, fazemos uma instância da classe socket, para solicitar imediatamente os tamanhos iniciais do buffer, depois os imprimimos na tela.
Finalmente, usaremos o método setsockopt () Para definir o tamanho desejado do buffer usando as constantes definidas no início do programa, este método recebe três parâmetros, o nível, o nome e finalmente o valor do buffer.
Vamos ver o código que nos ajuda a especificar o que explicamos, vamos salvá-lo em um arquivo chamado size_buffer.py:
#! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipulate_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Obtenha o tamanho do buffer de envio do socket sizeBufferopt = sock.getso (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Tamanho do Buffer [Antes]:% d"% Tamanho do Buffer sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNDBUFFER_ sock. setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, SIZE_BUFFER_RECEPCION) buffersize = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Tamanho do buffer [depois]:% d"% manipulate_buffer_size = '__buffer_size = __buffer_size =' ifuffer ' = '__ ()
Uma vez que tenhamos escrito nosso programa, iremos executá-lo no console e veremos que obtemos os valores do buffer antes e depois de modificar seu tamanho.
Por isso devemos aprender a lidar com os erros, desta forma, caso ocorra uma situação inesperada, nosso programa não morre mas nos avisa que algo aconteceu, com isso evitaremos a corrupção de dados ou situações semelhantes que afetem a estabilidade do nosso Programa.
Como lidar com isso?Conseguimos isso usando blocos tente - exceto que nos permitem avaliar situações, geralmente que envolvem dados fora do nosso controle e com isso podemos atuar em cenários de acordo com as respostas que obtemos. Se cairmos na seção exceto do bloco podemos usar a propriedade error de nossa instância e com ela imprimir o que aconteceu e assim saber qual foi a falha.
No programa a seguir vamos testar o que definimos durante a explicação. Primeiramente vamos criar um bloco que nos controle se a criação do socket teve um erro ou não, com isso podemos garantir um bom início de nosso código.
Em seguida, vamos avaliar a conexão de nossa aplicação a um host remoto através de uma porta específica e com o tratamento de erros podemos definir uma mensagem personalizada. Finalmente fazemos a chamada para a nossa função e com ela vamos executar as ações descritas.
Vamos ver o seguinte código que devemos armazenar em um arquivo chamado errors_socket.py e então iremos executá-lo no console:
#! / usr / bin / env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): try: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) exceto socket.error, e: print "Ocorreu um erro ao criar o soquete:% s"% e sys.exit (1) try: s.connect ((host, porta)) exceto socket.gaierror, e: print "Erro no endereço de conexão:% s "% e sys.exit (1) exceto socket.error, e: print" Erro de conexão:% s "% e sys.exit (1) if __name__ == '__main__': error_handling ()
Aqui vemos que usamos a biblioteca sys a fim de usar o método saída () e feche o programa após a ocorrência de um erro. Também observamos que o host está incorreto para que possamos forçar o erro e, assim, ver a mensagem na tela. Por fim, notamos que utilizamos a variável e para capturar o erro do socket, com isso podemos obter o real detalhe do ocorrido.
LembrarAqui devemos ter um cuidado especial com o recuo do código lembre-se disso Pitão Por não usar colchetes, o ponto-e-vírgula também para definir o fechamento do bloco depende exclusivamente dos espaços ou tabulações que usamos, portanto, se não o fizermos corretamente, veremos erros de sintaxe.
É muito importante que leiamos a documentação do Biblioteca de soquete Python para que você possa encontrar mais e melhores maneiras de aproveitar seus recursos.
Com isso terminamos este tutorial, percebemos como Pitão tem ferramentas muito fáceis de entender que nos dão acesso ao mundo de tomadasCom isso podemos começar a programar aplicativos que utilizam redes para realizar processamento em tempo real, como a obtenção de informações de outras máquinas da rede ou mesmo da Internet.Gostou e ajudou este tutorial?Você pode recompensar o autor pressionando este botão para dar a ele um ponto positivo
