AnsibleResult.py代码如下
from ansible.plugins.callback import CallbackBase

class ModelResultsCollector(CallbackBase):
    def __init__(self, *args, **kwargs):
        super(ModelResultsCollector, 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

runner.py代码如下
from ansible.inventory.manager import InventoryManager
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from utils.AnsibleResult import ModelResultsCollector
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from collections import namedtuple
from ansible import constants



class ansible_task:
    def __init__(self, ip, user, password, port, type, cmd):
        self.ip = ip
        self.password = password,
        self.port = port
        self.user = user
        self.type = type
        self.cmd = cmd
        load = DataLoader()
        inventory = InventoryManager(loader=load, sources=['hosts'])
        varaibles = VariableManager(loader=load, inventory=inventory)
        Options = namedtuple('Options',
                             ['connection',
                              'module_path',
                              'sudo_user',
                              'forks',
                              'timeout',
                              'remote_user',
                              'ask_pass',
                              'private_key_file',
                              'ssh_common_args',
                              'ssh_extra_args',
                              'sftp_extra_args',
                              'scp_extra_args',
                              'become',
                              'become_method',
                              'become_user',
                              'ask_value_pass',
                              'verbosity',
                              'check',
                              'listhosts',
                              'listtasks',
                              'listtags',
                              'syntax',
                              'diff'])

        options = Options(connection='smart',
                          module_path=None,           
                          sudo_user=None,
                          forks=5,                    
                          timeout=10,                 
                          remote_user=self.user,         
                          ask_pass=self.password,             
                          private_key_file=None,      
                          ssh_common_args=None,       
                          ssh_extra_args=None,        
                          sftp_extra_args=None,       
                          scp_extra_args=None,        
                          become=None,
                          become_method=None,
                          become_user='root',
                          ask_value_pass=False,
                          verbosity=None,
                          check=False,
                          listhosts=False,
                          listtasks=False,
                          listtags=False,
                          syntax=False,
                          diff=True)
        self.a = inventory
        self.v = varaibles
        self.loader = load
        self.option = options

    def playtask(self):
        play_source = dict(
            name="Ansible test",    
            hosts=self.ip,
            gather_facts='no',        
            tasks=[                   
                dict(action=dict(module=self.type, args=self.cmd)),
            ]
        )

        callback = ModelResultsCollector()
        play = Play().load(play_source, variable_manager=self.v, loader=self.loader)
        passwords = dict()
        try:
            tqm = TaskQueueManager(
                inventory=self.a,
                variable_manager=self.v,
                loader=self.loader,
                options=self.option,
                passwords=passwords,
                stdout_callback=callback
            )
            constants.HOST_KEY_CHECKING = False
            tqm.run(play)
        except Exception as e:
            print(e)
        finally:
            if tqm is not None:
                tqm.cleanup()
        result_raw = {'success': {}, 'failed': {}, 'unreachable': {}}
        for host, result in callback.host_ok.items():
            result_raw['success'][host] = result._result
        for host, result in callback.host_failed.items():
            result_raw['failed'][host] = result._result
        for host, result in callback.host_unreachable.items():
            result_raw['unreachable'][host] = result._result
        print(result_raw)

if __name__ == '__main__':
    a = ansible_task(ip='192.168.1.20', user='root', password='123456', port='22', type='shell', cmd='ls /root')
    a.playtask()

不知道问题出在哪里？我想禁用主机密匙，只用账号密码登陆。虽然设置了constants.HOST_KEY_CHECKING = False，依旧无效，只要经过密匙认证的主机，而且就算密码错误，一样可以登陆，我估计是只认证书了，没用进行ssh密匙认证的主机无法链接，希望老师指点一下迷津