[PYTHON] Pooling mechanisieren mit Django

Annahme

Erstellen Sie eine WEB-API mit Django (http://www.slideshare.net/satoshiyamada71697/django-54909370) Ich hatte eine gute Zeit.

Problem

Da es sich um eine WEB-API handelt, ist der Zugriff grundsätzlich zustandslos und jedes Mal, wenn eine Mechanisierungsinstanz erstellt und eine Operation ausgeführt wird. Aus Sicht des Intranets war es daher ** eine neue Anmeldung ** für jede Anforderung an die API. In naher Zukunft werde ich wütend auf das Informationssystem sein und mich verbessern wollen.

Bewältigung

Ich habe mich entschieden, zu bündeln, anstatt jedes Mal eine Instanz von mechanize zu erstellen.

Ursprünglicher Anrufer

worker = IntraWorker(USER,PASS)
worker.do_something()

IntraWoker ist eine Klasse, die mechanize verwendet. Ich melde mich jedes Mal mit __init__ an. Ich habe das unten gemacht.

Neuer Anrufer

# get from pool
worker = IntraWorkerPool().get(USER,PASS)
worker.do_something()
# back to pool
worker.close()

Fügen Sie eine Klasse namens IntraWorkerPool hinzu und lassen Sie sie den Pool verwalten.

IntraWorkerPool

from threading import Lock

class IntraWorkerPool(object):
    """
Mechanisieren Sie das Pooling-Management

    """
    #Arbeiter wird gepoolt
    # user,Verwenden Sie den Pass Taple als Schlüssel
    pooled_workers = {}

    def __init__(self):
        self.lock = Lock()
    def get(self, user, password):
        """
Entfernen Sie eine Worker-Instanz aus dem Pool
        """
        ret_aw = None
        pool = IntraWorkerPool.pooled_workers
        key = (hashed(user), password)
        with self.lock:
            if key in pool:
                #Machen Sie, wenn nicht verfügbar
                if len(pool[key]) == 0:
                    pool[key].append(IntraWorker(*key, pool_control=self))
            else:
                pool[key] = []
                pool[key].append(IntraWorker(*key, pool_control=self)
            
            #Überprüfen Sie, ob sich der Mitarbeiter noch anmelden kann
            while (ret_aw is None) or (not ret_aw.is_login()):
                ret_aw = pool[key].pop()

        return ret_aw

    def back_to_pool(self, aw_inst):
        """
Geben Sie die Instanz in den Pool zurück
Das nennt man eigentlich nicht direkt. Rufen Sie mit Close auf der Arbeiterseite an

        """
        key = (hashed(aw_inst.user_no), aw_inst.user_password)
        pool = IntraWorkerPool.pooled_workers
        with self.lock:
            pool.setdefault(key, [])
            pool[key].append(aw_inst)

Wir bereiten ein Wörterbuch mit dem Namen pooled_workers als Klassenvariable vor und verwalten den Taple für Benutzername und Kennwort sowie die Liste der Worker-Instanzen. Da Listenoperationen threadsicher sein sollten, werden sie auch mit threading.Lock () serialisiert. Um zum Pool zurückzukehren, haben wir eine Methode namens `` `back_to_pool``` vorbereitet, die ebenfalls durch Lock geschützt ist. In Wirklichkeit wird back_to_pool jedoch ausgeführt, wenn die Close-Methode auf der Worker-Instanzseite ausgeführt wird.

Um ehrlich zu sein, mag ich die Tatsache nicht, dass die Pool-Management-Klasse und die verwaltete Klasse voneinander abhängig sind, aber ich kann mir keine intelligente Implementierung vorstellen und der Tee ist auf diese Weise schlammig.

Ich würde es begrüßen, wenn mir jemand sagen könnte, ob es etwas Klügeres gibt.