Manipolazione socket con Python

Il prese Sono l'interfaccia che ci permette di comunicare due o più computer attraverso una rete. Grazie a questo, possiamo creare diversi tipi di applicazioni che ci aiutano a trasmettere dati su Internet e quindi vedere risultati che altrimenti non avremmo in tempo reale.
Uno dei modi più comuni per implementare i socket è attraverso il protocollo TCPQuesto aiuta che con il supporto del sistema operativo la trasmissione via Internet è normale e senza problemi.
Poiché conosciamo un po' il concetto di base di cosa sono le prese, inizieremo manipolando le loro caratteristiche, una di queste è il tempo di attesa.
Tempo di attesaIl tempo di attesa Ci permette di stabilire la quantità di tempo in cui il socket può stare attento a ricevere o inviare dati, questo è molto importante poiché se c'è un blocco dell'applicazione mentre questo tempo è in attesa possiamo correre il rischio di rallentare un intero sistema . Ecco perché abbiamo bisogno di sapere qual è il tempo di attesa predeterminato e anche di poterlo stabilire noi stessi per nostra comodità.
Per raggiungere questo obiettivo possiamo usare un paio di metodi che esistono a tale scopo all'interno della libreria standard presa di Pitone.
gettimeout ()Il primo metodo è gettimeout () e come indica il nome, ci offre il tempo di attesa iniziale del socket che passiamo come parametro.
settimeout ()Il secondo metodo è settimeout () e la sua funzionalità è quella di stabilire un timeout per il socket in questione espresso in millisecondi.
Ora creeremo un piccolo programma che ci permetta di mettere in atto ciò che abbiamo appreso, per questo creeremo prima un oggetto del tipo socket che fungerà da nostro soggetto di prova, per questo passeremo la famiglia e il tipo di socket al costruttore e con quello possiamo applicare i metodi.
Per vedere le modifiche una volta creato il nostro socket stamperemo il suo tempo di attesa che deve essere nullo perché è un nuovo oggetto, quindi con il metodo settimeout () Stabiliremo un nuovo tempo di attesa e infine stamperemo le informazioni, confermando così che tutto ha funzionato come doveva.
Per ottenere tutto questo dobbiamo assicurarci di avere Pitone installato nel nostro sistema, nella sua versione 2.7, e avere un editor di testo per poter creare i file con i programmi, anche se possiamo fare l'esercizio anche sulla console, tuttavia è un po' più scomodo e non è persistente, il che significa che perderemmo il nostro lavoro. Diamo un'occhiata al codice sorgente per questo esempio:

 #! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Il timeout iniziale è:% s"% s.gettimeout () s. settimeout (100 ) print "Il nuovo timeout è:% s"% s.gettimeout () if __name__ == '__main__': time_out_socket () 

Lo salveremo in un nuovo file chiamato socketTimeWait.py e lo eseguiremo in console, il risultato dovrebbe essere qualcosa di simile al seguente:

Il respingente È un'altra delle cose che dobbiamo prendere in considerazione quando lavoriamo con i socket, poiché questo componente è quello che indicherà la quantità di dati che possiamo trasmettere al momento, a più tampone Maggiore è la quantità di dati, però questo significa anche un maggiore consumo di risorse e un tempo di attesa più lungo nella trasmissione degli stessi. Altrimenti a tampone inferiore Rappresenta più velocità sebbene limiti la quantità di dati da trasferire, ecco perché è un'abilità che dobbiamo padroneggiare.
setsockopt ()Per aiutarci a manipolare il buffer della libreria presa di Pitone ci offre il metodo setsockopt(), che dobbiamo applicare a un'istanza della classe socket. Se vogliamo cambiare la dimensione del buffer, sicuramente dobbiamo prima conoscere la dimensione originale del buffer del socket, per questo abbiamo anche il metodo prendi in giro () ed è usato più o meno allo stesso modo del metodo che abbiamo descritto sopra.
Creeremo un piccolo programma per dimostrare quanto spiegato in precedenza, nel codice che vedremo andremo prima a creare una coppia di costanti che useremo nel nostro programma e che sarà definito come 4096 che è un valore per la dimensione dei buffer che stabiliremo.
Quindi facciamo un'istanza della classe socket, per chiedere subito le dimensioni iniziali del buffer, poi le stampiamo a schermo.
Infine useremo il metodo setsockopt () Per impostare la dimensione desiderata del buffer utilizzando le costanti definite all'inizio del programma, questo metodo riceve tre parametri, il livello, il nome e infine il valore per il buffer.
Vediamo il codice che ci aiuta a specificare quanto spiegato, lo salveremo in un file chiamato size_buffer.py:

 #! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipola_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Ottieni la dimensione del buffer di invio del socket sizeBufferopt = sock.getso (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Buffer Size [Before]:% d"% Buffer size 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 "Buffer size [After]:% d"% manipola_buffer_size = '__buffer_size ='__buffer_size =' =' __ () 

Una volta scritto il nostro programma, procederemo ad eseguirlo nella console e vedremo che otteniamo i valori del buffer prima e dopo averne modificato le dimensioni.

Come con tutti i tipi di programmi, quando lavoriamo con i socket non siamo esenti dall'incontrare alcuni errori, il problema che dobbiamo evitare è che questi errori ci sorprendano, poiché se lo fanno, la nostra applicazione può funzionare in modo imprevedibile.
Ecco perché dobbiamo imparare a gestire gli errori, in questo modo se si verifica una situazione imprevista, il nostro programma non muore ma ci informa che è successo qualcosa, con questo eviteremo il danneggiamento dei dati o situazioni simili che influiscono sulla stabilità del nostro programma.
Come gestirlo?Otteniamo questo usando i blocchi prova - tranne che ci consentono di valutare situazioni, generalmente che coinvolgono dati al di fuori del nostro controllo e con questo possiamo agire in scenari in base alle risposte che otteniamo. Se cadiamo nella sezione tranne del blocco possiamo usare la proprietà error della nostra istanza e con essa stampare cosa è successo e quindi sapere qual è stato l'errore.
Nel seguente programma andremo a verificare quanto definito durante la spiegazione. Prima di tutto creeremo un blocco che ci controlli se la creazione del socket ha avuto un errore o meno, con questo possiamo garantire un buon inizio del nostro codice.
Quindi valuteremo la connessione della nostra applicazione a un host remoto tramite una porta particolare e con la gestione degli errori possiamo definire un messaggio personalizzato. Infine effettuiamo la chiamata alla nostra funzione e con essa eseguiremo le azioni descritte.
Vediamo il seguente codice che dobbiamo memorizzare in un file chiamato errors_socket.py e poi lo eseguiremo in 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) tranne socket.error, e: print "Si è verificato un errore durante la creazione del socket:% s"% e sys.exit (1) try: s.connect ((host, porta)) tranne socket.gaierror, e: print "Errore in connection address:% s "% e sys.exit (1) tranne socket.error, e: print" Errore di connessione:% s "% e sys.exit (1) if __name__ == '__main__': error_handling () 

Qui vediamo che abbiamo usato la libreria sistema per utilizzare il metodo Uscita () e chiudere il programma dopo che si è verificato un errore. Notiamo anche che l'host non è corretto, questo è così che possiamo forzare l'errore e quindi vedere il messaggio sullo schermo. Infine notiamo che utilizziamo la variabile e per catturare l'errore del socket, con questo possiamo ottenere il dettaglio reale di quanto accaduto.
RicordareQui dobbiamo stare particolarmente attenti con il rientro del codice ricorda che Pitone Non usando le parentesi graffe, il punto e virgola anche per definire le chiusure dei blocchi dipende esclusivamente dagli spazi o dalle tabulazioni che utilizziamo, quindi se non lo facciamo correttamente vedremo errori di sintassi.
È molto importante leggere la documentazione del Libreria socket Python in modo che tu possa trovare modi migliori e più per sfruttare le tue risorse.
Con questo finiamo questo tutorial, abbiamo capito come Pitone dispone di strumenti molto facili da capire che ci danno accesso al mondo di preseCon questo possiamo iniziare a programmare applicazioni che utilizzano le reti per eseguire elaborazioni in tempo reale, come ottenere informazioni da altre macchine sulla rete o anche da Internet.Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo