Checkliste

• [ ] Ich habe die Ausgabe von celery -A proj report in die Ausgabe aufgenommen.
  software -> sellerie:4.0.2 (latentcall) kombu:4.0.2 py:3.6.0
  Billard:3.5.0.2 py-amqp:2.1.4
  Plattform -> System:Darwin arch:64bit imp:CPython
  loader -> celery.loaders.app.AppLoader
  Einstellungen -> transport:amqp results:django-db).
• [ ] Ich habe überprüft, dass das Problem für den master Zweig von Celery besteht.

Schritte zum Reproduzieren

1 .deploy_tomcat2.py
`von .AnsibleApi importieren CallApi

def django_process(jira_num):
Server = '10.10.51.30'
name = 'abc'
Port = 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

- - Codierung: utf-8 - -

Protokollierung importieren
aus .Logger importieren Logger
von django.conf Importeinstellungen
aus Sammlungen importieren namenstuple
aus ansible.parsing.dataloader importieren DataLoader
aus ansible.vars importieren VariableManager
aus ansible.inventory importieren Inventar
aus ansible.playbook.play importieren Play
from ansible.executor.task_queue_manager import TaskQueueManager
aus ansible.plugins.callback importieren CallbackBase

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

Klasse 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

Klasse CallApi(Objekt):
user = settings.SSH_USER
ssh_private_key_file = settings.SSH_PRIVATE_KEY_FILE
results_callback = ResultCallback()
Optionen = namedtuple('Optionen',
['Verbindung', 'Modulpfad', 'private_Schlüsseldatei', 'Verzweigungen', 'become', 'become_method',
'become_user', 'check'])

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
aus Sellerieimport shared_task
aus .deploy_tomcat2 importieren django_process

rom celery.contrib importieren rdb

@shared_task
def bereitstellen(num):
#return 'Hallo Welt {0}'.format(num)
#rdb.set_trace()

return django_process(num)`

Erwartetes Verhalten

In der django-Konsole: python manage.py shell kann ich deploy('123') verwenden, den Codeaufruf ansibleApi, um abc.sh erfolgreich auf den dst-Server zu kopieren.
Aber ich habe nicht funktioniert, als ich 'deploy.apply_async(args=['1334'], queue='queue.ops.deploy', routing_key='ops.deploy')' verwendet habe.

Ich habe ein paar Tage gesucht, funktioniert immer noch nicht.

Tatsächliches Verhalten

AnsibleApi gibt leeres dict zurück :{'success': {}, 'failed': {}, 'unreachable': {}}