Ordonnancement de traitements
Bonjour,
Je m'essaie à créer un ordonnanceur en Python permettant d'exécuter d'autres programmes python.
Le but est de pouvoir lancer un ensemble de traitements et de gérer les dépendances entre chaque.
Un exemple :
5 traitements : A, B, C, D et E
B doit attendre que A se termine correctement.
C doit attendre que A se termine correctement.
D doit attendre que B et C se terminent correctement.
E doit attendre que B et C se terminent correctement.
En théorie, je dois donc pouvoir tout exécuter en même temps et l'ordonnanceur doit se débrouiller avec les dépendances que je donne entre les traitements.
Bien sur, il doit pouvoir exécuter des traitements en parallèle.
Je ne sais pas exactement si cet outil a déjà été réalisé. J'ai vaguement recherché.. J'ai bien trouvé des choses pour remplacer la crontab mais, ce n'est pas vraiment ce que je cherche, et rien qui gérait les dépendances entre traitements. Si je me trompe, n'hésitez pas. ;)
Toujours est-il, qu'existant ou pas, l'exercice m'intéressait.
J'ai bien réalisé quelque chose mais au prix de quelques points négatifs, probablement dû aux limites de mes connaissances. Et je cherche à savoir s'il y a moyen d'améliorer le système.
Je commence donc mon traitement par là:
Code:
1
2
3
4
5
6
7
8
| listTrait = [1, 2, 3, 4, 5]
dictTrait = {1: 'Test_A.py', 2: 'Test_B.py', 3: 'Test_C.py', 4: 'Test_D.py', 5: 'Test_E.py'}
dictDep = {1: [], 2: [1], 3: [1], 4: [2, 3], 5: [2, 3]}
future = {}
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
for numTrait in listTrait: # Pour chaque traitement
future[numTrait] = executor.submit(fctExecTrait, dictTrait[numTrait], dictDep[numTrait], dictTrait, cr_fic) |
Ceci me permet donc de jouer sur 4 threads et donc d'exécuter jusqu'à 4 traitements en parallèle, préalablement initialisés dans la liste "listTrait".
Ces traitements sont donc lancés par l'intermédiaire de la fonction "fctExecTrait" avec en argument, entre autre, les dépendances dans le dictionnaire "dictDep" (contenant B attend A, C attend A ... ect..).
Commande utilisée dans la fonction "fctExecTrait" pour exécuter le script python du traitement :
Code:
codeRetour = subprocess.call((['{0}'.format(execPython), '{0}'.format(nomScript)])) # Exécution du traitement et récupération du code retour
Là où ça commence à pêcher, c'est dans la fonction "fctExecTrait", avant d'exécuter le traitement, pour déterminer si un prédecesseur a bien été exécuté ou n'est pas terminé.
Pour l'instant, je n'ai rien trouvé de mieux que de créer un fichier "flag" à la fin de chacun des traitements permettant de dire "OK moi traitement X, j'ai bien terminé".
Ainsi, chaque traitement va regarder dans le dictionnaire dictDep ce qu'il a besoin d'attendre, va vérifier si les fichiers flag correspondant sont présents. Si oui, alors il s'exécute sinon.... il ne s'exécute pas et va revérifier plus tard.
Et cette vérification de dépendances va se faire toutes les 5 sedondes à l'aide d'un boucle while et d'une temporisation de 5 secondes dans cette boucle.
Pour le moment, j'ai déterminé un nombre limite de vérifications des dépendances pour que le traitement dise ainsi "j'ai vérifié 20 fois les dépendances, toutes les 5 secondes, j'arrête car je pense que ça n'a pas du bien se terminer en amont".
Voilà. J'espère avoir été suffisamment clair.
Si vous avez des avis/pistes pour améliorer en fonction de ce que permet Python, je suis preneur. :)
