Lista de Verificación

• [] He incluido el resultado de celery -A proj report en la edición.
  software -> apio: 4.0.2 (llamada latente) kombu: 4.0.2 py: 3.6.0
  billar: 3.5.0.2 py-amqp: 2.1.4
  plataforma -> sistema: Darwin arch: 64bit imp: CPython
  cargador -> celery.loaders.app.AppLoader
  configuración -> transporte: amqp resultados: django-db).
• [] He verificado que el problema existe en la sucursal master de Apio.

pasos para reproducir

1 .deploy_tomcat2.py
`de .AnsibleApi importar CallApi

def django_process (jira_num):
servidor = '10 .10.51.30 '
nombre = 'abc'
puerto = 11011
código = '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

- - codificación: utf-8 - -

registro de importación
desde .Logger import Logger
desde la configuración de importación de django.conf
de la importación de colecciones namedtuple
desde ansible.parsing.dataloader importar DataLoader
desde ansible.vars importar VariableManager
desde ansible.inventory import Inventory
de ansible.playbook.play import Play
desde ansible.executor.task_queue_manager importar TaskQueueManager
desde ansible.plugins.callback importar CallbackBase

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

clase 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

clase CallApi (objeto):
usuario = configuración.SSH_USER
ssh_private_key_file = configuración.SSH_PRIVATE_KEY_FILE
results_callback = ResultCallback ()
Opciones = namedtuple ('Opciones',
['conexión', 'ruta_módulo', 'archivo_clave_privado', 'bifurcaciones', 'convertirse', 'convertirse_metodo',
'conviértete en_usuario', 'comprobar'])

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 de __future__ import absolute_import, unicode_literals
de importación de apio shared_task
desde .deploy_tomcat2 importar django_process

rom celery.contrib importar rdb

@tarea_compartida
def deploy (num):
#return 'hola mundo {0}'. formato (num)
# rdb.set_trace ()

return django_process(num)`

Comportamiento esperado

En la consola django: python manage.py shell, puedo usar deploy ('123'), llamar al código ansibleApi para copiar abc.sh al servidor dst con éxito.
Pero no funcioné cuando usé 'deploy.apply_async (args = [' 1334 '], queue =' queue.ops.deploy ', routing_key =' ops.deploy ')'

Busqué unos días, todavía no funciona.

Comportamiento real

AnsibleApi return dict vacío: {'éxito': {}, 'fallido': {}, 'inalcanzable': {}}