Socketmanipulatie met Python

De stopcontacten Ze zijn de interface waarmee we twee of meer computers via een netwerk kunnen communiceren. Hierdoor kunnen we verschillende soorten applicaties maken die ons helpen gegevens over internet te verzenden en zo resultaten te zien die we anders niet in realtime zouden hebben.
Een van de meest gebruikelijke manieren om sockets te implementeren is via het protocol TCPDit helpt dat met de ondersteuning van het besturingssysteem de overdracht via internet normaal en zonder problemen verloopt.
Omdat we een beetje weten over het basisconcept van wat sockets zijn, gaan we beginnen met het manipuleren van hun kenmerken, een daarvan is de wachttijd.
Wacht tijdDe wacht tijd Het stelt ons in staat om de hoeveelheid tijd vast te stellen die de socket attent kan zijn om gegevens te ontvangen of te verzenden, dit is erg belangrijk, want als er een blokkering van de applicatie is terwijl deze tijd wacht, kunnen we het risico lopen een heel systeem te vertragen . Daarom hebben we behoefte om te weten wat de vooraf bepaalde wachttijd is en ook om er zelf een te kunnen vaststellen voor ons gemak.
Om dit te bereiken kunnen we een aantal methoden gebruiken die voor dat doel in de standaardbibliotheek bestaan stopcontact van Python.
gettime-out ()De eerste methode is: gettime-out () en zoals de naam aangeeft, biedt het ons de initiële wachttijd van de socket die we als parameter doorgeven.
uitschakeltijd ()De tweede methode is: uitschakeltijd () en de functionaliteit ervan is om een ​​time-out voor de betreffende socket vast te stellen, uitgedrukt in milliseconden.
We gaan nu een klein programma maken waarmee we in praktijk kunnen brengen wat we hebben geleerd, hiervoor gaan we eerst een object van het socket-type maken dat als ons testonderwerp zal dienen, hiervoor zullen we de familie doorgeven en het sockettype naar de constructor en daarmee kunnen we de methoden toepassen.
Om de wijzigingen te zien zodra we onze socket hebben gemaakt, zullen we de wachttijd afdrukken die null moet zijn omdat het een nieuw object is, en vervolgens met de methode uitschakeltijd () We zullen een nieuwe wachttijd instellen en ten slotte zullen we de informatie afdrukken, waarmee we bevestigen dat alles naar behoren heeft gewerkt.
Om dit alles te bereiken, moeten we ervoor zorgen dat we Python geïnstalleerd in ons systeem, in zijn versie 2.7, en een teksteditor hebben om de bestanden met de programma's te kunnen maken, hoewel we de oefening ook op de console kunnen doen, maar het is een beetje ongemakkelijker en het is niet persistent, wat betekent dat we ons werk zouden verliezen. Laten we eens kijken naar de broncode voor dit voorbeeld:

 #! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Initiële time-out is:% s"% s.gettimeout () s. settimeout (100 ) print "De nieuwe time-out is:% s"% s.gettimeout () if __name__ == '__main__': time_out_socket () 

We gaan dit opslaan in een nieuw bestand genaamd socketTimeWait.py en we zullen het in de console uitvoeren, het resultaat zou ongeveer als volgt moeten zijn:

De buffer Het is nog een van de dingen waarmee we rekening moeten houden wanneer we met sockets werken, aangezien dit onderdeel degene is die de hoeveelheid gegevens aangeeft die we op dit moment kunnen verzenden, om meer buffer Hoe groter de hoeveelheid gegevens, maar dit betekent ook meer verbruik van middelen en een langere wachttijd bij de verzending ervan. anders een lagere buffer Het vertegenwoordigt meer snelheid, hoewel het de hoeveelheid gegevens die moet worden overgedragen, beperkt, daarom is het een vaardigheid die we moeten beheersen.
setsockopt ()Om ons te helpen de buffer van de bibliotheek te manipuleren stopcontact van Python biedt ons de methode setsockopt(), die we moeten toepassen op een instantie van de socketklasse. Als we de grootte van de buffer willen veranderen, moeten we toch eerst de originele grootte van de socketbuffer weten, hiervoor hebben we ook de methode oppakken () en het wordt op vrijwel dezelfde manier gebruikt als de methode die we hierboven hebben beschreven.
We gaan een klein programma maken om te demonstreren wat we eerder hebben uitgelegd, in de code die we zullen zien, gaan we eerst naar maak een paar constanten die we zullen gebruiken in ons programma en zullen worden gedefinieerd om 4096 wat een waarde is voor de grootte van de buffers die we zullen vaststellen.
Vervolgens maken we een instantie van de socketklasse, om meteen te vragen naar de begingroottes van de buffer, en printen we deze op het scherm.
Ten slotte zullen we de methode gebruiken: setsockopt () Om de gewenste grootte van de buffer in te stellen met behulp van de constanten die aan het begin van het programma zijn gedefinieerd, ontvangt deze methode drie parameters, het niveau, de naam en tenslotte de waarde voor de buffer.
Laten we eens kijken naar de code die ons helpt te specificeren wat we hebben uitgelegd, we gaan het opslaan in een bestand met de naam size_buffer.py:

 #! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipuleren_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Buffergrootte [Before]:% d"% Buffergrootte 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 "Buffergrootte [Na]:% d"% manipuleren_buffer_size = '___buffer_size =' =' __ () 

Nadat we ons programma hebben geschreven, gaan we het uitvoeren in de console en zullen we zien dat we de waarden van de buffer verkrijgen voor en na het wijzigen van de grootte.

Zoals met alle soorten programma's, zijn we bij het werken met sockets niet vrijgesteld van het tegenkomen van enkele fouten. Het probleem dat we moeten vermijden is dat deze fouten ons verrassen, omdat als ze dat doen, onze applicatie onvoorspelbaar kan functioneren.
Daarom moeten we leren omgaan met fouten, op deze manier, als zich een onverwachte situatie voordoet, sterft ons programma niet maar meldt het ons dat er iets is gebeurd, hiermee voorkomen we datacorruptie of soortgelijke situaties die de stabiliteit van ons programma aantasten.
Hoe ermee om te gaan?Dit bereiken we met blokken probeer - behalve die ons in staat stellen situaties te evalueren, in het algemeen die gegevens bevatten waarover wij geen controle hebben, en hiermee kunnen we in scenario's handelen in overeenstemming met de antwoorden die we krijgen. Als we in de sectie vallen behalve van het blok kunnen we de fouteigenschap van onze instantie gebruiken en daarmee afdrukken wat er is gebeurd en zo weten wat de fout was.
In het volgende programma gaan we testen wat we tijdens de uitleg hebben gedefinieerd. Allereerst gaan we een blok maken dat ons controleert of het maken van de socket een fout heeft gehad of niet, hiermee kunnen we zorgen voor een goede start van onze code.
Vervolgens gaan we de verbinding van onze applicatie met een externe host via een bepaalde poort evalueren en met foutafhandeling kunnen we een aangepast bericht definiëren. Ten slotte doen we de oproep naar onze functie en zullen we de beschreven acties uitvoeren.
Laten we de volgende code bekijken die we moeten opslaan in een bestand met de naam errors_socket.py en dan zullen we het in de console uitvoeren:

 #! / usr / bin / env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): probeer: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) behalve socket.error, e: print "Er is een fout opgetreden bij het maken van de socket:% s"% e sys.exit (1) probeer: s.connect ((host, poort)) behalve socket.gaierror, e: print "Fout in verbindingsadres:% s "% e sys.exit (1) behalve socket.error, e: print" Verbindingsfout:% s "% e sys.exit (1) if __name__ == '__main__': error_handling () 

Hier zien we dat we de bibliotheek hebben gebruikt sys om de methode te gebruiken Uitgang () en sluit het programma nadat er een fout is opgetreden. We merken ook op dat de host niet klopt dit is zodat we de fout kunnen forceren en zo de melding op het scherm kunnen zien. Ten slotte merken we op dat we de variabele e gebruiken om de socketfout vast te leggen, hiermee kunnen we het echte detail verkrijgen van wat er is gebeurd.
HerinnerenHier moeten we vooral voorzichtig zijn met de inspringing van de code onthoud dat: Python Door geen accolades te gebruiken, zijn puntkomma's ook om blokafsluitingen te definiëren uitsluitend afhankelijk van de spaties of tabbladen die we gebruiken, dus als we het niet correct doen, zullen we syntaxisfouten zien.
Het is erg belangrijk dat we de documentatie van de Python-socketbibliotheek zodat u meer en betere manieren kunt vinden om uw middelen te benutten.
Hiermee sluiten we deze tutorial af, we hebben ons gerealiseerd hoe Python heeft zeer gemakkelijk te begrijpen tools die ons toegang geven tot de wereld van stopcontactenHiermee kunnen we beginnen met het programmeren van applicaties die netwerken gebruiken om realtime verwerking uit te voeren, zoals het verkrijgen van informatie van andere machines op het netwerk of zelfs van internet.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven