Comment puis-je module de patch de singe A du module B lorsque les fonctions de Module A sont censées être importables afin que je puisse exécuter les fonctions de module A avec le package de bibliothèque code> standard p>
Un client a demandé un correctif qui ne s'appliquera pas à aucun de nos autres clients, j'ai donc créé une nouvelle succursale et a écrit un module séparé pour que cela puisse faire la fusion dans les modifications de la branche principale facile. Pour maintenir la compatibilité en arrière du client avec le comportement de pré-hotfix, j'ai implémenté le correctif comme paramètre configurable de l'application. Ainsi, je ne voulais pas remplacer em> mon ancien code - juste le correctif lorsque le réglage a été allumé. Je l'ai fait par Le module Une fois qu'un Comment puis-je maintenir la modularité dans mon code (c'est-à-dire de garder le code de correctif dans un module séparé) et profitez toujours du package code> multiprocessing de Python's p>
* Remarque Mon code doit fonctionner sur Windows (pour mon client) et UNIX (pour ma santé mentale ...) p> Structure de code h2>
__ Main __ code> dans le fichier de configuration. Si la configuration tourne sur le commutateur du correctif,
__ MAIN __ CODE> PATCHES MON
MODULE MOTEUR CODE> En remplaçant quelques fonctions avec code défini dans le module code> hotfix code> En substance, la fonction étant remplacée est le fonction de la touche à une fonction de maximisation a >. Le module code> Moteur Code> Charge ultérieurement une piscine de
MultiProcessing code>
travailleurs. P>
Le problème h2>
multiprocessionnaire code> travailleur commence, la première chose
multiprocessionnaire code> est-ce que Ré-importateurs * Le module code> Moteur CODE> et recherche la fonction de clé que
__ principal __ code> avait essayé de remplacer (alors
multiprocession code> contrôle des mains à mon code et l'algorithme de maximisation commence). Puisque
moteur code> est en cours de ré-importé par un nouveau processus et le nouveau processus ne réexécute pas
__ principal __ code> (où le fichier de configuration est lu) car cela provoquerait une infinie Boucle, il ne sait pas au ré-singe-patch
moteur code>. p>
la question h2>
3 Réponses :
On dirait que vous allez devoir modifier Travailler sur UNIX et Windows moteur.py code> pour vérifier un fichier de configuration et avoir le correctif lui-même s'il est nécessaire. P>
Moteur Code> peut conserver une variable global
config_done code> pour décider si elle doit vérifier à nouveau pour le fichier de configuration. P>
Cela ressemble à un endroit où la correction de singe ne fonctionnera tout simplement pas. Il est plus facile de simplement extraire les fonctions en question à un modules distincts et d'importer du moteur à partir de là. Peut-être que vous pouvez avoir un paramètre de configuration de l'endroit où les importer de. P>
Une autre façon de modulariser ceci est d'utiliser une sorte d'architecture de composants, comme ZCA . Cette dernière option est ce que j'irais avec, mais c'est parce que je suis habitué à cela, donc il n'y a pas d'apprentissage supplémentaire pour moi. P>
Pour le faire fonctionner sur un système d'exploitation UNIX / Linux qui a Pour le faire fonctionner sous Windows, demandez à votre Ensuite, le code de lecture de lecture sera effectué chaque fois que Fourche () Code>, vous n'avez pas besoin de faire quelque chose de spécial car le nouveau processus a accès aux mêmes classes (patchées de singe). comme le parent. p>
__ Main __ code> Lire la configuration à l'importation (mettre le
read_config code> /
patch_engine code> appel à la portée globale ), mais faire le multitraitement (exécution du moteur) dans un
si __name__ == '__main __' code> garde. p>
__ principal __ code> est importé (à partir de la ligne de commande ou à partir d'un
multiprocessionnaire code> réimport), mais le
Si __name__ == '__Main __' code> Le code n'est effectué que lorsque votre script est appelé à partir de la ligne de commande (puisque
__ Main __ code> est réimporté sous un nom différent dans le processus d'enfant). P>
+1, question joliment formatée. Mais pas
multiprocessionnaire code> REIMPORT
__ Main __ code> dans les processus enfants?
@nneonneo, oui mais respirant
__ Main __. Main () Code> entraînerait une boucle infinie.
Bien-sûr. Mais vous ne pouvez pas avoir séparé
read_config code> et
principale () code> méthodes et appelez
read_config code> mais pas
principal () code> ?
Comment obtenir
__ principal __ code> pour déterminer s'il est chargé sous forme de
multiprocessionnaire code> travailleur ou de la ligne de commande?
Voir ma réponse. Je crois que cela devrait le faire pour vous.