Manipulation de socket avec Python

Les prises Ils sont l'interface qui nous permet de communiquer deux ou plusieurs ordinateurs via un réseau. Grâce à cela, nous pouvons créer différents types d'applications qui nous aident à transmettre des données sur Internet et ainsi voir des résultats que nous n'aurions pas autrement en temps réel.
L'un des moyens les plus courants d'implémenter des sockets est le protocole TCPCela aide à ce qu'avec le support du système d'exploitation, la transmission via Internet soit normale et sans problème.
Puisque nous connaissons un peu le concept de base de ce que sont les sockets, nous allons commencer par manipuler leurs caractéristiques, l'une d'entre elles est le temps d'attente.
Temps d'attenteLe temps d'attente Cela nous permet d'établir le temps pendant lequel le socket peut être attentif pour recevoir ou envoyer des données, ceci est très important car s'il y a un blocage de l'application pendant ce temps d'attente nous pouvons subir le risque de ralentir tout un système . C'est pourquoi nous avons besoin de savoir quel est le temps d'attente prédéterminé et aussi de pouvoir en établir un nous-mêmes à notre convenance.
Pour y parvenir, nous pouvons utiliser quelques méthodes qui existent à cet effet dans la bibliothèque standard prise de Python.
gettimeout ()La première méthode est gettimeout () et comme son nom l'indique, il nous propose le temps d'attente initial de la socket que nous passons en paramètre.
délai d'attente ()La deuxième méthode est délai d'attente () et sa fonctionnalité est d'établir un timeout pour le socket en question exprimé en millisecondes.
Nous allons maintenant créer un petit programme qui nous permet de mettre en action ce que nous avons appris, pour cela nous allons d'abord créer un objet de type socket qui nous servira de sujet de test, pour cela nous passerons la famille et le type de socket au constructeur et avec cela nous pouvons appliquer les méthodes.
Afin de voir les changements une fois que nous aurons créé notre socket nous afficherons son temps d'attente qui doit être nul car il s'agit d'un nouvel objet, puis avec la méthode délai d'attente () Nous établirons un nouveau temps d'attente et enfin nous imprimerons les informations, confirmant ainsi que tout a fonctionné comme il se doit.
Pour réaliser tout cela, nous devons nous assurer que nous avons Python installé dans notre système, dans sa version 2.7, et avoir un éditeur de texte pour pouvoir créer les fichiers avec les programmes, bien que nous puissions également faire l'exercice sur la console, cependant c'est un peu plus inconfortable et ce n'est pas persistant, ce qui signifie que nous perdrions notre travail. Regardons le code source de cet exemple :

 #! / usr / bin / env python import socket def timeout_socket (): s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) print "Le délai d'attente initial est : % s"% s.gettimeout () s. settimeout (100 ) print "Le nouveau délai d'attente est : % s" % s.gettimeout () if __name__ == '__main__' : time_out_socket () 

Nous allons enregistrer cela dans un nouveau fichier appelé socketTimeWait.py et nous l'exécuterons dans la console, le résultat devrait ressembler à ce qui suit :

Le amortir C'est une autre des choses que nous devons prendre en compte lorsque nous travaillons avec des sockets, car ce composant est celui qui indiquera la quantité de données que nous pouvons transmettre pour le moment, à plus de tampon Plus la quantité de données est importante, mais cela signifie également plus de consommation de ressources et un temps d'attente plus long dans la transmission de celles-ci. Sinon un tampon inférieur Il représente plus de vitesse bien qu'il limite la quantité de données à transférer, c'est pourquoi c'est une compétence que nous devons maîtriser.
setsockopt ()Pour nous aider à manipuler le tampon de la bibliothèque prise de Python nous propose la méthode setsockopt(), que nous devons appliquer à une instance de la classe socket. Si nous voulons changer la taille du tampon, nous devons sûrement d'abord connaître la taille d'origine du tampon de socket, pour cela nous avons aussi la méthode getockopt () et il est utilisé à peu près de la même manière que la méthode que nous avons décrite ci-dessus.
Nous allons créer un petit programme pour démontrer ce que nous avons expliqué précédemment, dans le code que nous allons voir, nous allons d'abord créer une paire de constantes que nous utiliserons dans notre programme et seront définis pour 4096 qui est une valeur pour la taille des buffers que nous allons établir.
Puis on fait une instance de la classe socket, pour demander immédiatement les tailles initiales du buffer, puis on les affiche à l'écran.
Enfin, nous utiliserons la méthode setsockopt () Pour fixer la taille souhaitée du buffer à l'aide des constantes définies au début du programme, cette méthode reçoit trois paramètres, le niveau, le nom et enfin la valeur du buffer.
Voyons le code qui nous aide à spécifier ce que nous avons expliqué, nous allons l'enregistrer dans un fichier appelé size_buffer.py:

 #! / usr / bin / env python import socket TAM_BUFFER_SEND = 4096 TAM_BUFFER_RECEPCION = 4096 def manipuler_buffer (): sock = socket.socket (socket.AF_INET, socket.SOCK_STREAM) # Récupère la taille du tampon d'envoi du socket sizeBufferopt = socket.getso (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Taille du tampon [Avant]:% d"% Taille du tampon sock.setsockopt (socket.SOL_TCP, socket.TCP_NODELAY, 1) sock.setsockopt (socket.SOL_SOCKET, socket.SO_SNDBUFFER setsockopt (socket.SOL_SOCKET, socket.SO_RCVBUF, SIZE_BUFFER_RECEPCION) buffersize = sock.getsockopt (socket.SOL_SOCKET, socket.SO_SNDBUF) print "Taille du tampon [Après]:% d"% manipuler_buffer_size = '___buffer_size_buffer =' =' __ () 

Une fois que nous aurons écrit notre programme, nous procéderons à son exécution dans la console et nous verrons que nous obtenons les valeurs du tampon avant et après avoir modifié sa taille.

Comme avec tous les types de programmes, lorsque nous travaillons avec des sockets, nous ne sommes pas exempts de rencontrer des erreurs, le problème que nous devons éviter est que ces erreurs nous prennent par surprise, car si elles le font, notre application peut fonctionner de manière imprévisible.
C'est pourquoi nous devons apprendre à gérer les erreurs, de cette manière si une situation inattendue se produit, notre programme ne meurt pas mais nous avertit que quelque chose s'est passé, avec cela nous éviterons la corruption de données ou des situations similaires qui affectent la stabilité de notre programme.
Comment le gérer ?Nous y parvenons en utilisant des blocs essayer - sauf qui nous permettent d'évaluer des situations, généralement qui impliquent des données indépendantes de notre volonté et avec cela, nous pouvons agir dans des scénarios en fonction des réponses que nous obtenons. Si nous tombons dans la section à l'exception du bloc, nous pouvons utiliser la propriété error de notre instance et avec elle imprimer ce qui s'est passé et ainsi savoir quel était l'échec.
Dans le programme suivant, nous allons tester ce que nous avons défini lors de l'explication. Tout d'abord nous allons créer un bloc qui nous contrôle si la création du socket a eu une erreur ou non, avec cela nous pouvons assurer un bon démarrage de notre code.
Ensuite, nous allons évaluer la connexion de notre application à un hôte distant via un port particulier et avec la gestion des erreurs, nous pouvons définir un message personnalisé. Enfin, nous appelons notre fonction et avec elle, nous exécuterons les actions décrites.
Voyons le code suivant que nous devons stocker dans un fichier appelé erreurs_socket.py puis nous l'exécuterons dans la 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) except socket.error, e: print "Il y a eu une erreur lors de la création du socket:% s"% e sys.exit (1) try: s.connect ((host, port)) except socket.gaierror, e: print "Error dans l'adresse de connexion :% s "% e sys.exit (1) except socket.error, e: print" Erreur de connexion :% s "% e sys.exit (1) if __name__ == '__main__': error_handling () 

Ici, nous voyons que nous avons utilisé la bibliothèque système pour utiliser la méthode sortir () et fermez le programme après une erreur. On note aussi que l'hébergeur est incorrect c'est pour qu'on puisse forcer l'erreur et ainsi voir le message à l'écran. Enfin, nous notons que nous utilisons la variable e pour capturer l'erreur de socket, avec cela nous pouvons obtenir le vrai détail de ce qui s'est passé.
rappelerIci, nous devons être particulièrement prudents avec la échancrure du code rappelez-vous que Python En n'utilisant pas d'accolades, les points-virgules pour définir également les fermetures de blocs dépendent exclusivement des espaces ou des tabulations que nous utilisons, donc si nous ne le faisons pas correctement, nous verrons des erreurs de syntaxe.
Il est très important que nous lisions la documentation du bibliothèque de sockets Python afin que vous puissiez trouver des façons plus nombreuses et meilleures de tirer parti de vos ressources.
Avec cela, nous terminons ce tutoriel, nous avons réalisé comment Python dispose d'outils très simples à comprendre qui nous donnent accès au monde de prisesAvec cela, nous pouvons commencer à programmer des applications qui utilisent des réseaux pour effectuer des traitements en temps réel, tels que l'obtention d'informations à partir d'autres machines sur le réseau ou même à partir d'Internet.Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif