• Ansible 2.6 Pthon API

    核心代码

    python3.6

    ansible 2.6

     官方ansible-api文档：Python API — Ansible Documentation

    ansibleAPI 常用模块

    1. 用于读取yaml，json格式的文件
    2. from ansible.parsing.dataloader import DataLoader
    3. #用于管理变量的类，包括主机，组，扩展等变量
    4. from ansible.vars.manager import VariableManager
    5. #用于创建和管理inventory，倒入inventory文件
    6. from ansible.inventory.manager import InventoryManager
    7. #ad-hoc 存储着角色列表，任务，处理代码块
    8. from ansible.playbook.play import Play
    9. #ad-hoc ansible底层用到的任务队列
    10. from ansible.executor.task_queue_manager import TaskQueueManager
    11. #回调基类，用来定义回调事件，比如返回失败成功等信息
    12. from ansible.plugins.callback import CallbackBase
    13. #执行playbook
    14. from ansible.executor.playbook_executor import PlaybookExecutor
    15. #操作单个主机
    16. from ansible.inventory import host
    17. #操作单个主机组
    18. from ansible.inventory import group

    InventoryManager

    1. #实例化需要两个参数
    2. "参数一为读取yml文件的信息，需要实例化 DataLoader"
    3. "参数二为读取从那个位置读取资产配置文件，多个可逗号分割"
    4. intertory = InventoryManager(loader='',sources='')
    5. #以字典的方式打印出主机和主机组相关信息
    6. intertory.get_group_dict()
    7. #获取所有的主机
    8. inventory.get_hosts()
    9. #添加主机到指定主机组
    10. "参数一指定主机地址"
    11. "参数二指定主机端口"
    12. "参数三指定主机群组，必须存在的群组"
    13. inventory.add_host(host='10.1.41.200',port=2222,group='game_group')
    14. #获取指定的主机对象
    15. inventory.get_host(hostname='10.1.41.200')


    VariableManager

    1. #实例化需要两个参数
    2. "参数一为读取yml文件的信息，需要实例化 DataLoader"
    3. "参数二为资产管理配置变量"
    4. variable = VariableManager(loader=loader,inventory=inventory)
    5. #获取变量
    6. variable.get_vars()
    7. # 查看指定主机的详细变量信息
    8. "传入的host是inventory.get_host获得的主机对象"
    9. host = inventory.get_host(hostname='10.1.41.200')
    10. host_vars = variable.get_vars(host=host)
    11. #设置主机变量方法 
    12. "传入的host是inventory.get_host获得的主机对象"
    13. host = inventory.get_host(hostname='10.1.41.200')
    14. variable.set_host_variable(host=host,varname='ansible_ssh_pass',value='root')
    15. variable.set_host_variable(host=host,varname='ansible_ssh_user',value='root')
    16. #添加扩展变量
    17. "参数是一个字典多个逗号分割"
    18. variable.extra_vars={'devops':'best'}

    1. #!/usr/bin/env python
    2.  
    3. from collections import namedtuple
    4.  
    5. from ansible.executor.task_queue_manager import TaskQueueManager
    6. from ansible.inventory.manager import InventoryManager
    7. from ansible.parsing.dataloader import DataLoader
    8. from ansible.playbook.play import Play
    9. from ansible.plugins.callback import CallbackBase
    10. from ansible.vars.manager import VariableManager
    11.  
    12.  
    13. # Create a callback object so we can capture the output
    14. class ResultsCollector(CallbackBase):
    15.  
    16.     def __init__(self, *args, **kwargs):
    17.         super(ResultsCollector, self).__init__(*args, **kwargs)
    18.         self.host_ok = {}
    19.         self.host_unreachable = {}
    20.         self.host_failed = {}
    21.  
    22.     def v2_runner_on_unreachable(self, result):
    23.         self.host_unreachable[result._host.get_name()] = result
    24.  
    25.     def v2_runner_on_ok(self, result, *args, **kwargs):
    26.         self.host_ok[result._host.get_name()] = result
    27.  
    28.     def v2_runner_on_failed(self, result, *args, **kwargs):
    29.         self.host_failed[result._host.get_name()] = result
    30.  
    31.  
    32. def main():
    33.     host_list = ['10.1.41.210','10.1.41.200']
    34.     Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'remote_user',
    35.                                      'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args',
    36.                                      'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check',
    37.                                      'diff'])
    38.     # required for
    39.     # https://github.com/ansible/ansible/blob/devel/lib/ansible/inventory/manager.py#L204
    40.     sources = ','.join(host_list)
    41.     if len(host_list) == 1:
    42.         sources += ','
    43.  
    44.     # initialize needed objects
    45.     loader = DataLoader()
    46.     options = Options(connection='smart', module_path=['/usr/share/ansible'], forks=100,
    47.                       remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None,
    48.                       sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None,
    49.                       become_user=None, verbosity=None, check=False, diff=False,)
    50.  
    51.     passwords = dict()
    52.  
    53.     # create inventory and pass to var manager
    54.     inventory = InventoryManager(loader=loader, sources=sources)
    55.     variable_manager = VariableManager(loader=loader, inventory=inventory)
    56.     for host in host_list:
    57.         inventory.add_host(host=host,port=65534)
    58.         hostname=inventory.get_host(hostname=host)
    59.         variable_manager.set_host_variable(host=hostname,varname='ansible_ssh_pass',value='root')
    60.         variable_manager.set_host_variable(host=hostname,varname='ansible_ssh_user',value='root')
    61.  
    62.     # create play with tasks
    63.     play_source = dict(
    64.         name="Ansible Play",
    65.         hosts=host_list,
    66.         gather_facts='no',
    67.         #tasks=[dict(action=dict(module='command', args=dict(cmd='/usr/bin/uptime')))]
    68.         #tasks=[dict(action=dict(module='shell', args='/usr/sbin/ip a'))]
    69.         tasks=[
    70.                 dict(action=dict(module='setup', args='')),
    71.         #        dict(action=dict(module='setup', args=''),register='shell_out'),
    72.         #        dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
    73.         ]
    74.     )
    75.     play = Play().load(play_source, variable_manager=variable_manager, loader=loader)
    76.  
    77.     # actually run it
    78.     tqm = None
    79.     callback = ResultsCollector()
    80.     try:
    81.         tqm = TaskQueueManager(
    82.             inventory=inventory,
    83.             variable_manager=variable_manager,
    84.             loader=loader,
    85.             options=options,
    86.             passwords=passwords,
    87.         )
    88.         tqm._stdout_callback = callback
    89.         result = tqm.run(play)
    90.     finally:
    91.         if tqm is not None:
    92.             tqm.cleanup()
    93.  
    94.     print("UP ***********")
    95.     for host, result in callback.host_ok.items():
    96.         try:
    97.             print('{0} >>> {1}'.format(host, result._result['stdout']))
    98.         except :
    99.             print('{0} >>> {1}'.format(host, result._result['ansible_facts']))
    100.  
    101.     print("FAILED *******")
    102.     for host, result in callback.host_failed.items():
    103.         print('{0} >>> {1}'.format(host, result._result['msg']))
    104.  
    105.     print("DOWN *********")
    106.     for host, result in callback.host_unreachable.items():
    107.         print('{0} >>> {1}'.format(host, result._result['msg']))
    108.  
    109.  
    110. if __name__ == '__main__':
    111.     main()

    基于上面的内容，自己封装的API 如下：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. # author : liuyu
    4. # date : 2018/8/6 0006
    5.  
    6.  
    7. from collections import namedtuple
    8.  
    9. from ansible.executor.task_queue_manager import TaskQueueManager
    10. from ansible.inventory.manager import InventoryManager
    11. from ansible.parsing.dataloader import DataLoader
    12. from ansible.playbook.play import Play
    13. from ansible.plugins.callback import CallbackBase
    14. from ansible.vars.manager import VariableManager
    15. import ansible.constants as C
    16.  
    17. C.HOST_KEY_CHECKING = False
    18.  
    19.  
    20. def default_taskinfos():
    21.     TaskInfos = {
    22.         "hostinfo": [
    23.             {
    24.                 "host": "0.0.0.0",
    25.                 "port": 22,
    26.                 "user": "root",
    27.                 "password": "root"
    28.             },
    29.         ],
    30.         "taskinfo": [
    31.             {
    32.                 "module": "setup",
    33.                 "args": ""
    34.             },
    35.         ]
    36.     }
    37.     return TaskInfos
    38.  
    39.  
    40. # Create a callback object so we can capture the output
    41. class ResultsCollector(CallbackBase):
    42.  
    43.     def __init__(self, *args, **kwargs):
    44.         super(ResultsCollector, self).__init__(*args, **kwargs)
    45.         self.host_ok = {}
    46.         self.host_unreachable = {}
    47.         self.host_failed = {}
    48.  
    49.     def v2_runner_on_unreachable(self, result):
    50.         self.host_unreachable[result._host.get_name()] = result
    51.  
    52.     def v2_runner_on_ok(self, result, *args, **kwargs):
    53.         self.host_ok[result._host.get_name()] = result
    54.  
    55.     def v2_runner_on_failed(self, result, *args, **kwargs):
    56.         self.host_failed[result._host.get_name()] = result
    57.  
    58.  
    59. class AnsibleApi(object):
    60.  
    61.     def __init__(self, TaskInfos):
    62.         self.taskinfo = TaskInfos.get('taskinfo', default_taskinfos()["taskinfo"])
    63.         self.hostinfo = TaskInfos.get('hostinfo', default_taskinfos()["hostinfo"])
    64.         self.resultinfo = []
    65.  
    66.     def run(self):
    67.         host_list = []
    68.         [host_list.append(i.get("host", '0.0.0.0')) for i in self.hostinfo]
    69.         Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'remote_user',
    70.                                          'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args',
    71.                                          'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity',
    72.                                          'check',
    73.                                          'diff'])
    74.         # required for
    75.         # https://github.com/ansible/ansible/blob/devel/lib/ansible/inventory/manager.py#L204
    76.         sources = ','.join(host_list)
    77.         if len(host_list) == 1:
    78.             sources += ','
    79.  
    80.         # initialize needed objects
    81.         loader = DataLoader()
    82.         options = Options(connection='smart', module_path=['/usr/share/ansible'], forks=100,
    83.                           remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None,
    84.                           sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None,
    85.                           become_user=None, verbosity=None, check=False, diff=False, )
    86.  
    87.         passwords = dict(sshpass=None, becomepass=None)
    88.  
    89.         # create inventory and pass to var manager
    90.         inventory = InventoryManager(loader=loader, sources=sources)
    91.         variable_manager = VariableManager(loader=loader, inventory=inventory)
    92.         for host in self.hostinfo:
    93.             inventory.add_host(host=host.get('host'), port=host.get('port'))
    94.             hostname = inventory.get_host(hostname=host.get('host'))
    95.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_pass', value=host.get('password'))
    96.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_user', value=host.get('user'))
    97.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_port', value=host.get('port'))
    98.             # print("设置全局管理变量 %s"%host.get('host'))
    99.         # create play with tasks
    100.         tasks = []
    101.         # print(self.taskinfo)
    102.         for task in self.taskinfo:
    103.             # tasks.append(dict(action=dict(module=task.get("module"), args=task.get("args"))))
    104.             play_source = dict(
    105.                 name="Ansible API Play",
    106.                 hosts=host_list,
    107.                 gather_facts='no',
    108.                 # tasks=[dict(action=dict(module='command', args=dict(cmd='/usr/bin/uptime')))]
    109.                 # tasks=[dict(action=dict(module='shell', args='/usr/sbin/ip a'))]
    110.                 tasks=[dict(action=dict(module=task.get("module"), args=task.get("args")))]
    111.                 # dict(action=dict(module='setup', args='')),
    112.                 #        dict(action=dict(module='setup', args=''),register='shell_out'),
    113.                 #        dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
    114.  
    115.             )
    116.             play = Play().load(play_source, variable_manager=variable_manager, loader=loader)
    117.             # actually run it
    118.             tqm = None
    119.             callback = ResultsCollector()
    120.             try:
    121.                 tqm = TaskQueueManager(
    122.                     inventory=inventory,
    123.                     variable_manager=variable_manager,
    124.                     loader=loader,
    125.                     options=options,
    126.                     passwords=passwords,
    127.                 )
    128.                 tqm._stdout_callback = callback
    129.                 result = tqm.run(play)
    130.             finally:
    131.                 if tqm is not None:
    132.                     tqm.cleanup()
    133.  
    134.             # print("UP ***********")
    135.             # print(callback.host_ok.items())
    136.             for host, result in callback.host_ok.items():
    137.                 try:
    138.                     # print('{0} >>> {1}'.format(host, result._result['stdout']))
    139.                     self.resultinfo.append({host: {"message":result._result['stdout'],"code":0}})
    140.                 except:
    141.                     # print('{0} >>> {1}'.format(host, result._result['ansible_facts']))
    142.                     self.resultinfo.append({host: {"message":result._result['ansible_facts'],"code":0}})
    143.  
    144.             # print("FAILED *******")
    145.             for host, result in callback.host_failed.items():
    146.                 # print('{0} >>> {1}'.format(host, result._result['msg']))
    147.                 self.resultinfo.append({host: {"message":result._result['msg'],"code":1}})
    148.  
    149.             # print("DOWN *********")
    150.             for host, result in callback.host_unreachable.items():
    151.                 # print('{0} >>> {1}'.format(host, result._result['msg']))
    152.                 self.resultinfo.append({host: {"message":result._result['msg'],"code":-1}})
    153.  
    154.         return self.resultinfo
    155.  
    156.  
    157. def Baserun(TaskInfos):
    158.     TaskInfos = {
    159.         "hostinfo": [
    160.             {
    161.                 "host": "10.1.41.210",
    162.                 "port": 65534,
    163.                 "user": "root",
    164.                 "password": "root"
    165.             },
    166.             {
    167.                 "host": "10.1.41.220",
    168.                 "port": 6553,
    169.                 "user": "root",
    170.                 "password": "root"
    171.             },
    172.         ],
    173.         "taskinfo": [
    174.             {
    175.                 "module": "shell",
    176.                 "args": "hostname"
    177.             },
    178.             {
    179.                 "module": "command",
    180.                 "args": "/usr/bin/uptime"
    181.             },
    182.         ]
    183.     }
    184.     ansibleapi = AnsibleApi(TaskInfos)
    185.     results = ansibleapi.run()
    186.     print(results)
    187.  
    188.  
    189. def getsysinfo(hostinfo):
    190.     TaskInfos = {
    191.         "hostinfo": [
    192.             {
    193.                 "host": "10.1.41.210",
    194.                 "port": 65534,
    195.                 "user": "root",
    196.                 "password": "root"
    197.             },
    198.             {
    199.                 "host": "10.1.41.220",
    200.                 "port": 6553,
    201.                 "user": "root",
    202.                 "password": "root"
    203.             },
    204.         ],
    205.         "taskinfo": [
    206.             {
    207.                 "module": "setup",
    208.                 "args": ""
    209.             },
    210.         ]
    211.     }
    212.     TaskInfos["hostinfo"]=hostinfo
    213.     # print(TaskInfos)
    214.     ansibleapi = AnsibleApi(TaskInfos)
    215.     result = ansibleapi.run()
    216.     resultinfo=[]
    217.     # print(result)
    218.     for res in result:
    219.         for k in res:
    220.             data = res[k]["message"]
    221.             code=res[k]["code"]
    222.  
    223.             sysinfo = {}
    224.             disksize=0
    225.             if code !=0:
    226.                 resultinfo.append({k: res[k]})
    227.             else:
    228.                 for i in data["ansible_devices"]:
    229.                     if i[0:2] in ("vd", "ss", "sd"):
    230.                         disksize=disksize+int(data["ansible_devices"][i]["sectors"]) * int(
    231.                             data["ansible_devices"][i]["sectorsize"]) / 1024 / 1024 / 1024
    232.                 sysinfo['disk'] = "{}".format(str(disksize) + str(" GB"))
    233.                 sysinfo['mem'] = round(data['ansible_memtotal_mb'] / 1024)
    234.                 sysinfo['cpu'] = "{} * {}".format(data['ansible_processor_count'] * data["ansible_processor_cores"],
    235.                                                   data['ansible_processor'][2])
    236.                 sysinfo['system'] = data['ansible_distribution'] + " " + data['ansible_distribution_version']
    237.                 resultinfo.append({k:{"message":sysinfo,"code":0}})
    238.     return resultinfo
    239.  
    240.  
    241.  
    242.  
    243. def execshell(hostinfo, shellcmd):
    244.     TaskInfos = {
    245.         "hostinfo": [
    246.             {
    247.                 "host": "10.1.41.210",
    248.                 "port": 65534,
    249.                 "user": "root",
    250.                 "password": "root"
    251.             },
    252.             {
    253.                 "host": "10.1.41.220",
    254.                 "port": 6553,
    255.                 "user": "root",
    256.                 "password": "root"
    257.             },
    258.         ],
    259.         "taskinfo": [
    260.             {
    261.                 "module": "shell",
    262.                 "args": ""
    263.             },
    264.         ]
    265.     }
    266.     TaskInfos["hostinfo"]=hostinfo
    267.     TaskInfos["taskinfo"][0]["args"] = shellcmd
    268.     ansibleapi = AnsibleApi(TaskInfos)
    269.     result = ansibleapi.run()
    270.     return result
    271.  
    272. # data=getsysinfo([{"host": "10.1.41.220","port": 6553,"user": "root","password": "root"}])
    273. # print(data)
    274. # [{'10.1.41.220': {'disk': '30.0 GB', 'mem': 2, 'cpu': '4 * Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz', 'system': 'CentOS 7.2.1511'}}]
    275.  
    276. # data=execshell([{"host": "10.1.41.220","port": 6553,"user": "root","password": "root"}], "uptime")
    277. # print(data)
    278. # [{'10.1.41.220': ' 01:14:30 up  2:24,  2 users,  load average: 0.01, 0.02, 0.05'}]

    二，通过ansible-api 来添加免密认证

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. # author : liuyu
    4. # date : 2018/8/6 0006
    5.  
    6.  
    7. from collections import namedtuple
    8. from subprocess import Popen, PIPE
    9. import re
    10.  
    11. from ansible.executor.task_queue_manager import TaskQueueManager
    12. from ansible.inventory.manager import InventoryManager
    13. from ansible.parsing.dataloader import DataLoader
    14. from ansible.playbook.play import Play
    15. from ansible.plugins.callback import CallbackBase
    16. from ansible.vars.manager import VariableManager
    17. import ansible.constants as C
    18.  
    19. C.HOST_KEY_CHECKING = False
    20.  
    21.  
    22. def default_taskinfos():
    23.     TaskInfos = {
    24.         "hostinfo": [
    25.             {
    26.                 "host": "0.0.0.0",
    27.                 "port": 22,
    28.                 "user": "root",
    29.                 "password": "root"
    30.             },
    31.         ],
    32.         "taskinfo": [
    33.             {
    34.                 "module": "setup",
    35.                 "args": ""
    36.             },
    37.         ]
    38.     }
    39.     return TaskInfos
    40.  
    41.  
    42. # Create a callback object so we can capture the output
    43. class ResultsCollector(CallbackBase):
    44.  
    45.     def __init__(self, *args, **kwargs):
    46.         super(ResultsCollector, self).__init__(*args, **kwargs)
    47.         self.host_ok = {}
    48.         self.host_unreachable = {}
    49.         self.host_failed = {}
    50.  
    51.     def v2_runner_on_unreachable(self, result):
    52.         self.host_unreachable[result._host.get_name()] = result
    53.  
    54.     def v2_runner_on_ok(self, result, *args, **kwargs):
    55.         self.host_ok[result._host.get_name()] = result
    56.  
    57.     def v2_runner_on_failed(self, result, *args, **kwargs):
    58.         self.host_failed[result._host.get_name()] = result
    59.  
    60.  
    61. class AnsibleApi(object):
    62.  
    63.     def __init__(self, TaskInfos):
    64.         self.taskinfo = TaskInfos.get('taskinfo', default_taskinfos()["taskinfo"])
    65.         self.hostinfo = TaskInfos.get('hostinfo', default_taskinfos()["hostinfo"])
    66.         self.resultinfo = []
    67.  
    68.     def run(self):
    69.         host_list = []
    70.         [host_list.append(i.get("host", '0.0.0.0')) for i in self.hostinfo]
    71.         Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'remote_user',
    72.                                          'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args',
    73.                                          'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity',
    74.                                          'check',
    75.                                          'diff'])
    76.         # required for
    77.         # https://github.com/ansible/ansible/blob/devel/lib/ansible/inventory/manager.py#L204
    78.         sources = ','.join(host_list)
    79.         if len(host_list) == 1:
    80.             sources += ','
    81.  
    82.         # initialize needed objects
    83.         loader = DataLoader()
    84.         options = Options(connection='smart', module_path=['/usr/share/ansible'], forks=100,
    85.                           remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None,
    86.                           sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None,
    87.                           become_user=None, verbosity=None, check=False, diff=False, )
    88.  
    89.         passwords = dict(sshpass=None, becomepass=None)
    90.  
    91.         # create inventory and pass to var manager
    92.         inventory = InventoryManager(loader=loader, sources=sources)
    93.         variable_manager = VariableManager(loader=loader, inventory=inventory)
    94.         for host in self.hostinfo:
    95.             inventory.add_host(host=host.get('host'), port=host.get('port'))
    96.             hostname = inventory.get_host(hostname=host.get('host'))
    97.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_pass', value=host.get('password'))
    98.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_user', value=host.get('user'))
    99.             variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_port', value=host.get('port'))
    100.             # print("设置全局管理变量 %s"%host.get('host'))
    101.         # create play with tasks
    102.         tasks = []
    103.         # print(self.taskinfo)
    104.         for task in self.taskinfo:
    105.             # tasks.append(dict(action=dict(module=task.get("module"), args=task.get("args"))))
    106.             play_source = dict(
    107.                 name="Ansible API Play",
    108.                 hosts=host_list,
    109.                 gather_facts='no',
    110.                 # tasks=[dict(action=dict(module='command', args=dict(cmd='/usr/bin/uptime')))]
    111.                 # tasks=[dict(action=dict(module='shell', args='/usr/sbin/ip a'))]
    112.                 tasks=[dict(action=dict(module=task.get("module"), args=task.get("args")))]
    113.                 # dict(action=dict(module='setup', args='')),
    114.                 #        dict(action=dict(module='setup', args=''),register='shell_out'),
    115.                 #        dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
    116.  
    117.             )
    118.             play = Play().load(play_source, variable_manager=variable_manager, loader=loader)
    119.             # actually run it
    120.             tqm = None
    121.             callback = ResultsCollector()
    122.             try:
    123.                 tqm = TaskQueueManager(
    124.                     inventory=inventory,
    125.                     variable_manager=variable_manager,
    126.                     loader=loader,
    127.                     options=options,
    128.                     passwords=passwords,
    129.                 )
    130.                 tqm._stdout_callback = callback
    131.                 result = tqm.run(play)
    132.             finally:
    133.                 if tqm is not None:
    134.                     tqm.cleanup()
    135.  
    136.             # print("UP ***********")
    137.             # print(callback.host_ok.items())
    138.             for host, result in callback.host_ok.items():
    139.                 try:
    140.                     # print('{0} >>> {1}'.format(host, result._result['stdout']))
    141.                     self.resultinfo.append({host: {"message":result._result['stdout'],"code":0}})
    142.                 except:
    143.                     # print('{0} >>> {1}'.format(host, result._result['ansible_facts']))
    144.                     self.resultinfo.append({host: {"message":result._result['ansible_facts'],"code":0}})
    145.  
    146.             # print("FAILED *******")
    147.             for host, result in callback.host_failed.items():
    148.                 # print('{0} >>> {1}'.format(host, result._result['msg']))
    149.                 self.resultinfo.append({host: {"message":result._result['msg'],"code":1}})
    150.  
    151.             # print("DOWN *********")
    152.             for host, result in callback.host_unreachable.items():
    153.                 # print('{0} >>> {1}'.format(host, result._result['msg']))
    154.                 self.resultinfo.append({host: {"message":result._result['msg'],"code":-1}})
    155.  
    156.         return self.resultinfo
    157.  
    158.  
    159.  
    160.  
    161. def execshell(hostinfo, shellcmd):
    162.     TaskInfos = {
    163.         "hostinfo": [
    164.             {
    165.                 "host": "10.1.41.210",
    166.                 "port": 65534,
    167.                 "user": "root",
    168.                 "password": "root"
    169.             },
    170.           
    171.         ],
    172.         "taskinfo": [
    173.             {
    174.                 "module": "shell",
    175.                 "args": ""
    176.             },
    177.         ]
    178.     }
    179.     TaskInfos["hostinfo"]=hostinfo
    180.     TaskInfos["taskinfo"][0]["args"] = shellcmd
    181.     ansibleapi = AnsibleApi(TaskInfos)
    182.     result = ansibleapi.run()
    183.     return result
    184.  
    185.  
    186.  
    187. def setremotenopass(ip,port,username,password,fs):
    188.     #data=execshell([{"host": ip,"port": port,"user": username,"password": password}], "sed -i '/oldauthorized/d' /root/.ssh/authorized_keys")
    189.     data=execshell([{"host": ip,"port": port,"user": username,"password": password}], "echo {} >> /root/.ssh/authorized_keys".format(fs))
    190.  
    191.     child = Popen(["ssh -o StrictHostKeyChecking=no %s 'hostname && ip a| grep global'"%(ip)],shell=True,stdout=PIPE)
    192.     out,err=child.communicate()
    193.     print(data,out)
    194.  
    195. if __name__ == "__main__":
    196.     
    197.     
    198.     password="hostpassword"
    199.     port=15625
    200.     id_rsa_file="/root/.ssh/id_rsa.pub"
    201.     
    202.     hosts="./ip"
    203.     
    204.     with open(hosts,'r') as f:
    205.         lines=f.readlines()
    206.     with open(id_rsa_file,'r') as fpub:
    207.         fpubrsa=fpub.readlines()[0].strip('\n')
    208.  
    209.  
    210.     for i in lines:
    211.         result = re.findall(r"\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b", i)
    212.         if result:
    213.            for ip in result:
    214.                setremotenopass(ip,port,'root',password,fpubrsa)

  • 相关阅读:
    【编程DIY】一.几个有趣的小程序
    【双指针-简单】977. 有序数组的平方
    基于C++和C#窗体实现各种无损压缩算法并进行比较分析
    Docker 容器常见故障的排查处理
    如何避免远程访问欺诈？让远程办公更加安全的六个建议
    Seata四大模式之XA模式详解及代码实现
    IU酒店落子重庆，数山城美景
    chatgpt输出mysql常用语法汇总
    3D全景模型展示可视化技术演示
    有趣的statement stack
  • 原文地址：https://blog.csdn.net/ly1358152944/article/details/126436323