Lista de controle

• [] Incluí a saída de celery -A proj report na edição.
  software -> aipo: 4.0.2 (latentcall) kombu: 4.0.2 py: 3.6.0
  bilhar: 3.5.0.2 py-amqp: 2.1.4
  plataforma -> sistema: Darwin arch: 64 bits imp: CPython
  loader -> celery.loaders.app.AppLoader
  configurações -> transporte: resultados amqp: django-db).
• [] Eu verifiquei que o problema existe no ramo master do aipo.

Passos para reproduzir

1 .deploy_tomcat2.py
`from .AnsibleApi importar CallApi

def django_process (jira_num):
server = '10 .10.51.30 '
nome = 'abc'
porta = 11011
code = 'efs'
jdk = '1.12.13'
jvm = 'xxxx'

if str.isdigit(jira_num):
    # import pdb
    # pdb.set_trace()
    call = CallApi(server,name,port,code,jdk,jvm)
    return call.run_task()

`

1. AnsibleApi.py
   `#! / usr / bin / env python

- - codificação: utf-8 - -

registro de importação
de .Logger import Logger
das configurações de importação do django.conf
de coleções importar namedtuple
de ansible.parsing.dataloader import DataLoader
de ansible.vars import VariableManager
de ansible.inventory import Inventory
de ansible.playbook.play import Play
de ansible.executor.task_queue_manager import TaskQueueManager
de ansible.plugins.callback import CallbackBase

Log = Logger ('/ tmp / auto_deploy_tomcat.log', logging.INFO)

classe ResultCallback (CallbackBase):
def __init __ (self, args, * kwargs):
super (ResultCallback, self) .__ init __ ( args, * kwargs)
self.host_ok = {}
self.host_unreachable = {}
self.host_failed = {}

def v2_runner_on_unreachable(self, result):
    self.host_unreachable[result._host.get_name()] = result

def v2_runner_on_ok(self, result, *args, **kwargs):
    self.host_ok[result._host.get_name()] = result

def v2_runner_on_failed(self, result, *args, **kwargs):
    self.host_failed[result._host.get_name()] = result

classe CallApi (objeto):
user = settings.SSH_USER
ssh_private_key_file = settings.SSH_PRIVATE_KEY_FILE
results_callback = ResultCallback ()
Options = namedtuple ('Opções',
['conexão', 'caminho_módulo', 'arquivo_chave_privado', 'bifurcações', 'se torna', 'método_de_volvimento',
'tornar-se_usuário', 'verificar'])

def __init__(self,ip,name,port,code,jdk,jvm):
    self.ip = ip
    self.name = name
    self.port = port
    self.code = code
    self.jdk = jdk
    self.jvm = jvm
    self.results_callback = ResultCallback()
    self.results_raw = {}

def _gen_user_task(self):
    tasks = []
    deploy_script = 'autodeploy/abc.sh'
    dst_script = '/tmp/abc.sh'
    cargs = dict(src=deploy_script, dest=dst_script, owner=self.user, group=self.user, mode='0755')
    args = "%s %s %d %s %s '%s'" % (dst_script, self.name, self.port, self.code, self.jdk, self.jvm)
    tasks.append(dict(action=dict(module='copy', args=cargs),register='shell_out'))
    tasks.append(dict(action=dict(module='debug', args=dict(msg='{{shell_out}}'))))
    # tasks.append(dict(action=dict(module='command', args=args)))
    # tasks.append(dict(action=dict(module='command', args=args), register='result'))
    # tasks.append(dict(action=dict(module='debug', args=dict(msg='{{result.stdout}}'))))
    self.tasks = tasks

def _set_option(self):
    self._gen_user_task()

    self.variable_manager = VariableManager()
    self.loader = DataLoader()
    self.options = self.Options(connection='smart', module_path=None, private_key_file=self.ssh_private_key_file, forks=None,
                                become=True, become_method='sudo', become_user='root', check=False)
    self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=[self.ip])
    self.variable_manager.set_inventory(self.inventory)

    play_source = dict(
    name = "auto deploy tomcat",
        hosts = self.ip,
        remote_user = self.user,
        gather_facts='no',
        tasks = self.tasks
    )
    self.play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)

def run_task(self):
    self.results_raw = {'success':{}, 'failed':{}, 'unreachable':{}}
    tqm = None
    from celery.contrib import rdb
    rdb.set_trace()
    self._set_option()
    try:
        tqm = TaskQueueManager(
            inventory=self.inventory,
            variable_manager=self.variable_manager,
            loader=self.loader,
            options=self.options,
            passwords=None,
            stdout_callback=self.results_callback,
        )
        result = tqm.run(self.play)
    finally:
        if tqm is not None:
            tqm.cleanup()

    for host, result in self.results_callback.host_ok.items():
        self.results_raw['success'][host] = result._result

    for host, result in self.results_callback.host_failed.items():
        self.results_raw['failed'][host] = result._result

    for host, result in self.results_callback.host_unreachable.items():
        self.results_raw['unreachable'][host]= result._result
    Log.info("result is :%s" % self.results_raw)
    return self.results_raw

3.tasks.py from __future__ import absolute_import, unicode_literals
de importação de aipo shared_task
from .deploy_tomcat2 import django_process

rom celery.contrib import rdb

@shared_task
def implantar (num):
#return 'hello world {0}'. format (num)
# rdb.set_trace ()

return django_process(num)`

Comportamento esperado

No console django: shell python manage.py, posso usar deploy ('123'), chamar ansibleApi para copiar abc.sh para o servidor dst com sucesso.
Mas não funcionei quando usei 'deploy.apply_async (args = [' 1334 '], queue =' queue.ops.deploy ', routing_key =' ops.deploy ')'

Procurei alguns dias, ainda não deu certo.

Comportamento real

AnsibleApi retorna dict vazio: {'sucesso': {}, 'falhou': {}, 'inacessível': {}}