Est-il possible de créer/appeler plusieurs instances de AnsibleModule à l'intérieur d'un module?

Question

Notre structure logique de serveur est basée sur le concept de "cluster" et "instance". Un cluster est un ensemble d'instances de Weblogic et/ou de Karaf et/ou d'Apache et/ou de Nginx et/ou de Jboss. Les instances "MAI OU PEUT-ÊTRE" peuvent être réparties sur plusieurs hôtes.

Un groupe classique serait: hôtes: a, b instances sur: tst13-apache, tst13-weblogic-ECOM, tst13-weblogic-remplir instances sur b: tst13-karaf repos bus, tst13 -karf-rest-svcs, tst13-nginx-cache

J'ai créé un module de super-classe (myMod) et 5 sous-classes (myApache, myNginx, myJboss, myKaraf, myWeblogic). Les informations "instance" (variables d'inventaire) sont conservées dans une base de données ldap. Les instances ne sont pas "enregistrées" dans les répertoires rc.d sur les hôtes. Chaque serveur a des "scripts génériques" pour démarrer une instance apache et une instance weblogic et une instance JBoss et ... par "nom d'instance" donc appeler des modules Ansible tels que "httpd" n'était pas pratique. Mon module sera utilisé pour "stop, start, status, kill, etc" (actions) sur une liste d'instances. Idéalement, je voudrais créer une connexion SSH à l'hôte de destination pour CHAQUE instance de logiciel à actionner sur l'hôte de destination (ce qui, je crois, signifierait une instance d'un module par instance de serveur ...). logiciel qui nécessite une action); cependant, jusqu'à présent, il semble que l'on puisse faire 1 connexion ssh par destination "hôte". Comme un «hôte» peut exécuter plusieurs instances de différents types de logiciels (2 instances apache, 4 instances weblogic et 3 instances karaf peuvent toutes être sur 1 hôte); il semblait pratique de créer mon « myMod » comme suit:

##### 
## <ANSIBLE_HOME>/modules/controller.py  
##### 
    import socket 
    from ansible.module_utils.ldapData import ldapData 
    from ansible.module_utils.myMod import myMod 
    from ansible.module_utils.myModules import myApache, myNginx, myWeblogic, myKaraf, myJboss 

    def main(): 

     arg_spec = dict(
       action = dict(default='status', choices=['start', 'stop', 'kill', 'status', 'warm', 'startsession', 'stopsession']), 
       instances = dict(default='@', required=False, type='str'), 
      ) 

     host = socket.gethostname() 

     serverdata = ldapData() 
     cluster = serverdata.hosts[host]["cluster"] 
     clusterData = serverdata.clusters[cluster] 
     hostData = serverdata.hosts[host] 

     classList = list(myMod.__subclasses__()) 

     for classType in classList: 
      localMod = classType(arg_spec, hostData, clusterData) 
      localMod.process() 

    if __name__ == '__main__': 
     main() 

La méthode de processus myMod ressemble à ceci:

##### 
## <ANSIBLE_HOME>/module_utils/myMod.py 
##### 
    def process(self): 
     fPointers = { 
       'start': self.start, 
       'stop': self.stop, 
       'kill': self.kill, 
       'status': self.status, 
       'stopsession': self.stopsession, 
       'startsesson': self.startsession, 
       'warm': self.warm 
     } 
     act = self.params['action'] 
     for inst in self.instances: 
       if fPointers[act]: 
         fPointers[act](inst) 
       else: 
         undefined(inst) 
     self.exit_json(changed=self.changed, msg=self.out, warnings=self.warn, errors=self.err) 

Actuellement, je ne suis en revenir le « out » et « warn » et "err" du premier module qui appelle "process". Les autres modules ne sont pas exécutés ou ne sont pas signalés. Je m'attends à ce que exit_json soit "en train de quitter la totalité de Ansible" et pas seulement "le module en cours".

Ai-je raison? Y a-t-il un concept en jeu dont je ne suis pas au courant? Quel est le meilleur changement ici pour s'assurer que le "rapport" à la fin de la course montre "toutes les sorties de toutes les instances"?

Answer 1

Pour chaque tâche Ansible conditionne le module avec toutes les bibliothèques et paramètres requis avant de l'envoyer à l'exécution via SSH. Donc, votre module principal (wrapper) devrait faire tout le travail en une seule fois.

méthode exit_jsonstops tout le processus avec sys.exit(0), donc quand vous appelez cette méthode pour la première fois la course de votre module est terminé.

Je vous recommande de créer une classe AnsibleModule et un ensemble d'aides qui renvoient des données à votre module parent. Ensuite, il suffit de combiner les résultats de tous les assistants en un seul objet et de le vider sur stdout (avec exit_json).