RDF et gestion des connaissances

Partie 1 - Apprendre les bases d’un triplestore REST en Python

Julien Garderon

Cet article, qui est le premier d’une série en trois parties et aborde les bases d’un triplestore REST en Python, c’est-à-dire un serveur Web HTTP qui nous permettra d’avoir une base technique pour recevoir des commandes et les exécuter grossièrement.

Pour réagir au contenu de ce tutoriel, un espace de dialogue vous est proposé sur le forum. Commentez

- Titre : RDF et gestion des connaissances

- Auteur : Julien Garderon

- Parution : 9 avril 2019

- Licence : Copyright ® 2019 Julien Garderon. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Prérequis

- II. Préambule : triplestore, késako ?

- II-A. Exemple d’un raisonnement autour d’un triplet

- II-B. Un silo de données ?

- III. Un serveur Web minimum

- III-A. Un serveur pour les servir tous…

- III-B. Une classe puis des classes, puis…

- III-C. Et les routes d’abord ?

- III-D. Simplifions !

- III-E. Un verbe = une action

- IV. L’organisation de notre premier silo

- IV-A. La vraie nature du silo

- V. Note de la rédaction de Developpez.com

I - Prérequis

Pour la lecture aisée de cet article, vous devez avoir un certain nombre de connaissances préalables :

- l’écriture de scripts asynchrones en Python (notamment via Asyncio), dont le fonctionnement général est expliqué ici ;

- connaître le fonctionnement général d’un serveur Web et du protocole HTTP ;

- connaître le fonctionnement général de l’architecture REST.

À chaque fois que j’utiliserai le terme Python, c’est au moins la version 3.7 (et plus) qui est évoquée.

Cet article est le premier d’une série en trois parties :

1. Les bases d’un triplestore REST en Python, c’est-à-dire un serveur Web HTTP qui nous permettra d’avoir une base technique pour recevoir des commandes et les exécuter grossièrement ;

2. Le fonctionnement avancé et opérationnel d’un triplestore, avec le fonctionnement d’un silo de données et comment les deux peuvent s’articuler ;

3. L’intérêt de RDF et d’un triplestore dans la gestion des connaissances, particulièrement dans la veille personnelle, avec l’approche des linked open data.

II - Préambule : triplestore, késako ?

Chose étonnante : nous ne nous occuperons pas aujourd’hui de ce qu’est un triplestore ! Gardez à l’esprit qu’il s’agit d’une sorte d’entrepôt pour des « triplets » – un groupe de trois données fondamentales formant ensemble une entité et qui est l’équivalent de deux nœuds et d’un arc dans un graphe. Un assemblage de triplets permet d’organiser un schéma, un graphe des données et permettre, à plus haut niveau, des inférences, c’est-à-dire des déductions nouvelles à partir de l’existant (un peu sous la forme d’un syllogisme, avec possiblement des risques intrinsèques… « Socrate est un homme »).

Un triplet n’est pas une chose récente : c’est une unité, ou plus exactement un rassemblement, des données les plus petites possible dans la gestion des connaissances suivant la norme RDF – Resource Description Framework – qui date du début des années 2000, par l’inventeur du Web, Tim Berners-Lee, dans la perspective que beaucoup ont appelé le Web 3.0 : c’est-à-dire le web sémantique. Les triplets peuvent être utilisés partout, quel que soit le sujet ou le contexte.

Des deux nœuds et de l’arc que j’évoquais auparavant, il s’agit dans une forme plus régulière pour nous humain, d’une phrase qui serait appelée une «proposition» : un sujet, un prédicat (une forme de verbe, qui porte en réalité le sens avec les autres données) et un objet.

Un triplet est un rassemblement donc, qui peuvent être soit des URI, des URL, du texte conventionné (une écriture particulière)… et n’a d’intérêt que rassemblé avec ses congénères (leur rassemblement est une connaissance). Un langage de requête a été conçu pour interroger, quel que soit le triplestore (ou même l’interface) utilisé, d’une manière transparente pour celui qui conçoit la requête : il s’agit de SparQL.

Si vous souhaitez d’ores et déjà découvrir ces sujets, Wikipédia est bien pourvu : triplestore, RDF sont autant d’articles pour débuter.

II-A - Exemple d’un raisonnement autour d’un triplet

Si nous avons la phrase « Paul a un polo rouge », le triplet « grossier » qui y serait associé est : Sujet( Paul ) Prédicat( a ) Objet ( un polo rouge )… où « Paul » et « un polo rouge » sont des entités uniques et le prédicat « a », dans ce contexte, implique implicitement qu’il le porte aujourd’hui (ce qui serait une inférence) et à tout le moins qu’il en dispose (qu’il en ait ou pas la propriété).

Il y aurait encore beaucoup à dire, notamment sur la notation et les relations autour et pour ce triplet. Mais restons-en là pour cette partie.

II-B - Un silo de données ?

Le principe d’un silo ici, même si nous le verrons dans le troisième article, est un espace où sont stockés des données sans nécessairement d’organisation comme l’entend une base de données MySQL (avec des bases, des tables, etc.) : prenez l’exemple d’un silo à grain. Comme son homologue dans la vie physique, le silo que nous allons construire aura une taille maximum – élevée certes – qui ne pourra pas être dépassée. C’est-à-dire que lorsqu’un silo est rempli, il faudra déporter les futures données sur un autre.

III - Un serveur Web minimum

Pour notre triplestore, étant donné que nous utiliserons le format REST, cela implique de disposer d’un serveur Web qui puisse parfaitement se coupler avec le fonctionnement de notre silo.

III-A - Un serveur pour les servir tous…

Nous utiliserons en point de départ, le serveur « écho » (TCP) qui sert d’exemple à Python 3.7. Peu est à modifier, car la structure d’Asyncio est pensée naturellement pour être efficace :

1. import asyncio

3. async def handle_echo(reader, writer):

4. data = await reader.read(100)

5. message = data.decode()

6. addr = writer.get_extra_info('peername')

8. print(f"Received {message!r} from {addr!r}")

10. print(f"Send: {message!r}")

11. writer.write(data)

12. await writer.drain()

14. print("Close the connection")

15. writer.close()

17. async def main():

18. server = await asyncio.start_server(

19. handle_echo, '127.0.0.1', 8888)

21. addr = server.sockets[0].getsockname()

22. print(f'Serving on {addr}')

24. async with server:

25. await server.serve_forever()

27. asyncio.run(main())

Deux fonctions sont définies et utilisent la « loop » (boucle) principale, générée lors de la première tentative de récupération. Nous n’utiliserons que celle-ci durant cet article, et aucunement les threads.

La fonction « main » permet d’initier un service opérationnel qui écoute les connexions locales sur le port 8888 – je n’entre pas dans le détail, mais sachez si vous êtes novices (nous le sommes tous à des degrés divers…!) que des centaines de lignes et d’heures sont derrière ce simple « start_server »). Comme d’ailleurs pour les termes « async » et « await », qui seront utilisés.

Ce service transforme donc le poste en serveur sur ce port : un service à durée indéfinie, qui permet de gérer des clients (des connexions), jusqu’à la fin des temps (d’où l’appel à « serve_forever »). Chacune de ces connexions est gérée par une fonction, « handle_echo », qui prend en paramètre deux arguments : l’équivalent d’un fichier comme « lecteur » et l’équivalent d’un fichier comme « écrivain ». En somme, « reader » permet d’accéder à une ressource qui se comporte comme un fichier et qui dispose des données reçues du client par le serveur. La ressource « writer » est son inverse : elle permet d’écrire des données du serveur au client.

Prenez garde cependant : vous pouvez en quelque sorte « lire et écrire » en même temps. Il ne s’agit pas d’un dialogue où chacun attend l’autre et que ce dernier termine. Il s’agit de deux monologues qui, en outre, peuvent ne pas avoir de lien (sémantique). Ainsi vous pouvez très bien recevoir à n’importe quel moment des données – mais aussi en émettre sans attendre.

Gardons cela à l’esprit sans nous en soucier : nous verrons bientôt pourquoi cette liberté de deux monologues est (parfois) nécessaire et n’est pas problématique dans notre cas.

À ce code fondamental, rajoutons ceci :

1. import re

3. # pour mémoire, re.I indique lors de la compilation de l’expression régulière,

4. # de ne pas prendre en compte la casse

5. expReg_requete = re.compile(

6. "([a-z]+)\s+.*\s+HTTP\/1.[01]$",

7. re.I

8. )

10. expReg_entete = re.compile(

11. "([^\:]+)\s*\:\s*(.*)$",

12. re.I

13. )

Il s’agit deux variables globales, qui permettent de récupérer la ligne de commande (le verbe d’action, l’URL demandée, la version du protocole – seul le premier nous intéresse). Puis ce sont les lignes d’entêtes qui sont « canoniquement » définies.

Nb : nous utilisons match et non search du module re : l’expression de recherche est toujours sur le début de la chaîne analysée….

Dit autrement, ces deux variables se traduiraient humainement par les définitions suivantes :

- pour tout début de texte, cherche un bloc de texte composé d’au-moins un caractère, suivi ou non d’un espace, suivi d’un nombre indéfini de signes (caractères, espaces, ponctuations, etc.) et se terminant par « HTTP/1. » et soit 1, soit 1. Soit l’équivalent de :
GET /coucou HTTP/1.1

- pour tout début de texte, chercher un bloc de signes composé de tous les caractères sauf les sauts de lignes et du caractère « : », suivi ou non d’un non d’un espace, suivi de « : », suivi par le reste de la chaîne quel qu’en soit le contenu. Soit l’équivalent de :
Content-length : 125

Ajoutons une première fonction de réponse, très simple, pour les tests :

1. async def reponse(ecrivain, code, message):

2. ecrivain.write( ( "HTTP/1.0 %s %s" % ( code, message ) ).encode( "utf-8" ) )

3. await ecrivain.drain()

4. ecrivain.close()

5. raise Exception("connexion à clore")

Modifions enfin la fonction « handle_echo » pour répondre aux premières requêtes (sans récupération du corps pour l’instant) :

1. async def handle_echo(reader, writer):

2. methode = None

3. entetes = {}

4. while True:

5. ligne = await reader.readline()

6. ligne = ligne.decode("utf-8").strip()

7. if ligne=="":

8. break

9. if methode is None:

10. r = expReg_requete.match( ligne )

11. if r is None:

12. return await reponse( writer, 400, "bad request" )

13. else:

14. methode = r.group( 0 )

15. else:

16. r = expReg_entete.match( ligne )

17. if r is None:

18. return await reponse( writer, 400, "bad request" )

19. else:

20. _, cle, valeur = r.groups()

21. entetes[cle] = valeur

22. print(methode, entetes)

23. await reponse( writer, 200, "OK" )

25. print("Close the connection")

26. writer.close()

Nous connaissons le début du corps (et la fin de l’entête HTTP), grâce à la syntaxe qui prévoit deux sauts de ligne consécutifs (soit l’équivalent d’une ligne vierge). Il suffit donc de détecter qu’une ligne est considérée comme vierge de tout signe pour faire un arrêt de la boucle :

while True:
(…)
if ligne=="":
break

Tester ce code avec votre navigateur : l’ouverture de l’URL 127.0.0.1:8888 renverra systématiquement un code « HTTP 200 OK » sans corps.

Si par contre vous tester une connexion avec Putty en mode « raw » par exemple, le non-respect de la syntaxe HTTP vous renverra systématiquement un code d’erreur 400 « bad request ».

Voilà, notre serveur peut communiquer avec l’extérieur en utilisant un minimum de langage. Le plus dur est presque prêt !

III-B - Une classe puis des classes, puis…

Le problème survient avec le temps : si l’on reste sur des fonctions qui s’appellent, il faut constamment envoyé le simili-fichier « lecteur », celui « écrivain », la commande déjà traitée et que sais-je d’autres… Pas pratique. Les objets sont donc hautement nécessaires, pour ne pas dire indépassables.

Il nous faut créer une classe. Pas d’inquiétude pour Asyncio : les mots-clés « await » et « async » se marient très bien avec la définition de méthodes de classe.

Tout d’abord, réagençons notre code avec une classe « Client » qui « dialogue » lors d’une connexion au service :

1. import asyncio

2. import re

4. class ClientHTTP:

6. expReg_requete = re.compile(

7. "([a-z]+)\s+.*\s+HTTP\/1.[01]$",

8. re.I

9. )

10. expReg_entete = re.compile(

11. "([^\:]+)\s*\:\s*(.*)$",

12. re.I

13. )

15. def __init__(self, lecteur, ecrivain):

16. self.lecteur, self.ecrivain = lecteur, ecrivain

17. self.methode = None

18. self.entetes = {}

20. async def dialoguer(self):

21. while True:

22. ligne = await self.lecteur.readline()

23. ligne = ligne.decode("utf-8").strip()

24. if ligne=="":

25. break

26. if self.methode is None:

27. r = self.expReg_requete.match( ligne )

28. if r is None:

29. return ( await self.reponse( 400, "bad request" ) )

30. else:

31. self.methode = r.group( 0 )

32. else:

33. r = self.expReg_entete.match( ligne )

34. if r is None:

35. return ( await self.reponse( 400, "bad request" ) )

36. else:

37. cle, valeur = r.groups()

38. self.entetes[cle.lower()] = valeur

39. print(self.methode, self.entetes)

40. await self.reponse( 200, "OK" )

41. print("Close the connection")

43. async def reponse(self, code, message):

44. self.ecrivain.write( ( "HTTP/1.0 %s %s" % ( code, message ) ).encode( "utf-8" ) )

45. await self.ecrivain.drain()

47. async def handle_echo(reader, writer):

48. c = ClientHTTP(

49. reader,

50. writer

51. )

52. await c.dialoguer()

53. writer.close()

55. async def main():

56. server = await asyncio.start_server(

57. handle_echo, '127.0.0.1', 8888)

59. addr = server.sockets[0].getsockname()

60. print(f'Serving on {addr}')

62. async with server:

63. await server.serve_forever()

65. asyncio.run(main())

Ce code est « équivalent » à celui au-dessus, mais il est plus clair et surtout plus facile à étendre. Notamment si vous avez besoin de l’héritage.

Détachons désormais le client, du dialogue HTTP. C’est-à-dire qu’un client pourrait traiter indifféremment du HTTP ou tout autre protocole – dès le démarrage du serveur, il suffirait d’indiquer quel « format » est utilisé. Pour cela, nous renommons la classe « ClientHTTP » en « Client », nous créons la classe « CommandeHTTP » et nous y intégrons ce qui tient lieu du dialogue HTTP à proprement parler (ici, récupérer les informations de la syntaxe précisément, et y répondre).

Nous n’oublions pas d’ajouter en paramètre de la création d’une instance du client, de donner la bonne classe du format de commande à utiliser. Voici ce que cela donne, sachant que ce code est toujours identique aux deux exemples précédents :

1. import asyncio

2. import re

4. class CommandeHTTP:

6. expReg_requete = re.compile(

7. "([a-z]+)\s+.*\s+HTTP\/1.[01]$",

8. re.I

9. )

10. expReg_entete = re.compile(

11. "([^\:]+)\s*\:\s*(.*)$",

12. re.I

13. )

15. def __init__(self, client):

16. self.client = client

17. self.methode = None

18. self.entetes = {}

20. def traiterLigne(self, ligne):

21. if self.methode is None:

22. r = self.expReg_requete.match( ligne )

23. if r is None:

24. return False

25. else:

26. self.methode = r.group( 0 )

27. else:

28. r = self.expReg_entete.match( ligne )

29. if r is None:

30. return False

31. else:

32. cle, valeur = r.groups()

33. self.entetes[cle.lower()] = valeur

34. return True

36. async def repondre(self, code, message):

37. self.client.ecrivain.write( ( "HTTP/1.0 %s %s" % ( code, message ) ).encode( "utf-8" ) )

38. await self.client.ecrivain.drain()

40. class Client:

42. def __init__(self, lecteur, ecrivain, formatDialogue):

43. self.lecteur, self.ecrivain = lecteur, ecrivain

44. self.formatDialogue = formatDialogue

46. async def recupereLigne(self):

47. return (

48. await self.lecteur.readline()

49. ).decode("utf-8").strip()

51. async def dialoguer(self):

52. commande = self.formatDialogue( self )

53. while True:

54. ligne = await self.recupereLigne()

55. if ligne=="":

56. break

57. if commande.traiterLigne( ligne ) is False:

58. return ( await commande.repondre( 400, "bad request" ) )

59. print(commande.methode, commande.entetes)

60. await commande.repondre( 200, "OK" )

61. print("Close the connection")

63. async def handle_echo(reader, writer):

64. c = Client(

65. reader,

66. writer,

67. CommandeHTTP

68. )

69. await c.dialoguer()

70. writer.close()

72. async def main():

73. server = await asyncio.start_server(

74. handle_echo, '127.0.0.1', 8888)

76. addr = server.sockets[0].getsockname()

77. print(f'Serving on {addr}')

79. async with server:

80. await server.serve_forever()

82. asyncio.run(main())

Vous devriez avoir avec votre navigateur, en testant l’URL localhost sur le port 8888, un retour similaire dans la console de votre serveur :

Serving on ('127.0.0.1', 8888)
GET / HTTP/1.1 {'host': '127.0.0.1:8888', 'connection': 'keep-alive', 'cache-control': 'max-age=0', 'upgrade-insecure-requests': '1', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36', 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'accept-encoding': 'gzip, deflate, br', 'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8'}
Close the connection
GET /favicon.ico HTTP/1.1 {'host': '127.0.0.1:8888', 'connection': 'keep-alive', 'pragma': 'no-cache', 'cache-control': 'no-cache', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36', 'accept': 'image/webp,image/apng,image/*,*/*;q=0.8', 'referer': 'http://127.0.0.1:8888/', 'accept-encoding': 'gzip, deflate, br', 'accept-language': 'fr-FR,fr;q=0.9,en;q=0.8'}
Close the connection

Notez que mon navigateur a envoyé deux requêtes – et non une seule comme j’aurai pu l’imaginer – car il tente de récupérer un « favicon », c’est-à-dire l’équivalent du logo du site. Ce comportement est classique pour la visite d’un nouveau site par la plupart des navigateurs modernes. Ne soyez donc pas étonné, ce n’est pas une « erreur » du serveur de détecter deux requêtes !

III-C - Et les routes d’abord ?

Jusqu’à présent, nous ne nous occupions pas des routes indiquées par le client connecté : pas de besoin. Or ce serait super d’avoir une page de présentation de notre serveur (ou de paramétrage, ou que sais-je…).

Nul besoin de quelque chose de compliqué pour l’instant : juste renvoyé du HTML.

Commençons par récupérer le chemin en modifiant notre expression régulière compilée de la ligne de commande HTTP :

1. expReg_requete = re.compile(

2. "([a-z]+)\s+(.*)\s+HTTP\/1.[01]$", # j’ai rajouté les parenthèses : le groupe devient « capturant » !

3. re.I

4. )

Modifions ensuite la fonction initialisation de notre classe CommandeHTTP :

1. def __init__(self, client):

2. self.client = client

3. self.methode = None

4. self.chemin = None

5. self.entetes = {}

Et enfin, dans cette classe, pour la fonction « traiterLigne », remplacer la ligne :

self.methode = r.group( 0 )

…par,

self.methode, self.chemin = r.groups()

Le tour est joué ! Votre chemin est récupéré. Modifions la fonction « dialoguer » pour prendre en compte que certains chemins sont en quelque sorte des « exceptions », qui seront gérés par la classe CommandeHTTP :

1. async def dialoguer(self):

2. commande = self.formatDialogue( self )

3. while True:

4. ligne = await self.recupereLigne()

5. if ligne=="":

6. break

7. if commande.traiterLigne( ligne ) is False:

8. return ( await commande.repondre( 400, "bad request" ) )

9. if ( await commande.traiterChemin() ) is False:

10. #print(commande.methode, commande.chemin, commande.entetes)

11. await commande.repondre( 200, "OK" )

12. print("Close the connection")

Dans CommandeHTTP, ajoutons d’abord les ressources sous la forme d’expressions régulières compilées, qui renvoient vers un chemin local (ici, que des fichiers statiques). Ajoutons également deux fonctions : la première va parcourir à chaque requête, les ressources ainsi définies et si l’expression est valide, on renvoie le fichier associé. Évidemment, on en profite pour gérer un fichier qui n’existerait pas localement, et renvoyer une erreur 404…

1. async def traiterChemin(self):

2. for rExpReg in self.ressources:

3. r = rExpReg.match( self.chemin )

4. if r is not None:

5. await self.repondreFichier( self.ressources[rExpReg], r )

6. return True

7. return False

9. async def repondreFichier(self, chemin, resultat):

10. if os.path.isfile( chemin ): # pensez à ajouter « import os »

11. with open( chemin, "r" ) as f:

12. r = f.read().encode( "utf-8" )

13. await self.repondre( 200, "correct ressource" )

14. # les quelques lignes ci-dessous peuvent poser problème :

15. # nous verrons plus tard pourquoi

16. self.client.ecrivain.write(

17. ( "Content-length: %s\n" % len( r ) ).encode( "utf-8" )

18. )

19. self.client.ecrivain.write(

20. "\n".encode( "utf-8" )

21. )

22. self.client.ecrivain.write(

23. r

24. )

25. await self.client.ecrivain.drain()

26. return True

27. return ( await self.repondre( 404, "bad ressource" ) )

28. return True

Enfin nous modifions la fonction « repondre » pour y ajouter le caractère « \n » en fin de ligne… sinon votre première ligne de réponse sera confondue avec la seconde…

1. async def repondre(self, code, message):

2. self.client.ecrivain.write( ( "HTTP/1.0 %s %s\n" % ( code, message ) ).encode( "utf-8" ) )

3. await self.client.ecrivain.drain()

Si vous testez désormais votre code, vous aurez le comportement suivant :

- http://127.0.0.1:8888/ ou http://127.0.0.1:8888 : code 200 + rien => cas 1 ;

- http://127.0.0.1:8888/page : code 200 + ressource => cas 2 ;
http://127.0.0.1:8888/coucou (ou toute autre URL avec seulement des caractères alphabétiques !) : code 200 + ressource => cas 2 ;

- http://127.0.0.1:8888/coucou/bonjour (ou toute autre URL !) : code 200 + rien => cas 1.

Soyons restrictifs : modifions l’expression régulière des ressources pour limiter la ressource « page.html » seulement à l’URL « /page » :

1. ressources = {

2. re.compile(

3. "\/page\/?$"

4. ) : "./page.html"

5. }

Si vous testez désormais votre code, vous aurez le comportement suivant :

- http://127.0.0.1:8888/ ou http://127.0.0.1:8888 : code 200 + rien => cas 1 ;

- http://127.0.0.1:8888/page : code 200 + ressource => cas 2 ;
http://127.0.0.1:8888/coucou (ou toute autre URL avec seulement des caractères alphabétiques !) : code 200 + rien => cas 1 ;

- http://127.0.0.1:8888/coucou/bonjour (ou toute autre URL !) : code 200 + rien => cas 1.

Vous l’aurez compris, un retour avec un code HTTP 200 est donc particulièrement relatif à un contexte. Un code HTTP d’ailleurs, n’est jamais qu’une indication sur la situation de la requête et n’est absolument pas une « réalité ».

Ainsi pour des raisons de sécurité, un serveur peut être configuré pour retourner un code 404 (ressource inconnue) au lieu et place d’un code 403 (accès refusé à cette ressource).

III-D - Simplifions !

Tout cela est sympathique, mais n’offre guère de possibilité de réutilisation. Ce serait vite un bazar inouï si nous n’y prenions pas garde. Ce qui est intéressant avec le protocole HTTP et qui motive son usage le plus large, c’est sa grande simplicité et robustesse dans les réponses. Finalement, les requêtes sont aussi faciles à concevoir qu’à analyser :

1. async def repondre(self, codeHTTP=200, messageHTTP="OK", entetes={}, corps=None):

2. reponse = [

3. "HTTP/1.0 %s %s" % ( codeHTTP, messageHTTP )

4. ]

5. for cle in entetes:

6. reponse.append(

7. "%s: %s" % ( cle, entetes[cle] )

8. )

9. if corps is not None:

10. reponse.append(

11. "content-length: %s" % len( corps )

12. )

13. reponse.append( "" )

14. reponse.append( corps )

15. print(reponse)

16. self.client.ecrivain.write(

17. ( "\n".join( reponse ) ).encode( "utf-8" )

18. )

19. await self.client.ecrivain.drain()

Nous gérons plus aisément les différents types de réponses possibles, avec ou sans corps. Rien d’exceptionnel certes, mais c’est ce que nous avons besoin - ni plus ni moins.

Modifiez le reste de votre conséquence ; vous devriez alors avoir quelque chose qui ressemble à ceci :

1. import asyncio

2. import re

3. import os

5. class CommandeHTTP:

7. ressources = {

8. re.compile(

9. "\/page\/?$"

10. ) : "./page.html"

11. }

13. expReg_requete = re.compile(

14. "([a-z]+)\s+(.*)\s+HTTP\/1.[01]$",

15. re.I

16. )

17. expReg_entete = re.compile(

18. "([^\:]+)\s*\:\s*(.*)$",

19. re.I

20. )

22. def __init__(self, client):

23. self.client = client

24. self.methode = None

25. self.chemin = None

26. self.entetes = {}

28. def traiterLigne(self, ligne):

29. if self.methode is None:

30. r = self.expReg_requete.match( ligne )

31. if r is None:

32. return False

33. else:

34. self.methode, self.chemin = r.groups()

35. else:

36. r = self.expReg_entete.match( ligne )

37. if r is None:

38. return False

39. else:

40. cle, valeur = r.groups()

41. self.entetes[cle.lower()] = valeur

42. return True

44. async def traiterChemin(self):

45. for rExpReg in self.ressources:

46. r = rExpReg.match( self.chemin )

47. if r is not None:

48. await self.repondreFichier( self.ressources[rExpReg], r )

49. return True

50. return False

52. async def repondreFichier(self, chemin, resultat):

53. if os.path.isfile( chemin ):

54. with open( chemin, "r" ) as f:

55. await self.repondre(

56. corps = f.read()

57. )

58. return True

59. return ( await self.repondre( codeHTTP = 404, messageHTTP = "bad ressource" ) )

60. return True

62. async def repondre(self, codeHTTP=200, messageHTTP="OK", entetes={}, corps=None):

63. reponse = [

64. "HTTP/1.0 %s %s" % ( codeHTTP, messageHTTP )

65. ]

66. for cle in entetes:

67. reponse.append(

68. "%s: %s" % ( cle, entetes[cle] )

69. )

70. if corps is not None:

71. reponse.append(

72. "content-length: %s" % len( corps )

73. )

74. reponse.append( "" )

75. reponse.append( corps )

76. print(reponse)

77. self.client.ecrivain.write(

78. ( "\n".join( reponse ) ).encode( "utf-8" )

79. )

80. await self.client.ecrivain.drain()

82. class Client:

84. def __init__(self, lecteur, ecrivain, formatDialogue):

85. self.lecteur, self.ecrivain = lecteur, ecrivain

86. self.formatDialogue = formatDialogue

88. async def recupereLigne(self):

89. return (

90. await self.lecteur.readline()

91. ).decode("utf-8").strip()

93. async def dialoguer(self):

94. commande = self.formatDialogue( self )

95. while True:

96. ligne = await self.recupereLigne()

97. if ligne=="":

98. break

99. if commande.traiterLigne( ligne ) is False:

100. return ( await commande.repondre( codeHTTP = 400, messageHTTP = "bad request" ) )

101. if ( await commande.traiterChemin() ) is False:

102. #print(commande.methode, commande.chemin, commande.entetes)

103. await commande.repondre()

104. print("Close the connection")

106. async def handle_echo(reader, writer):

107. c = Client(

108. reader,

109. writer,

110. CommandeHTTP

111. )

112. await c.dialoguer()

113. writer.close()

115. async def main():

116. server = await asyncio.start_server(

117. handle_echo, '127.0.0.1', 8888)

119. addr = server.sockets[0].getsockname()

120. print(f'Serving on {addr}')

122. async with server:

123. await server.serve_forever()

125. asyncio.run(main())

Notez dans la fonction « dialoguer » de la classe « Client », que la réponse à proprement parler, est un appel tout simple et sans argument à la fonction « repondre » de la classe « Commande » :

await commande.repondre()

Bref : c’est efficace et bien organisé, mais ça ne sert rigoureusement à rien, car le renvoi sera toujours un code HTTP 200.

III-E - Un verbe = une action

Le protocole HTTP prévoit des « verbes » d’action. Pour une architecture REST (representational state transfer), ce verbe est en quelque sorte soit un « contexte » général, soit tout à fait l’action à proprement parler. Tout dépend de l’API (application programming interface) souhaitée :

- soit les verbes indiquent une action, exemples : GET = obtenir et POST = créer ;

- soit les verbes indiquent un contexte, exemples : GET = une requête (lecture seule) et POST = une transaction (écriture probable).

Notre classe « CommandeHTTP » a pour devoir de gérer ces situations – qui heureusement sont peu nombreuses : GET, POST, PUT, DELETE, HEAD, CONNECT, OPTIONS, TRACE, PATCH. Les deux premiers sont les plus connus, mais chacun recouvre en réalité un besoin et l’on confond parfois les verbes entre eux : GET et HEAD ; POST et PUT…

Python n’offre pas d’éléments de langage de type « switch/case » pour gérer de nombreuses situations. Dès lors, soit l’on utilise une série de « if/else », soit une combinaison d’expressions régulières testées les unes après les autres (comme pour les routes plus haut). Soit, comme c’est notre cas, nous avons aussi le moyen de tester l’existence ou non d’une méthode…

Dans « CommandeHTTP », ajoutons cette fonction :

1. async def executer(self):

2. if hasattr( self, "cmd_%s" % self.methode ):

3. await getattr( self, "cmd_%s" % self.methode)()

4. else:

5. return ( await self.repondre( codeHTTP = 400, messageHTTP = "bad request" ) )

Son intérêt est de savoir si une méthode de l’instance existe à partir d’un nom composé à la volée. Ainsi vous pouvez gérer facilement (et étendre tout aussi facilement) vos verbes HTTP. Une telle méthode serait par exemple :

async def cmd_get(self):
await self.repondre( corps = "youpi tralala" )

…toutes les requêtes GET (pas celles POST, PUT, etc.) renverront le même message.

Remplaçons dans la fonction « dialoguer » de « Client », la fonction de réponse par la fonction d’exécution :

await commande.executer()

Et testez : rien ne marche… ! Une erreur 400 apparaît systématiquement !

En effet, peut-être avez-vous remarqué tout au début, pour le traitement des entêtes des requêtes, que je passais à une petite casse des clés :

self.entetes[cle.lower()] = valeur

Ainsi « Content-length », « CONTENT-length » ou « ConTenT-LengHT » aboutiront toutes à la chaîne « content-length » - facile à retrouver. Il faut faire de même avec la méthode, dans la même fonction « traiterLigne » de « CommandeHTTP » :

self.methode = self.methode.lower()

Relancez et ouf, « youpi tralala » devrait s’afficher… Notre serveur est prêt.

1. import asyncio

2. import re

3. import os

5. class CommandeHTTP:

7. ressources = {

8. re.compile(

9. "\/page\/?$"

10. ) : "./page.html"

11. }

13. expReg_requete = re.compile(

14. "([a-z]+)\s+(.*)\s+HTTP\/1.[01]$",

15. re.I

16. )

17. expReg_entete = re.compile(

18. "([^\:]+)\s*\:\s*(.*)$",

19. re.I

20. )

22. def __init__(self, client):

23. self.client = client

24. self.methode = None

25. self.chemin = None

26. self.entetes = {}

28. def traiterLigne(self, ligne):

29. if self.methode is None:

30. r = self.expReg_requete.match( ligne )

31. if r is None:

32. return False

33. else:

34. self.methode, self.chemin = r.groups()

35. self.methode = self.methode.lower()

36. else:

37. r = self.expReg_entete.match( ligne )

38. if r is None:

39. return False

40. else:

41. cle, valeur = r.groups()

42. self.entetes[cle.lower()] = valeur

43. return True

45. async def traiterChemin(self):

46. for rExpReg in self.ressources:

47. r = rExpReg.match( self.chemin )

48. if r is not None:

49. await self.repondreFichier( self.ressources[rExpReg], r )

50. return True

51. return False

53. async def repondreFichier(self, chemin, resultat):

54. if os.path.isfile( chemin ):

55. with open( chemin, "r" ) as f:

56. await self.repondre(

57. corps = f.read()

58. )

59. return True

60. return ( await self.repondre( codeHTTP = 404, messageHTTP = "bad ressource" ) )

61. return True

63. async def repondre(self, codeHTTP=200, messageHTTP="OK", entetes={}, corps=None):

64. reponse = [

65. "HTTP/1.0 %s %s" % ( codeHTTP, messageHTTP )

66. ]

67. for cle in entetes:

68. reponse.append(

69. "%s: %s" % ( cle, entetes[cle] )

70. )

71. if corps is not None:

72. reponse.append(

73. "content-length: %s" % len( corps )

74. )

75. reponse.append( "" )

76. reponse.append( corps )

77. #print(reponse)

78. self.client.ecrivain.write(

79. ( "\n".join( reponse ) ).encode( "utf-8" )

80. )

81. await self.client.ecrivain.drain()

83. async def executer(self):

84. if hasattr( self, "cmd_%s" % self.methode ):

85. await getattr( self, "cmd_%s" % self.methode)()

86. else:

87. await self.repondre( codeHTTP = 400, messageHTTP = "bad request" )

89. async def cmd_get(self):

90. await self.repondre( corps = "youpi tralala" )

92. class Client:

94. def __init__(self, lecteur, ecrivain, formatDialogue):

95. self.lecteur, self.ecrivain = lecteur, ecrivain

96. self.formatDialogue = formatDialogue

98. async def recupereLigne(self):

99. return (

100. await self.lecteur.readline()

101. ).decode("utf-8").strip()

103. async def dialoguer(self):

104. commande = self.formatDialogue( self )

105. while True:

106. ligne = await self.recupereLigne()

107. if ligne=="":

108. break

109. if commande.traiterLigne( ligne ) is False:

110. return ( await commande.repondre( codeHTTP = 400, messageHTTP = "bad request" ) )

111. if ( await commande.traiterChemin() ) is False:

112. #print(commande.methode, commande.chemin, commande.entetes)

113. await commande.executer()

114. print("Close the connection")

116. async def handle_echo(reader, writer):

117. c = Client(

118. reader,

119. writer,

120. CommandeHTTP

121. )

122. await c.dialoguer()

123. writer.close()

125. # le reste du code sera désormais ici (et suivant) sauf mention contraire

127. async def main():

128. server = await asyncio.start_server(

129. handle_echo, '127.0.0.1', 8888)

131. addr = server.sockets[0].getsockname()

132. print(f'Serving on {addr}')

134. async with server:

135. await server.serve_forever()

137. asyncio.run(main())

IV - L’organisation de notre premier silo

Notre silo, comme je l’expliquais plus haut, utilisera pour fonctionner la même boucle que le serveur : c’est-à-dire que les tâches du serveur gérées par Python grâce aux coroutines, sont confondues avec celles du silo. Cela est permis, car la fonction « main » organise dès le départ la création des tâches nécessaires et du lancement des serveurs.

Notre appel à cette boucle est désormais ceci :

1. # n’oubliez pas qu’au-dessus, il y a le code vu précédemment

2. ObjSilo = None

4. async def main(_silos):

5. global ObjSilo

6. server = await asyncio.start_server(

7. handle_echo, '127.0.0.1', 8888)

9. addr = server.sockets[0].getsockname()

10. print(f'Serving on {addr}')

12. ObjSilo = _silos()

14. async with server:

15. await server.serve_forever()

17. class Silo:

19. def __init__(self):

20. self.commandes = []

21. self.tache = asyncio.create_task( self.executer() )

23. async def executerCommande(self, commande):

24. print("attendre 3 secondes pour ", commande)

25. await asyncio.sleep( 3 )

26. commande.enAttente = False

28. async def executer(self):

29. while True:

30. _commandes = []

31. for c in self.commandes:

32. _commandes.append( c )

33. self.commandes.remove( c )

34. for c in _commandes:

35. print("traitement de", c)

36. await self.executerCommande( c )

37. print("silo executer")

38. await asyncio.sleep(1)

40. if __name__=="__main__":

41. try:

42. m = main(

43. Silo

44. )

45. asyncio.run( m )

46. except KeyboardInterrupt:

47. pass

Testez votre script : vous verrez qu’au-delà des requêtes gérées par le serveur, vous aurez chaque seconde un message « silo executer », qui se répétera indéfiniment.

Nous modifions également notre client, en ajoutant une fonction d’attente et « cmd_get » :

1. async def attendre(self):

2. self.enAttente = True

3. while self.enAttente:

4. print("un client attend", self)

5. await asyncio.sleep( 1 )

7. async def cmd_get(self):

8. global ObjSilo

9. ObjSilo.commandes.append(

10. self

11. )

12. await self.attendre()

13. await self.repondre( corps = "youpi tralala" )

Vous devriez voir un retour de console similaire à ceci, en gardant à l’esprit qu’il y a deux requêtes envoyées par le navigateur :

1. Serving on ('127.0.0.1', 8888)

2. silo executer

3. silo executer

4. silo executer

5. un client attend <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

6. traitement de <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

7. attendre 3 secondes pour  <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

8. un client attend <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

9. un client attend <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

10. un client attend <__main__.CommandeHTTP object at 0x000002666B8F1EB8>

11. silo executer

12. Close the connection <__main__.Client object at 0x000002666B8F1C18>

13. un client attend <__main__.CommandeHTTP object at 0x000002666B8F5B38>

14. traitement de <__main__.CommandeHTTP object at 0x000002666B8F5B38>

15. attendre 3 secondes pour  <__main__.CommandeHTTP object at 0x000002666B8F5B38>

16. un client attend <__main__.CommandeHTTP object at 0x000002666B8F5B38>

17. un client attend <__main__.CommandeHTTP object at 0x000002666B8F5B38>

18. un client attend <__main__.CommandeHTTP object at 0x000002666B8F5B38>

19. silo executer

20. Close the connection <__main__.Client object at 0x000002666B8F5B00>

21. silo executer

22. silo executer

23. silo executer

24. ...

Alors comment fonctionne un tel code ? La fonction « cmd_get » gère toujours dans notre cas les requêtes du navigateur, sauf que nous ajoutons à notre variable globale « ObjSilo », la commande du client à une liste de toutes les commandes de tous les clients, puis nous mettons la présente commande dans un mode d’attente.

Lorsque cette attente est terminée, la réponse est envoyée : ici la réponse est toujours envoyée après au moins 3 secondes.

Le plus intéressant est ailleurs : « ObjSilo » est une variable globale donc, qui contient un objet instancié de la classe « Silo ». C’est celle-ci qui définit le comportement du silo, ses modalités d’actions, et qui récupère et gère les commandes acquises.

En somme, le déroulé de notre script est le suivant, qui nous permet d’identifier précisément le rôle de chacun :

- un serveur asynchrone est lancé au travers d’une fonction « main », qui crée elle-même une instance d’un silo ;

- ce serveur ne gère que les connexions TCP/IP, et pour chaque nouvelle connexion, crée un client qui va être l’outil pour récupérer le contenu des connexions et permettre de répondre ;

- chaque client, pour les requêtes qu’il reçoit, va créer une instance de commande, qui est l’outil de compréhension (récupération ≠ compréhension ; permettant au client d’être agnostique sur le protocole) :

- chaque silo gère individuellement les commandes, en « verrouillant » le fichier lorsque c’est nécessaire, et libère en quelque sorte la commande et donc le client. Cette libération déclenche l’envoi d’une réponse.

Il est important que des fonctions d’attente soient utilisées – et pas seulement pour l’exemple. En effet, si vous ne les utilisez pas, la commande envoie une réponse trop tôt – le client pourrait donc recevoir une réponse erronée (voire pas de réponse), sans que le silo ait eu le temps de gérer la commande.

Si nous commentons la ligne suivante :

await self.attendre()

…notez que désormais l’envoi de la réponse est immédiat. C’est-à-dire que le silo, lorsqu’il récupère la commande, celle-ci est déjà considérée comme exécutée, car la réponse est envoyée… Cette erreur logique peut être difficile à appréhender et à détecter, mais elle est essentielle à ne pas être commise.

De la même façon, la fonction « executer » de la classe « Silo » récupère, à un instant précis, les commandes qui existent ; et traitent seulement celles-ci jusqu’au passage suivant : nous verrons bientôt pourquoi.

IV-A - La vraie nature du silo

Notre silo est – avant toute autre chose – un fichier et surtout un pointeur dans un fichier (en réalité deux dans notre cas). Ce fichier doit rester cohérent : il faut donc que chaque opération d’écriture soit parfaitement gérée et surtout exclusivement à un moment donné.

Comme je l’indiquais plus haut, il y a donc :

- des commandes « en lecture seule » - des requêtes ;

- des commandes « en écriture » - des transactions.

Les requêtes peuvent être multiples à un moment donné, car elles n’entraînent pas d’effets sur le contenu de fichier, elles sont donc « plus rapides » dans l’absolu (c’est relatif…) qu’une transaction. Par contre les transactions sont traitées individuellement, de bout en bout, afin de ne pas avoir d’incohérences ou d’écrasement lors de l’écriture, et cela a une incidence sur les performances.

En réalité, c’est un peu plus compliqué : si vous avez 1000 lecteurs par exemple, vous aurez donc 1000 clients qui seront traités de manière concurrentielle – ralentissant d’autant la performance « pure » si la requête était la seule et encore plus si des opérations de comparaison sont à faire… L’asynchrone a une efficacité relative et propre à chaque situation (+ article sur le sujet).

Nous mettrons donc un nombre maximum de lecteurs simultanés afin de conserver un équilibre (10 dans notre exemple).

Mais continuons : créez dans le même dossier, un fichier « silo.test » (un simple fichier texte, encodé en UTF-8), avec une liste de chiffres (un par ligne). Quelque chose de similaire à ceci :

| 1

| 2

| 3

| 4

| 5

| 6

| 7

| 8

| 9

La consigne sera de renvoyer seulement les valeurs qui sont paires (c’est-à-dire que le modulo de 2 retourne 0). Deux boucles sont nécessaires : la première permet de garder la fonction « executer » de « Silo » active, celle-ci comparant si des requêtes sont en attente. La seconde permet de parcourir le fichier, renvoyant une portion du fichier individuellement aux requêtes sélectionnées pour être traitées.

Cette portion dans notre cas, sera simplement de faire le modulo et d’ajouter, si le nombre est pair, à une nouvelle variable « reponse » de la classe « Commande ». Ce qui sera renvoyé au client sera d’ailleurs la concaténation de ces valeurs.

Voici le code complet, avec les modifications. Prenez le temps nécessaire à sa découverte et vous familiariser avec :

1. import asyncio

2. import re

3. import os

5. class CommandeHTTP:

7. ressources = {

8. re.compile(

9. "\/page\/?$"

10. ) : "./page.html"

11. }

13. expReg_requete = re.compile(

14. "([a-z]+)\s+(.*)\s+HTTP\/1.[01]$",

15. re.I

16. )

17. expReg_entete = re.compile(

18. "([^\:]+)\s*\:\s*(.*)$",

19. re.I

20. )

22. def __init__(self, client):

23. self.client = client

24. self.methode = None

25. self.chemin = None

26. self.entetes = {}

27. self.reponse = []

29. def traiterLigne(self, ligne):

30. if self.methode is None:

31. r = self.expReg_requete.match( ligne )

32. if r is None:

33. return False

34. else:

35. self.methode, self.chemin = r.groups()

36. self.methode = self.methode.lower()

37. else:

38. r = self.expReg_entete.match( ligne )

39. if r is None:

40. return False

41. else:

42. cle, valeur = r.groups()

43. self.entetes[cle.lower()] = valeur

44. return True

46. async def traiterChemin(self):

47. for rExpReg in self.ressources:

48. r = rExpReg.match( self.chemin )

49. if r is not None:

50. await self.repondreFichier( self.ressources[rExpReg], r )

51. return True

52. return False

54. async def repondreFichier(self, chemin, resultat):

55. if os.path.isfile( chemin ):

56. with open( chemin, "r" ) as f:

57. await self.repondre(

58. corps = f.read()

59. )

60. return True

61. return ( await self.repondre( codeHTTP = 404, messageHTTP = "bad ressource" ) )

62. return True

64. async def repondre(self, codeHTTP=200, messageHTTP="OK", entetes={}, corps=None):

65. reponse = [

66. "HTTP/1.0 %s %s" % ( codeHTTP, messageHTTP )

67. ]

68. for cle in entetes:

69. reponse.append(

70. "%s: %s" % ( cle, entetes[cle] )

71. )

72. if corps is not None:

73. reponse.append(

74. "content-length: %s" % len( corps )

75. )

76. reponse.append( "" )

77. reponse.append( corps )

78. #print(reponse)

79. self.client.ecrivain.write(

80. ( "\n".join( reponse ) ).encode( "utf-8" )

81. )

82. await self.client.ecrivain.drain()

84. async def executer(self):

85. if hasattr( self, "cmd_%s" % self.methode ):

86. await getattr( self, "cmd_%s" % self.methode)()

87. else:

88. await self.repondre( codeHTTP = 400, messageHTTP = "bad request" )

90. async def attendre(self):

91. self.enAttente = True

92. while self.enAttente:

93. print("un client attend", self)

94. await asyncio.sleep( 1 )

96. async def cmd_get(self):

97. global ObjSilo

98. ObjSilo.requetes.append(

99. self

100. )

101. await self.attendre()

102. await self.repondre( corps = "\n".join( self.reponse ) )

104. class Client:

106. def __init__(self, lecteur, ecrivain, formatDialogue):

107. self.lecteur, self.ecrivain = lecteur, ecrivain

108. self.formatDialogue = formatDialogue

110. async def recupereLigne(self):

111. return (

112. await self.lecteur.readline()

113. ).decode("utf-8").strip()

115. async def dialoguer(self):

116. commande = self.formatDialogue( self )

117. while True:

118. ligne = await self.recupereLigne()

119. if ligne=="":

120. break

121. if commande.traiterLigne( ligne ) is False:

122. return ( await commande.repondre( codeHTTP = 400, messageHTTP = "bad request" ) )

123. if ( await commande.traiterChemin() ) is False:

124. #print(commande.methode, commande.chemin, commande.entetes)

125. await commande.executer()

126. print("Close the connection", self)

128. async def handle_echo(reader, writer):

129. c = Client(

130. reader,

131. writer,

132. CommandeHTTP

133. )

134. await c.dialoguer()

135. writer.close()

137. ####################################################

139. ObjSilo = None

141. async def main(_silos):

142. global ObjSilo

143. server = await asyncio.start_server(

144. handle_echo, '127.0.0.1', 8888)

145. addr = server.sockets[0].getsockname()

146. print(f'Serving on {addr}')

147. ObjSilo = _silos()

148. async with server:

149. await server.serve_forever()

151. class Silo:

153. nbreMaxRequetesSimultanee = 10

155. def __init__(self):

156. self.requetes = []

157. self.transactions = []

158. self.fSilo = open( "./silo.test", "r" )

159. self.tache = asyncio.create_task( self.executer() )

161. async def executerRequete(self, commande, portion):

162. if portion%2==0:

163. commande.reponse.append(

164. str( portion )

165. )

167. def recupererRequetes(self):

168. # cette opération doit rester bloquante

169. # il s'agit de récupérer les requêtes

170. # (commandes en lecture) à un instant t

171. _requetes = []

172. for requete in self.requetes:

173. _requetes.append( requete )

174. self.requetes.remove( requete )

175. if len( _requetes ) >= self.nbreMaxRequetesSimultanee:

176. break

177. return _requetes

179. async def recupererPortion(self):

180. return self.fSilo.readline()

182. async def executer(self):

183. while True:

184. try:

185. if len( self.requetes ) == 0:

186. print("Silo : pas encore de client à exécuter")

187. await asyncio.sleep( 0.5 )

188. else:

189. self.fSilo.seek( 0 ) # début du fichier

190. requetes = self.recupererRequetes()

191. print("Silo : requêtes en cours de réalisation", requetes)

192. while True:

193. p = ( await self.recupererPortion() )

194. if p=="":

195. break # la fin du fichier détectée

196. else:

197. p = int( p )

198. for requete in requetes:

199. await self.executerRequete( requete, p )

200. for requete in requetes:

201. requete.enAttente = False

202. except Exception as err:

203. print(err)

205. if __name__=="__main__":

206. try:

207. m = main(

208. Silo

209. )

210. asyncio.run( m )

211. except KeyboardInterrupt:

212. pass

Le retour de la console devrait être similaire à ceci :

1. Serving on ('127.0.0.1', 8888)

2. Silo : pas encore de client à exécuter

3. Silo : pas encore de client à exécuter

4. un client attend <__main__.CommandeHTTP object at 0x0000018A00AFB550>

5. Silo : requêtes en cours de réalisation [<__main__.CommandeHTTP object at 0x0000018A00AFB550>]

6. Silo : pas encore de client à exécuter

7. Silo : pas encore de client à exécuter

8. Close the connection <__main__.Client object at 0x0000018A00AFB518>

9. un client attend <__main__.CommandeHTTP object at 0x0000018A00AFB908>

10. Silo : requêtes en cours de réalisation [<__main__.CommandeHTTP object at 0x0000018A00AFB908>]

11. Silo : pas encore de client à exécuter

12. Silo : pas encore de client à exécuter

13. Close the connection <__main__.Client object at 0x0000018A00AFB8D0>

14. Silo : pas encore de client à exécuter

15. Silo : pas encore de client à exécuter

16. Silo : pas encore de client à exécuter

17. …

Et pour ce qui est des transactions, c’est-à-dire d’une opération en écriture, me direz-vous ? Facile : une fois qu’une sélection de requêtes a été traitée, nous pouvons traiter les opérations en écriture.

Dans la fonction d’initialisation du silo, modifiez le mode d’ouverture du fichier de silo de « r » (read, lecture seule) en « r+ » (read et write, possibilité d’écriture, avec le curseur en début de fichier par défaut).

self.fSilo = open( "./silo.test", "r+" )

Nous allons nous servir du try / except que j’ai écrit dans la fonction « executer » du silo, pour être certain qu’après les requêtes, nous ayons toujours des transactions en attente :

1. async def executer(self):

2. while True:

3. try:

4. if len( self.requetes ) == 0:

5. print("Silo : pas encore de client à exécuter")

6. await asyncio.sleep( 2 ) # on attend un peu…

7. else:

8. self.fSilo.seek( 0 ) # début du fichier

9. requetes = self.recupererRequetes()

10. print("Silo : requêtes en cours de réalisation", requetes)

11. while True:

12. p = ( await self.recupererPortion() )

13. if p=="":

14. break # la fin du fichier détectée

15. else:

16. p = int( p )

17. for requete in requetes:

18. await self.executerRequete( requete, p )

19. for requete in requetes:

20. requete.enAttente = False

21. except Exception as err:

22. print("erreur :", err)

23. finally:

24. # on simule des transactions en attente

25. self.fSilo.seek( 0, 2 ) # fin du fichier

26. for i in range(0, 10):

27. self.fSilo.write( "%i\n" % i )

28. self.fSilo.flush()

Ainsi à chaque paquet de requêtes traité, ou toutes les deux secondes s’il n’y a pas de requêtes à traiter, nous ajoutons des valeurs à notre fichier, dont voici un retour de console possible :

1. Serving on ('127.0.0.1', 8888)

2. Silo : pas encore de client à exécuter

3. un client attend <__main__.CommandeHTTP object at 0x0000018603E2B588>

4. Silo : écriture de nouvelles valeurs

5. Silo : requêtes en cours de réalisation [<__main__.CommandeHTTP object at 0x0000018603E2B588>]

6. Silo : écriture de nouvelles valeurs

7. Silo : pas encore de client à exécuter

8. Close the connection <__main__.Client object at 0x0000018603E2B550>

9. un client attend <__main__.CommandeHTTP object at 0x0000018603E7AF98>

10. un client attend <__main__.CommandeHTTP object at 0x0000018603E7AF98>

11. Silo : écriture de nouvelles valeurs

12. Silo : requêtes en cours de réalisation [<__main__.CommandeHTTP object at 0x0000018603E7AF98>]

13. Silo : écriture de nouvelles valeurs

14. Silo : pas encore de client à exécuter

15. Close the connection <__main__.Client object at 0x0000018603E7AF60>

16. Silo : écriture de nouvelles valeurs

17. Silo : pas encore de client à exécuter

18. Silo : écriture de nouvelles valeurs

19. Silo : pas encore de client à exécuter

20. Silo : écriture de nouvelles valeurs

21. Silo : pas encore de client à exécuter

22. …

V - Note de la rédaction de Developpez.com

Nous tenons à remercier f-leb pour la relecture orthographique de ce tutoriel.