Mit python socketserver wie kann ich das übergeben einer variable an den Konstruktor der handler-Klasse,

Ich möchte mein Datenbank-Verbindung zur EchoHandler Klasse, aber ich kann nicht herausfinden, wie zu tun, dass der oder Zugriff auf die EchoHandler Klasse überhaupt.

 
Klasse EchoHandler(SocketServer.StreamRequestHandler): 
def handle(self): 
print self.client_address, 'connected' 

wenn __name__ == '__main__': 
conn = MySQLdb.connect (host = "10.0.0.5", user = "user", passwd = "pass", db = "Datenbank") 

SocketServer.ForkingTCPServer.allow_reuse_address = 1 

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

print "Server lauscht auf localhost:4242..." 
versuchen: 
server.allow_reuse_address 
server.serve_forever() 
except KeyboardInterrupt: 
print "\nbailing..."
InformationsquelleAutor Jesse | 2011-07-29
  1. 25

    Leider, es ist wirklich nicht eine einfache Möglichkeit, access-Handler, die direkt von außerhalb der server.

    Haben Sie zwei Optionen, um die Informationen zu den EchoHandler Instanzen:

    1. Speichern Sie die Verbindung als eine Eigenschaft der server (add server.conn = conn vor dem Aufruf server_forever()) und dann Zugriff auf das Eigentum in EchoHandler.handler durch self.server.conn.
    2. Können Sie überschreiben die server finish_request und weisen Sie den Wert dort (Sie hätte, um es zu übergeben an den Konstruktor von EchoHandler und überschreiben EchoHandler.__init__). Das ist ein weit messier Lösung und es ist ziemlich viel verlangt, Sie um die Verbindung zu speichern auf dem server sowieso.

    Meine optionon Ihre beste Wette:

    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
    • Das funktioniert wunderbar, Danke!
    InformationsquelleAutor cwallenpoole
  2. 9

    Mark T hat dazu Folgendes zu sagen, auf der python-list-Archiv

    In der handler-Klasse, selbst.server bezieht sich auf das server-Objekt, Unterklasse so
    die server und überschreiben init, um zusätzliche server-Parameter
    und speichern Sie Sie als Instanz-Variablen.

    
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
    • Warum nicht super().__init__(...) statt in MyServer.__init__?
    • Klassen in der SocketServer-Module sind "old-style" - Klassen. Der super-Konstruktor aufgerufen werden, auf diese Weise. Siehe hier: stackoverflow.com/questions/11527921/...
    InformationsquelleAutor demented hedgehog
  3. 1

    Andere Art und Weise, dass ich glaube, mehr pythonic, ist Folgendes zu tun:

    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)

    Können Sie jetzt geben Sie eine Instanz von Ihrem handler an den tcpserver gestartet:

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

    Den tcpserver gestartet, normalerweise erzeugt eine neue Instanz von EchoHandler pro Anfrage, aber in diesem Fall, die __call__ Methode aufgerufen wird, anstatt den Konstruktor (es ist schon eine Instanz.)

    In der nennen Methode, die ich explizit eine Kopie der aktuellen EchoHandler und übergeben es an den super-Konstruktor entspricht der ursprünglichen Logik der "one-handler-Instanz pro request".

    Ist es Wert, einen Blick auf die SocketServer Moduls zu verstehen, was hier passiert: https://github.com/python/cpython/blob/2.7/Lib/SocketServer.py

    InformationsquelleAutor aramaki
  4. 0

    Ich war derzeit der Lösung des gleichen Problems, aber ich verwendet etwas andere Lösung, ich finde es ist etwas schöner und mehr allgemein (inspiriert von @aramaki).

    In der EchoHandler brauchen Sie nur zu überschreiben __init__ und geben Sie einen benutzerdefinierten Creator Methode.

    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

    Dann können Sie einfach anrufen, die Creator - Methode, und übergeben Sie alles, was Sie brauchen.

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

    Hauptvorteil ist, dass auf diese Weise Sie sind nicht erstellen mehr Instanzen als nötig, und erweitern Sie die Klasse in überschaubare Weise - Sie brauchen nicht zu ändern, die Creator Methode immer wieder.

    InformationsquelleAutor Higgcz
Schreibe einen Kommentar