[PYTHON] La mutualisation mécanise avec Django

supposition

Créez une API WEB avec Django appelée amélioration commerciale En interne, en utilisant en partie mécaniser pour convertir les connexions intra-login et intra-opération en API Je passais un bon moment.

problème

Puisqu'il s'agit d'une API WEB, l'accès est essentiellement sans état, et chaque fois qu'une instance de mécanisation est créée et qu'une opération intra-opération est effectuée. Par conséquent, du point de vue de l'intranet, il était à l'état de ** nouvelle connexion ** pour chaque requête à l'API. Dans un proche avenir, je serai en colère contre le système d'information et je souhaiterai m'améliorer.

Faire face

J'ai décidé de mettre en commun au lieu de créer une instance de mécanisation à chaque fois.

Appelant d'origine

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

IntraWoker est une classe qui utilise mécaniser. Je me connecte à chaque fois avec `` init ''. J'ai fait ceci ci-dessous.

Nouvel appelant

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

Ajoutez une classe appelée IntraWorkerPool et laissez-la gérer le pool.

IntraWorkerPool

from threading import Lock

class IntraWorkerPool(object):
    """
Mécaniser la gestion de la mutualisation

    """
    #Travailleur mis en commun
    # user,Utilisez le pass taple comme clé
    pooled_workers = {}

    def __init__(self):
        self.lock = Lock()
    def get(self, user, password):
        """
Supprimer une instance Worker du pool
        """
        ret_aw = None
        pool = IntraWorkerPool.pooled_workers
        key = (hashed(user), password)
        with self.lock:
            if key in pool:
                #Faire si non disponible
                if len(pool[key]) == 0:
                    pool[key].append(IntraWorker(*key, pool_control=self))
            else:
                pool[key] = []
                pool[key].append(IntraWorker(*key, pool_control=self)
            
            #Vérifiez si le travailleur est toujours en mesure de se connecter
            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):
        """
Renvoyer l'instance au pool
Vous n'appelez pas ça directement. Appel à proximité du côté travailleur

        """
        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)

Ce que nous faisons est de préparer un dictionnaire appelé pooled_workers en tant que variable de classe et de gérer le nom d'utilisateur et le mot de passe taple et la liste des instances Worker. En outre, les opérations de liste doivent être thread-safe, donc threading.Lock () est utilisé pour la sérialisation. Pour revenir au pool, nous avons préparé une méthode appelée back_to_pool```, qui est également protégée par Lock, mais en réalité, back_to_pool est exécutée lorsque la méthode Close du côté de l'instance Worker est exécutée.

Pour être honnête, je n'aime pas le fait que la classe de gestion de pool et la classe gérée soient interdépendantes, mais je ne peux pas penser à une implémentation intelligente et le thé est boueux de cette façon.

J'apprécierais que quelqu'un puisse me dire s'il y a quelque chose de plus intelligent.