IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Téléchargez Python Discussion :

ServBDD.py


Sujet :

Téléchargez Python

  1. #1
    Membre confirmé

    Homme Profil pro
    Autre
    Inscrit en
    janvier 2018
    Messages
    12
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Saône et Loire (Bourgogne)

    Informations professionnelles :
    Activité : Autre

    Informations forums :
    Inscription : janvier 2018
    Messages : 12
    Points : 628
    Points
    628
    Par défaut ServBDD.py
    Bonjour,

    Je vous propose un nouvel élément à utiliser : ServBDD.py

    Serveur TCP/IP avec base de donnée sqlite3

    Qu'en pensez-vous ?

  2. #2
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    décembre 2007
    Messages
    4 183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : décembre 2007
    Messages : 4 183
    Points : 8 684
    Points
    8 684
    Billets dans le blog
    6
    Par défaut
    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...e-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 - Visualiser dans une fenêtre à part
    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 - Visualiser dans une fenêtre à part
    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?
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo