Daftar periksa

• [ ] Saya telah menyertakan output dari celery -A proj report dalam masalah ini.
  perangkat lunak -> seledri:4.0.2 (panggilan laten) kombu:4.0.2 py:3.6.0
  biliar:3.5.0.2 py-amqp:2.1.4
  platform -> sistem: Darwin arch: 64bit imp: CPython
  loader -> seledri.loaders.app.AppLoader
  pengaturan -> transport: hasil amqp: Django-db).
• [ ] Saya telah memverifikasi bahwa ada masalah pada master cabang Seledri.

Langkah-langkah untuk mereproduksi

1 .deploy_tomcat2.py
`dari .AnsibleApi mengimpor CallApi

def Django_process(jira_num):
server = '10.10.51.30'
nama = 'abc'
pelabuhan = 11011
kode = '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

- - pengkodean: utf-8 - -

impor log
dari .Logger impor Logger
dari pengaturan impor django.conf
dari koleksi impor bernamatuple
dari ansible.parsing.dataloader impor DataLoader
dari ansible.vars mengimpor VariableManager
dari ansible.inventory import Inventory
dari ansible.playbook.play impor Play
dari ansible.executor.task_queue_manager impor TaskQueueManager
dari ansible.plugins.callback impor CallbackBase

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

kelas 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

kelas CallApi(objek):
pengguna = pengaturan.SSH_USER
ssh_private_key_file = pengaturan.SSH_PRIVATE_KEY_FILE
result_callback = HasilCallback()
Opsi = bernamatuple('Opsi',
['koneksi', 'modul_jalur', 'file_kunci_pribadi', 'garpu', 'menjadi', 'menjadi_metode',
'menjadi_pengguna', 'periksa'])

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 dari __future__ import absolute_import, unicode_literals
dari seledri impor shared_task
dari .deploy_Tomcat2 impor Django_process

rom celery.contrib import rdb

@shared_task
def menyebarkan (angka):
#return 'halo dunia {0}'.format(num)
#rdb.set_trace()

return django_process(num)`

Perilaku yang diharapkan

Di konsol Django :python manage.py Shell , saya dapat menggunakan deploy('123') ,panggilan kode ansibleApi untuk menyalin abc.sh ke server dst dengan sukses.
Tapi saya tidak bekerja ketika saya menggunakan 'deploy.apply_async(args=['1334'], queue='queue.ops.deploy', routing_key='ops.deploy')'

Saya mencari beberapa hari, masih tidak berhasil.

Perilaku sebenarnya

AnsibleApi mengembalikan dict kosong :{'success': {}, 'failed': {}, 'unreachable': {}}