Avec python socketserver comment puis-je passer une variable dans le constructeur de la classe de gestionnaire

Je voudrais passer ma connexion à la base de la EchoHandler classe, cependant je ne peux pas comprendre comment le faire ou accéder à la EchoHandler classe à tous.

 
classe EchoHandler(SocketServer.StreamRequestHandler): 
def poignée(self): 
imprimer soi-même.client_address, "connecté" 

si __name__ == '__principaux__': 
conn = MySQLdb.connect (host = "10.0.0.5", user = "utilisateur", passwd = "pass", db = "base de données") 

SocketServer.ForkingTCPServer.allow_reuse_address = 1 

serveur = SocketServer.ForkingTCPServer(('10.0.0.6', 4242), EchoHandler) 

print "Serveur écoute sur localhost:4242..." 
essayez: 
serveur.allow_reuse_address 
serveur.serve_forever() 
sauf KeyboardInterrupt: 
print "\nbailing..."
InformationsquelleAutor Jesse | 2011-07-29
  1. 25

    Malheureusement, il n'y a vraiment pas un moyen facile d'accéder aux gestionnaires directement à partir de l'extérieur du serveur.

    Vous avez deux options pour obtenir de l'information à la EchoHandler instances:

    1. Magasin de la connexion en tant que propriété de l'server (ajouter server.conn = conn avant d'appeler server_forever()) et ensuite accéder à la propriété dans EchoHandler.gestionnaire par self.server.conn.
    2. Vous pouvez remplacer le serveur de finish_request et attribuer la valeur on (vous auriez à passer au constructeur de EchoHandler et écraser EchoHandler.__init__). C'est un loin messier solution et c'est à peu près vous oblige à stocker la connexion sur le serveur de toute façon.

    Mon optionon de votre meilleur pari:

    class EchoHandler(SocketServer.StreamRequestHandler):
    def handle(self):
        # I have no idea why you would print this but this is an example
        print( self.server.conn );
        print self.client_address, 'connected'

if __name__ == '__main__':
    SocketServer.ForkingTCPServer.allow_reuse_address = 1

    server = SocketServer.ForkingTCPServer(('10.0.0.6', 4242), EchoHandler)
    server.conn = MySQLdb.connect (host = "10.0.0.5", 
                     user = "user", passwd = "pass", db = "database")
    # continue as normal
    • Qui fonctionne à merveille, Merci!
    InformationsquelleAutor cwallenpoole
  2. 9

    Marque T a ceci à dire sur le python archive de la liste de

    Dans la classe de gestionnaire, de soi.le serveur se réfère à l'objet serveur, de sorte que la sous-classe
    le serveur et le remplacer init à prendre en charge tous les paramètres de serveur
    et de les stocker dans des variables d'instance.

    
import SocketServer

class MyServer(SocketServer.ThreadingTCPServer):

    def __init__(self, server_address, RequestHandlerClass, arg1, arg2):
        SocketServer.ThreadingTCPServer.__init__(self, 
                                                 server_address, 
                                                 RequestHandlerClass)
        self.arg1 = arg1
        self.arg2 = arg2


class MyHandler(SocketServer.StreamRequestHandler):

    def handle(self):
        print self.server.arg1
        print self.server.arg2
    • Pourquoi ne pas faire super().__init__(...) au lieu de MyServer.__init__?
    • Les Classes dans le SocketServer modules sont "old-style" des classes. Le super constructeur doit être appelé de cette façon. Voir ici: stackoverflow.com/questions/11527921/...
    InformationsquelleAutor demented hedgehog
  3. 1

    Une autre façon, que je crois de plus pythonic, est de faire ce qui suit:

    class EchoHandler(SocketServer.StreamRequestHandler):
  def __init__(self, a, b):
    self.a = a
    self.b = b

  def __call__(self, request, client_address, server):
    h = EchoHandler(self.a, self.b)
    SocketServer.StreamRequestHandler.__init__(h, request, client_address, server)

    Vous pouvez maintenant donner un instance de votre gestionnaire de la TCPServer:

    SocketServer.ForkingTCPServer(('10.0.0.6', 4242), EchoHandler("aaa", "bbb"))

    La TCPServer normalement crée une nouvelle instance de EchoHandler par la demande, mais dans ce cas, le __appel__ méthode sera appelée à la place du constructeur (c'est déjà un exemple.)

    Dans le appel méthode, j'ai choisi de faire une copie de l'actuel EchoHandler et la passer au super constructeur pour se conformer à la logique initiale de "un gestionnaire d'instance par requête".

    Il vaut la peine d'avoir un coup d'oeil à la SocketServer module de comprendre ce qui se passe ici: https://github.com/python/cpython/blob/2.7/Lib/SocketServer.py

    InformationsquelleAutor aramaki
  4. 0

    J'étais en train de résoudre le même problème, mais j'ai utilisé légèrement différente de la solution, je pense que c'est un peu plus sympa et plus générale (inspiré par @aramaki).

    Dans le EchoHandler vous avez juste besoin de remplacer __init__ et d'indiquer les Creator méthode.

    class EchoHandler(SocketServer.StreamRequestHandler):
    def __init__(self, request, client_address, server, a, b):
        self.a = a
        self.b = b
        # super().__init__() must be called at the end
        # because it's immediately calling handle method
        super().__init__(request, client_address, server)

    @classmethod
    def Creator(cls, *args, **kwargs):
        def _HandlerCreator(request, client_address, server):
            cls(request, client_address, server, *args, **kwargs)
        return _HandlerCreator

    Alors vous pouvez simplement appeler la Creator méthode et passer quelque chose dont vous avez besoin.

    SocketServer.ForkingTCPServer(('10.0.0.6', 4242), EchoHandler.Creator(0, "foo"))

    Principal avantage est que de cette façon, vous ne créent pas plus d'instances que nécessaire et vous étendez la classe de façon plus facile à gérer - vous n'avez pas besoin de changer le Creator méthode plus jamais.

    InformationsquelleAutor Higgcz