ServBDD.py

Serveur TCP/IP avec base de donnée sqlite3

Signaler un problème

tyrtamos

Expert éminent

Le 12/08/2021 à 7:53

Bonjour,

Désolé, je viens de découvrir ce post qui m'avait échappé jusqu'à présent. J'ai une remarque et une question.

Remarque: pour le serveur TCP/IP (qui n'est pas ici un serveur "web"

, il n'est pas nécessaire d'utiliser un thread puisque c'est déjà prévu dans le module "socketserver" (https://docs.python.org/fr/3/library/socketserver.html#module-socketserver). Ainsi, chaque nouvelle requête ouvre un nouveau thread, ce qui permet à cette requête de ne pas avoir à attendre la fin de la requête précédente pour être traitée. On pourrait d'ailleurs tout aussi bien utiliser un processus à la place: c'est prévu.

J'avais essayé des trucs comme ça il y a... un certain temps (2008). C'était sous Python 2, et voilà la modernisation sous Python 3:

serveur.py:

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
# Serveur TCP utilisant StreamRequestHandler et ThreadingMixIn 
# du module socketserver
 
# import nécessaire pour le fonctionnement du serveur
import socketserver
 
# import seulement nécessaire pour l'exemple (=calcul d'expression par eval())
import sys
from math import *
 
##############################################################################
# initialisation des variables globales
adresse=('', 20000) # localhost, port=20000
 
##############################################################################
class Traitementrequete(socketserver.StreamRequestHandler):
 
    def handle(self):
 
        # lecture de la requête et suppression des caractères de fin de ligne
        requete = self.rfile.readline().rstrip()
 
        # préparation de la réponse
        requete = str(requete, sys.stdin.encoding) # conversion en str
        try:
            reponse = "{}".format(eval(requete))
        except Exception as msgerr:
            reponse = "{}".format(msgerr)
 
        # envoi de la réponse avec ajout des caractères de fin de ligne
        reponse = bytes(reponse, sys.stdout.encoding)
        self.wfile.write(reponse + b"\r\n")
 
        return
 
##############################################################################
class Serveurthread(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass
 
##############################################################################
if __name__ == '__main__':
 
    serveur = Serveurthread(adresse, Traitementrequete)
    print("serveur actif")
    serveur.serve_forever()
    # fermeture de connexion inutile: on arrête le serveur en "tuant" son processus
    #server.socket.close()

client.py:

Code :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
# client TCP fait pour communiquer avec un serveur TCP "StreamRequestHandler"
 
import sys
import socket
from random import randint
 
buf=1024
adresse=('', 20000)

##############################################################################
def clienttcp(requete, adresse=("localhost", 20000), buf=1024):
    
    # établissement de la connexion
    maSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        maSocket.connect(adresse)
    except Exception as msgerr:
        print("Echec de la connexion:", msgerr)
        return None
    
    # envoi de la requête au serveur
    requete = bytes(requete, sys.stdout.encoding)
    envoi = maSocket.send(requete + b"\r\n")
    
    # réception de la réponse
    reponse = maSocket.recv(buf).rstrip()
    
    # traitement de la réponse
    reponse = str(reponse, sys.stdout.encoding)
    
    # arrêter la connexion
    maSocket.close()    
    
    return reponse
    
##############################################################################
if __name__ == '__main__':
    
    for i in range(0,1000):
        
        requete =  str(randint(1000, 9999)) + "**55"
        
        reponse = clienttcp(requete)
        
        print(i, requete, reponse)

Question: à ma connaissance, sqlite3 ne fonctionne pas en serveur puisqu'il ne supporte pas le multitâche. Il faudrait donc que chaque requête ne soit prise en compte qu'après la fin de la requête précédente, ce qui est justement le contraire du fonctionnement par thread. Alors, qu'avez-vous fait pour que ça marche quand même?

Poster un commentaire

Developpez.com décline toute responsabilité quant à l'utilisation des différents éléments téléchargés.