Socket manipulation med Python

Det stikkontakter De er grænsefladen, der giver os mulighed for at kommunikere to eller flere computere via et netværk. Takket være dette kan vi oprette forskellige typer applikationer, der hjælper os med at overføre data over internettet og dermed se resultater, som vi ellers ikke ville have i realtid.
En af de mest almindelige måder at implementere stikkontakter på er gennem protokollen TCPDette hjælper med at understøttelse af operativsystemet er transmissionen via Internettet normal og uden problemer.
Da vi kender lidt til det grundlæggende koncept for hvad stikkontakter er, vil vi starte med at manipulere deres egenskaber, en af ​​dem er ventetiden.
VentetidDet ventetid Det giver os mulighed for at fastslå den tid, stikket kan være opmærksom på at modtage eller sende data, dette er meget vigtigt, da hvis der er en blokering af applikationen, mens denne tid venter, kan vi lide risikoen for at bremse et helt system . Derfor har vi brug for at kunne vide, hvad den forudbestemte ventetid er, og også for at være i stand til at etablere en selv for vores bekvemmelighed.
For at opnå dette kan vi bruge et par metoder, der findes til dette formål i standardbiblioteket stikkontakt af Python.
gettimeout ()Den første metode er gettimeout () og som navnet angiver, tilbyder den os den oprindelige ventetid for stikket, som vi sender som parameter.
settimeout ()Den anden metode er settimeout () og dens funktionalitet er at etablere en timeout for den pågældende socket udtrykt i millisekunder.
Vi skal nu oprette et lille program, der giver os mulighed for at omsætte det, vi har lært, for dette skal vi først oprette et objekt af stikkontakten, der vil tjene som vores testperson, for dette vil vi passere familien og stikkontakten til konstruktøren og med det kan vi anvende metoderne.
For at se ændringerne, når vi har oprettet vores socket, vil vi udskrive dens ventetid, som skal være nul, fordi det er et nyt objekt, derefter med metoden settimeout () Vi etablerer en ny ventetid, og til sidst vil vi udskrive oplysningerne og dermed bekræfte, at alt har fungeret som det skal.
For at opnå alt dette skal vi sikre, at vi har Python installeret i vores system, i dets version 2.7, og har en tekstredigerer for at kunne oprette filerne med programmerne, selvom vi også kan lave øvelsen på konsollen, men det er lidt mere ubehageligt, og det er ikke vedholdende, hvilket betyder, at vi ville miste vores arbejde. Lad os se på kildekoden til dette eksempel:

 #! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Initial timeout is:% s"% s.gettimeout () s. setimeout (100 ) print "Den nye timeout er:% s"% s.gettimeout () hvis __name__ == '__main__': time_out_socket () 

Vi vil gemme dette i en ny fil kaldet socketTimeWait.py og vi vil udføre det i konsol, resultatet skal være noget lignende det følgende:

Det buffer Det er en anden af ​​de ting, vi skal tage i betragtning, når vi arbejder med stikkontakter, da denne komponent er den, der angiver mængden af ​​data, som vi kan overføre i øjeblikket, til mere buffer Jo større datamængde, men dette betyder også mere forbrug af ressourcer og en længere ventetid ved overførsel af de samme. Ellers a lavere buffer Det repræsenterer mere hastighed, selvom det begrænser mængden af ​​data, der skal overføres, derfor er det en færdighed, vi skal mestre.
setsockopt ()For at hjælpe os med at manipulere bufferen biblioteket stikkontakt af Python tilbyder os metoden setsockopt(), som vi skal anvende på en forekomst af socketklassen. Hvis vi vil ændre størrelsen på bufferen, skal vi helt sikkert først kende den originale størrelse på socketbufferen, til dette har vi også metoden getockopt () og det bruges stort set på samme måde som den metode, vi beskrev ovenfor.
Vi skal oprette et lille program for at demonstrere det, vi tidligere har forklaret, i den kode, som vi vil se, vi først går til oprette et par konstanter som vi vil bruge i vores program og vil blive defineret til 4096 som er en værdi for størrelsen af ​​bufferne, som vi vil etablere.
Derefter laver vi en forekomst af socketklassen, for straks at bede om de oprindelige størrelser af bufferen, derefter udskriver vi dem på skærmen.
Endelig vil vi bruge metoden setsockopt () For at indstille den ønskede størrelse af bufferen ved hjælp af de konstanter, der er defineret i programmets begyndelse, modtager denne metode tre parametre, niveauet, navnet og endelig værdien for bufferen.
Lad os se koden, der hjælper os med at specificere, hvad vi har forklaret, vi kommer til at gemme den i en fil kaldet size_buffer.py:

 #! / usr / bin / env python importstik TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipulate_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Få størrelsen på stikkets sendebuffer størrelse bufferopt = sock (socket.SOL_SOCKET, socket.SO_SNDBUF) udskriver "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) udskrive "Bufferstørrelse [Efter]:% d"% manipulere_buffer_size =_ __b_størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse__størrelse = '__b = '__ () 

Når vi har skrevet vores program, vil vi fortsætte med at udføre det i konsollen, og vi vil se, at vi får værdierne for bufferen før og efter at have ændret dens størrelse.

Som med alle typer programmer, når vi arbejder med sockets, er vi ikke fritaget for at støde på nogle fejl, det problem, vi skal undgå, er, at disse fejl overrasker os, da hvis de gør det, kan vores applikation fungere uforudsigeligt.
Det er derfor, vi skal lære at håndtere fejl, på denne måde, hvis en uventet situation opstår, dør vores program ikke, men giver os besked om, at der er sket noget, med dette vil vi undgå datakorruption eller lignende situationer, der påvirker stabiliteten af ​​vores program.
Hvordan håndteres det?Vi opnår dette ved hjælp af blokke prøv - undtagen der giver os mulighed for at evaluere situationer, generelt der involverer data uden for vores kontrol, og med dette kan vi handle i scenarier i henhold til de svar, vi får. Hvis vi falder ind i afsnittet undtagen af blokken kan vi bruge fejlens egenskab i vores forekomst og med den udskrive, hvad der er sket og dermed vide, hvad fejlen var.
I det følgende program skal vi teste, hvad vi har defineret under forklaringen. Først og fremmest skal vi oprette en blok, der styrer os, hvis oprettelsen af ​​stikket har haft en fejl eller ej, med dette kan vi sikre en god start på vores kode.
Derefter vil vi evaluere forbindelsen af ​​vores applikation til en ekstern vært via en bestemt port, og med fejlhåndtering kan vi definere en brugerdefineret meddelelse. Endelig kalder vi til vores funktion, og med den udfører vi de beskrevne handlinger.
Lad os se følgende kode, som vi skal gemme i en fil kaldet errors_socket.py og så kører vi det i konsol:

 #! / usr / bin / env python import sys import socket host = 'http: //python.orgt' port = '06' def error_handling (): prøv: s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) undtagen socket.error, e: print "Der opstod en fejl under oprettelse af socket:% s"% e sys.exit (1) prøv: s.connect ((host, port)) undtagen socket.gaierror, e: print "Fejl i forbindelsesadresse:% s "% e sys.exit (1) undtagen socket.error, e: print" Forbindelsesfejl:% s "% e sys.exit (1) hvis __name__ == '__main__': error_handling () 

Her ser vi, at vi har brugt biblioteket sys for at bruge metoden Afslut () og luk programmet efter en fejl opstår. Vi bemærker også, at værten er forkert, dette er for at vi kan tvinge fejlen og dermed se beskeden på skærmen. Endelig bemærker vi, at vi bruger variablen e til at fange socket -fejlen, med dette kan vi få den virkelige detalje af, hvad der skete.
HuskHer skal vi være særlig forsigtige med indrykning af koden husk det Python Ved ikke at bruge seler afhænger semikolon også for at definere bloklukninger udelukkende af de mellemrum eller faner, vi bruger, så hvis vi ikke gør det korrekt, ser vi syntaksfejl.
Det er meget vigtigt, at vi læser dokumentationen til Python socket bibliotek så du kan finde flere og bedre måder at udnytte dine ressourcer på.
Med dette afslutter vi denne vejledning, vi har indset hvordan Python har meget letforståelige værktøjer, der giver os adgang til verden af stikkontakterMed dette kan vi begynde at programmere applikationer, der bruger netværk til at udføre behandling i realtid, såsom at indhente oplysninger fra andre maskiner på netværket eller endda fra Internettet.Kan du lide og hjælpe denne vejledning?Du kan belønne forfatteren ved at trykke på denne knap for at give ham et positivt punkt