资产管理系统(未完待续)

:smile:

Demo

数据库表结构

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models
from datetime import datetime

# Create your models here.

HD_INTERFACE = (
    ('SSD', 'SSD'),
    ('SAS', 'SAS'),
    ('SATA', 'SATA'),
)

MEM_INTERFACE = (
    ('DDR3', 'DDR3'),
    ('DDR4', 'DDR4'),
    ('Unknown', 'Unknown')
)

STATUS = (
    ('1', '使用中'),
    ('2', '未使用'),
    ('3', '故障'),
    ('4', '报废'),
    ('5', '其他')
)

OS_TYPE = (
    ('Linux', 'Linux'),
    ('Windows', 'Windows'),
    ('Other', 'Other'),
)


AUTH_TYPE = (
    ('PWD', '密码认证'),
    ('KEY', '密钥认证')
)
# 定义服务器认证信息


class AuthInfo(models.Model):
    auth_type = models.CharField(max_length=10, choices=AUTH_TYPE, default='PWD', verbose_name='认证类型')
    user = models.CharField(max_length=128, verbose_name='认证用户')
    pwd = models.CharField(max_length=128, verbose_name='认证密码', null=True, blank=True)
    add_time = models.DateTimeField(default=datetime.now, verbose_name=u"添加时间")

    class Meta:
        verbose_name = '认证信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.user + '-' + self.auth_type

class HardDiskInfo(models.Model):
    '''
    物理磁盘信息
    '''
    wwn = models.CharField(max_length=100, verbose_name='序列号', unique=True)
    model = models.CharField(max_length=100, verbose_name='硬盘型号')
    size = models.CharField(max_length=100, verbose_name='硬盘大小')
    slot = models.CharField(max_length=2, verbose_name='插槽位置')
    interface = models.CharField(max_length=10, choices=HD_INTERFACE, verbose_name='接口类型')
    manufacturer = models.CharField(max_length=100, verbose_name='硬盘厂商')
    host = models.ForeignKey('PhysicalHostInfo', verbose_name='关联主机', null=True, blank=True)

    class Meta:
        verbose_name = '硬盘信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.wwn


class MemoryInfo(models.Model):
    '''
    内存信息
    '''
    sn = models.CharField(max_length=100, verbose_name='序列号', unique=True)
    size = models.CharField(max_length=100, verbose_name='内存大小')
    slot = models.CharField(max_length=10, verbose_name='插槽位置')
    interface = models.CharField(max_length=20, choices=MEM_INTERFACE, verbose_name='接口类型')
    speed = models.CharField(max_length=100, verbose_name='内存频率')
    manufacturer = models.CharField(max_length=100, verbose_name='内存厂商')
    voltage = models.CharField(max_length=100, verbose_name='内存电压', null=True, blank=True)
    host = models.ForeignKey('PhysicalHostInfo', verbose_name='关联主机', null=True, blank=True)

    class Meta:
        verbose_name = '内存信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.sn


class NetworkInfo(models.Model):
    '''
    网络信息
    '''
    name = models.CharField(max_length=100, verbose_name='网卡名称', null=True, blank=True)
    mac = models.CharField(max_length=48, verbose_name='网卡地址', null=True, blank=True)
    ip = models.GenericIPAddressField(verbose_name='IP地址', unique=True)
    mask = models.GenericIPAddressField(verbose_name='子网掩码', null=True, blank=True)
    gw = models.GenericIPAddressField(verbose_name='网关地址', null=True, blank=True)
    host = models.ForeignKey('PhysicalHostInfo', verbose_name='关联主机', null=True, blank=True)
    primary = models.BooleanField(default=False, verbose_name='默认地址')

    class Meta:
        verbose_name = '网络信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.host.sn + "-" + self.ip


class IdcInfo(models.Model):
    '''
    数据中心或机房信息
    '''
    name = models.CharField("机房名称", max_length=30, null=True)
    address = models.CharField("机房地址", max_length=100, null=True)
    tel = models.CharField("机房电话", max_length=30, null=True)
    contact = models.CharField("客户经理", max_length=30, null=True)
    contact_phone = models.CharField("移动电话", max_length=30, null=True)
    jigui = models.CharField("机柜信息", max_length=30, null=True)
    ip_range = models.CharField("IP范围", max_length=30, null=True)
    bandwidth = models.CharField("接入带宽", max_length=30, null=True)

    def __unicode__(self):
        return self.name

    class Meta:
        verbose_name = '机房管理'
        verbose_name_plural = '机房管理'


class CabinetInfo(models.Model):
    '''
    机柜信息
    '''
    name = models.CharField(max_length=10, verbose_name='机柜名称')
    cab_lever = models.CharField(max_length=2, verbose_name=u'机器U数,1-10分别代表1~10层')

    class Meta:
        verbose_name = u'机柜信息表'
        verbose_name_plural = verbose_name


class HostGroup(models.Model):
    '''
    主机组信息
    '''
    name = models.CharField("组名", max_length=30, unique=True)
    desc = models.CharField("描述", max_length=100, null=True, blank=True)

    class Meta:
        verbose_name = '属组管理'
        verbose_name_plural = '属组管理'

    def __unicode__(self):
        return self.name


class PhysicalHostInfo(models.Model):
    '''
    物理主机信息
    '''
    brand = models.CharField(max_length=60, verbose_name='品牌', null=True, blank=True)
    model = models.CharField(max_length=60, verbose_name='型号', null=True, blank=True)
    sn = models.CharField(max_length=60, verbose_name='序列号', null=True, blank=True)
    status = models.CharField(max_length=10, choices=STATUS, verbose_name='使用状态')
    use_department = models.CharField(max_length=100, verbose_name='使用部门', null=True, blank=True)
    asset_no = models.CharField(max_length=60, verbose_name='资产编号', null=True, blank=True)
    idc = models.ForeignKey('IdcInfo', verbose_name='机房', null=True, blank=True)
    cabinet = models.ForeignKey('CabinetInfo', verbose_name='机柜', null=True, blank=True)
    warranty_time = models.DateField(verbose_name='质保时间', null=True, blank=True)
    group = models.ForeignKey('HostGroup', verbose_name='主机组', null=True, blank=True)
    os_type = models.CharField(max_length=10, choices=OS_TYPE, verbose_name='操作系统', null=True, blank=True)
    os = models.CharField(max_length=60, verbose_name='操作系统', null=True, blank=True)
    os_kernel = models.CharField(max_length=60, verbose_name='内核', null=True, blank=True)
    hostname = models.CharField(max_length=100, verbose_name='主机名', null=True, blank=True)
    manage_ip = models.CharField(max_length=60, verbose_name='管理IP', null=True, blank=True)
    raid_adp_name = models.CharField(max_length=100, verbose_name='控制器名称', null=True, blank=True)
    raid_adp_sn = models.CharField(max_length=100, verbose_name='控制器序列号', null=True, blank=True)
    raid_adp_cache_size = models.CharField(max_length=100, verbose_name='缓存大小', null=True, blank=True)
    cpu_no = models.CharField(max_length=10, verbose_name='数量', null=True, blank=True)
    cpu_brand = models.CharField(max_length=60, verbose_name='品牌', null=True, blank=True)
    cpu_model = models.CharField(max_length=60, verbose_name='型号', null=True, blank=True)
    cpu_core = models.CharField(max_length=60, verbose_name='核心数', null=True, blank=True)
    cpu_threads_per_core = models.CharField(max_length=60, verbose_name='线程数/核', null=True, blank=True)
    comment = models.TextField(verbose_name='备注信息', null=True, blank=True)
    auth_info = models.ForeignKey(AuthInfo, verbose_name='认证信息', null=True, blank=True)

    class Meta:
        verbose_name = u'物理服务器'
        verbose_name_plural = verbose_name

    def __unicode__(self):
        return self.sn

    def get_nets(self):
        return self.networkinfo_set.all()

    def get_default_ip(self):
        return self.networkinfo_set.get(primary=True).ip
    get_default_ip.short_description = '默认IP'
    # def get_cpus(self):
    #     return self.cpuinfo_set.all().count()


class VirtualHostInfo(models.Model):
    sn = models.CharField(max_length=60, verbose_name='序列号')
    status = models.CharField(max_length=10, choices=STATUS, verbose_name='使用状态')
    use_department = models.CharField(max_length=100, verbose_name='使用部门')
    group = models.ForeignKey('HostGroup', verbose_name='主机组')
    os_type = models.CharField(max_length=10, choices=OS_TYPE, verbose_name='操作系统')
    os = models.CharField(max_length=60, verbose_name='操作系统')
    os_kernel = models.CharField(max_length=60, verbose_name='内核')
    hostname = models.CharField(max_length=100, verbose_name='主机名')
    cpu_no = models.CharField(max_length=10, verbose_name='数量')
    phy = models.ForeignKey('PhysicalHostInfo', verbose_name='宿主机信息')
    mem = models.ForeignKey('MemoryInfo', verbose_name='内存信息')
    hd = models.ForeignKey('HardDiskInfo', verbose_name='硬盘信息')
    net = models.ForeignKey('NetworkInfo', verbose_name='网络信息')
    comment = models.TextField(verbose_name='备注信息')

    class Meta:
        verbose_name = u'虚拟服务器'
        verbose_name_plural = verbose_name

    def __unicode__(self):
        return self.hostname

获取资产信息

# -*- coding:utf-8 -*-
__author__ = 'jianhu.yong'
__date__ = '19-4-10 下午4:48'

import os
from ansible import constants
from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.executor.playbook_executor import PlaybookExecutor
from ansible.plugins.callback import CallbackBase
from ansible.inventory.manager import InventoryManager
from ansible.vars.manager import VariableManager
from ansible.inventory.host import Host, Group
from cmdb.settings import BASE_DIR
from cmdb.settings import SSH_PRIVATE_KEY_FILE, SSH_USER

from asset.models import PhysicalHostInfo, NetworkInfo, MemoryInfo, HardDiskInfo
from datetime import datetime
import hashlib


class ModelResultsCollector(CallbackBase):
    def __init__(self, sn, *args, **kwargs):
        super(ModelResultsCollector, self).__init__(*args, **kwargs)
        self.host_ok = {}
        self.host_unreachable = {}
        self.host_failed = {}
        self.sn = sn

    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

        task_name = result.task_name
        if task_name == 'setup':
            host = result._host.name
            facts = result._result.get('ansible_facts')
            if facts:
                product_serial = facts.get('ansible_product_serial', 'NA')
                if product_serial != 'NA' and 'VMware' in product_serial:
                    virtual_type = 'vmware'
                elif product_serial != 'NA':
                    virtual_type = 'physical'
                else:
                    virtual_type = facts.get('facter_virtual', 'NA')

                self.sn_new = product_serial

                obj, status = PhysicalHostInfo.objects.get_or_create(sn=product_serial)
                obj.brand = facts.get('ansible_system_vendor')
                obj.model = facts.get('ansible_product_name')

                # 获取操作系统信息
                obj.os_type = facts.get('ansible_system')
                obj.os = facts.get('ansible_distribution')
                obj.os_kernel = facts.get('ansible_kernel')
                obj.hostname = facts.get('ansible_nodename')
                obj.save()

                # 获取CPU信息
                cpu_no = facts.get('ansible_processor_count')
                cpu_model = facts.get('ansible_processor')[-1]
                cpu_brand = facts.get('ansible_processor')[-2]
                cpu_core = facts.get('ansible_processor_cores')
                cpu_threads_per_core = facts.get('ansible_processor_threads_per_core')

                obj.cpu_no = cpu_no
                obj.cpu_model = cpu_model
                obj.cpu_brand = cpu_brand
                obj.cpu_core = cpu_core
                obj.cpu_threads_per_core = cpu_threads_per_core
                obj.save()


                # 获取网络信息
                interfaces_info = {}
                valid_interfaces = []
                interfaces = facts.get('ansible_interfaces')
                if 'lo' in interfaces:
                    interfaces.remove('lo')
                if 'w1g1' in interfaces:
                    interfaces.remove('w1g1')

                for interface in interfaces:
                    if not interface.startswith('vir'):
                        valid_interfaces.append(interface)

                default_interface = facts.get('ansible_default_ipv4').get('interface')
                default_gw = facts.get('ansible_default_ipv4').get('gateway')

                for interface in valid_interfaces:
                    interface_info = facts.get('ansible_{}'.format(interface))
                    if not interface_info.get('active'):
                        continue
                    if interface_info.has_key('ipv4'):
                        address = interface_info.get('ipv4').get('address')
                        netmask = interface_info.get('ipv4').get('netmask')
                    else:
                        address = None
                        netmask = None
                    macaddress = interface_info.get('macaddress')

                    if interface == default_interface:
                        primary = True
                        gateway = default_gw
                    else:
                        primary = False
                        gateway = None

                    interfaces_info[interface] = dict(
                        address=address,
                        netmask=netmask,
                        macaddress= macaddress,
                        primary=primary,
                        gateway=gateway
                    )

                ip_list = []
                for k, v in interfaces_info.items():
                    if v.get('primary'):
                        net_ins, status = NetworkInfo.objects.get_or_create(primary=True,ip=v.get('address'))
                        net_ins.primary = True
                    else:
                        if not v.get('address'):
                            continue
                        net_ins, status = NetworkInfo.objects.get_or_create(primary=False, ip=v.get('address'))
                        net_ins.primary = False
                    ip_list.append(v.get('address'))
                    net_ins.name = k
                    net_ins.mac = v.get('macaddress')
                    if v.get('address'):
                        net_ins.ip = v.get('address')
                    net_ins.mask = v.get('netmask')
                    net_ins.gw = v.get('gateway', None)
                    net_ins.host = obj
                    net_ins.save()
                net_ins = NetworkInfo.objects.filter(host_id=obj.id, primary=False).exclude(ip__in=ip_list)
                if net_ins:
                    net_ins.delete()

                """
                针对虚拟机和无法获取序列号的物理机做特殊处理
                1、vmware虚拟机有序列号，但是太长，无意义
                2、kvm虚拟机无序列号
                3、少数物理机无法正常获取序列号，需要手工维护
                """
                if virtual_type == 'physical' and product_serial != 'NA':  # 物理机能正常获取到序列号的情况
                    obj.product_serial = product_serial
                elif virtual_type != 'physical':  # 虚拟机
                    obj.product_serial = "{0}-{1}".format(virtual_type, host)
                else:  # 物理机无法正常获取产品序列号，需要手动更新
                    pass

                obj.save()






        elif task_name == 'mem':
            mem_info = []
            result = result._result.get('stdout').split('\n\n')
            for i in result:
                if not i.startswith('Handle'):
                    continue
                tmp = i.split('\n\t')
                mem_dict = {}
                for j in tmp:
                    if ':' not in j:
                        continue
                    else:
                        k,v = j.split(':')
                        mem_dict[k.strip()] = v.strip()
                mem_info.append(mem_dict)

            if self.sn == self.sn_new:
                obj, status = PhysicalHostInfo.objects.get_or_create(sn=self.sn)
            else:
                obj, status = PhysicalHostInfo.objects.get_or_create(sn=self.sn_new)
            sn_list = []
            for i in mem_info:
                if i.has_key('Size') and i.get('Size').endswith('MB'):
                    size = i.get('Size', 'Unknown')
                    slot = i.get('Locator', 'Unknown')
                    interface = i.get('Type', 'Unknown')
                    speed = i.get('Speed', 'Unknown')
                    manufacturer = i.get('Manufacturer', 'Unknown')
                    sn = i.get('Serial Number', None)
                    if not sn or sn == 'None':
                        h = hashlib.md5()
                        h.update(obj.sn+slot)
                        sn = h.hexdigest()
                    sn_list.append(sn)
                    voltage = i.get('Configured Voltage', 'Unknown')

                    mem_ins, status = MemoryInfo.objects.get_or_create(sn=sn)
                    mem_ins.sn = sn
                    mem_ins.size = size
                    mem_ins.slot = slot
                    mem_ins.interface = interface
                    mem_ins.speed = speed
                    mem_ins.manufacturer = manufacturer
                    mem_ins.voltage = voltage
                    mem_ins.host = obj
                    mem_ins.save()
            mem_ins = MemoryInfo.objects.filter(host_id=obj.id).exclude(sn__in=sn_list)
            if mem_ins:
                mem_ins.delete()
        elif task_name == 'hd':
            if self.sn == self.sn_new:
                obj, status = PhysicalHostInfo.objects.get_or_create(sn=self.sn)
            else:
                obj, status = PhysicalHostInfo.objects.get_or_create(sn=self.sn_new)
            result = result._result.get('stdout')
            import re

            raid_adp_name = re.search('Product Name:.+', result).group().split(':')[-1].strip()
            raid_adp_sn = re.search('Serial No:.+', result).group().split(':')[-1].strip()
            raid_adp_cache_size = re.search('Memory:.+', result).group().split(':')[-1].strip()

            obj.raid_adp_name = raid_adp_name
            obj.raid_adp_sn = raid_adp_sn
            obj.raid_adp_cache_size = raid_adp_cache_size
            obj.save()

            s = re.search('Physical Disk:.+alert : No', result, flags=re.DOTALL).group()

            hd_info = s.split('\n\n\n\n')

            wwn_list = []
            for hd in hd_info:
                slot = re.search('Slot Number:.+', hd).group().split(":")[-1].strip()
                wwn = re.search('WWN:.+', hd).group().split(":")[-1].strip()
                interface = re.search('PD Type:.+', hd).group().split(":")[-1].strip()
                size = re.search('Raw Size:.+B', hd).group().split(":")[-1].strip()
                manufacturer = re.search('Inquiry Data.+', hd).group().split(":")[-1].split()[0].strip()
                model = re.search('Inquiry Data.+', hd).group().split(":")[-1].split()[1].strip()

                wwn_list.append(wwn)

                hd_ins, status = HardDiskInfo.objects.get_or_create(wwn=wwn)
                hd_ins.slot = slot
                hd_ins.wwn = wwn
                hd_ins.interface = interface
                hd_ins.size = size
                hd_ins.manufacturer = manufacturer
                hd_ins.model = model
                hd_ins.host = obj
                hd_ins.save()

            hd_ins = HardDiskInfo.objects.filter(host_id=obj.id).exclude(wwn__in=wwn_list)
            if hd_ins:
                hd_ins.delete()









            pass



    def v2_runner_on_failed(self, result, *args, **kwargs):
        self.host_failed[result._host.get_name()] = result


class PlayBookResultsCollector(CallbackBase):
    CALLBACK_VERSION = 2.0
    def __init__(self, *args, **kwargs):
        super(PlayBookResultsCollector, self).__init__(*args, **kwargs)
        self.task_ok = {}
        self.task_skipped = {}
        self.task_failed = {}
        self.task_status = {}
        self.task_unreachable = {}

    def v2_runner_on_ok(self, result, *args, **kwargs):
        self.task_ok[result._host.get_name()]  = result

    def v2_runner_on_failed(self, result, *args, **kwargs):
        self.task_failed[result._host.get_name()] = result

    def v2_runner_on_unreachable(self, result):
        self.task_unreachable[result._host.get_name()] = result

    def v2_runner_on_skipped(self, result):
        self.task_ok[result._host.get_name()]  = result

    def v2_playbook_on_stats(self, stats):
        hosts = sorted(stats.processed.keys())
        for h in hosts:
            t = stats.summarize(h)
            self.task_status[h] = {
                "ok":t['ok'],
                "changed" : t['changed'],
                "unreachable":t['unreachable'],
                "skipped":t['skipped'],
                "failed":t['failures']
            }


class CustomInventory(object):
    def __init__(self, resource, auth_type):
        self.resource = resource
        self.auth_type = auth_type
        self.loader = DataLoader()
        self.inventory = InventoryManager(loader=self.loader, sources=[os.path.join(BASE_DIR, 'conf/inventory.conf')])
        # self.variable_manager.set_inventory(self.inventory)
        self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory)
        self.dynamic_inventory()

    def dynamic_inventory(self):
        '''
        添加主机信息
        '''
        if isinstance(self.resource, list):
            if self.auth_type == 'pwd_login':
                self.add_dynamic_group(self.resource, self.auth_type)
            elif self.auth_type == 'key_login':
                self.add_dynamic_group(self.resource, self.auth_type)

        elif isinstance(self.resource, dict):
            for groupname, hosts in self.resource.iteritems():
                self.add_dynamic_group(hosts, groupname)

    def add_dynamic_group(self, hosts, group_name, groupvars=None):
        """
        添加主机信息
        """
        if not self.inventory.groups.get(group_name, ''):
            self.inventory.add_group(group_name)

        group_ins = Group(name=group_name)

        # if group variables exists, add them to group
        if groupvars:
            for key, value in groupvars.iteritems():
                group_ins.set_variable(key, value)

        # add hosts to group
        for host in hosts:
            self.inventory.add_host(host=host,group=group_name)


class ANSRunner(object):
    """
    This is a General object for parallel execute modules.
    """
    def __init__(self, auth_type, resource, *args, **kwargs):
        self.loader = None
        self.inventory = None
        self.variable_manager = None
        self.resource = resource
        self.options = None
        self.passwords = None
        self.callback = None
        self.results_raw = {}
        self.auth_type = auth_type
        self.__initializeData()
        self.sn = kwargs.get('sn')

    def __initializeData(self):
        '''
        初始化ansible
        '''
        self.loader = DataLoader()
        Options = namedtuple('Options', ['connection', 'module_path', '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'])

        if self.auth_type == 'pwd_login':
            ask_pass = True
            ask_value_pass = True
            remote_user = 'root'
            private_key_file = None
        if self.auth_type == 'key_login':
            ask_pass = False
            ask_value_pass = False
            remote_user = SSH_USER
            private_key_file = SSH_PRIVATE_KEY_FILE

        self.options = Options(connection='smart', module_path=None, forks=2, timeout=10,
                remote_user=remote_user, ask_pass=ask_pass, private_key_file=private_key_file, ssh_common_args=None, ssh_extra_args=None,
                sftp_extra_args=None, scp_extra_args=None, become=True, become_method="sudo",
                become_user="root", ask_value_pass=ask_value_pass, verbosity=None, check=False, listhosts=False,
                listtasks=False, listtags=False, syntax=False, diff=True)

        self.passwords = dict(
            conn_pass='xxxx',
            becomepass='xxxx'
        )

        ci = CustomInventory(self.resource, self.auth_type)
        self.inventory = ci.inventory
        self.variable_manager = ci.variable_manager
        pass

    def run_model(self, host_list, module_name, module_args=None):
        """
        run module from andible ad-hoc.
        module_name: ansible module_name
        module_args: ansible module args
        """
        if module_args:
            play_source = dict(
                    name="Ansible Play",
                    hosts=host_list,
                    gather_facts='no',
                    tasks=[
                        dict(action=dict(module='setup')),
                        dict(action=dict(module='shell', args='/usr/sbin/dmidecode -t memory')),
                    ]
            )
        else:
            play_source = dict(
                    name="Ansible Play",
                    hosts=host_list,
                    gather_facts='no',
                    tasks=[
                        dict(action=dict(module='setup'), name="setup"),
                        dict(action=dict(module='shell', args='/usr/sbin/dmidecode -t memory'), name='mem'),
                        dict(action=dict(module='shell', args='/opt/MegaRAID/MegaCli/MegaCli64 -cfgdsply -aALL -NoLog'), name='hd')
                    ]
            )
        play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)
        tqm = None
        self.callback = ModelResultsCollector(sn=self.sn)
        import traceback
        try:
            tqm = TaskQueueManager(
                inventory=self.inventory,
                variable_manager=self.variable_manager,
                loader=self.loader,
                options=self.options,
                passwords=self.passwords,
                stdout_callback = "minimal",
            )
            tqm._stdout_callback = self.callback
            constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令
            tqm.run(play)
        except Exception as err:
            print traceback.print_exc()
            # DsRedis.OpsAnsibleModel.lpush(self.redisKey,data=err)
            # if self.logId:AnsibleSaveResult.Model.insert(self.logId, err)
        finally:
            if tqm is not None:
                tqm.cleanup()

    def run_playbook(self, playbook_path,extra_vars=None):
        """
        run ansible palybook
        """
        try:
            # if self.redisKey:self.callback = PlayBookResultsCollectorToSave(self.redisKey,self.logId)
            self.callback = PlayBookResultsCollector()
            if extra_vars:self.variable_manager.extra_vars = extra_vars
            executor = PlaybookExecutor(
                playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader,
                options=self.options, passwords=self.passwords,
            )
            executor._tqm._stdout_callback = self.callback
            constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令
            executor.run()
        except Exception as err:
            return False

    def get_model_result(self):
        self.results_raw = {'success':{}, 'failed':{}, 'unreachable':{}}
        for host, result in self.callback.host_ok.items():
            hostvisiable = host.replace('.','_')
            self.results_raw['success'][hostvisiable] = result._result


        for host, result in self.callback.host_failed.items():
            hostvisiable = host.replace('.','_')
            self.results_raw['failed'][hostvisiable] = result._result


        for host, result in self.callback.host_unreachable.items():
            hostvisiable = host.replace('.','_')
            self.results_raw['unreachable'][hostvisiable]= result._result

        # return json.dumps(self.results_raw)
        return self.results_raw

    def get_playbook_result(self):
        self.results_raw = {'skipped':{}, 'failed':{}, 'ok':{},"status":{},'unreachable':{},"changed":{}}
        for host, result in self.callback.task_ok.items():
            self.results_raw['ok'][host] = result

        for host, result in self.callback.task_failed.items():
            self.results_raw['failed'][host] = result

        for host, result in self.callback.task_status.items():
            self.results_raw['status'][host] = result

        # for host, result in self.callback.task_changed.items():
        #     self.results_raw['changed'][host] = result

        for host, result in self.callback.task_skipped.items():
            self.results_raw['skipped'][host] = result

        for host, result in self.callback.task_unreachable.items():
            self.results_raw['unreachable'][host] = result
        return self.results_raw


if __name__ == '__main__':
    # resource = [
    #     {"hostname": "192.168.8.119"},
    #     {"hostname": "192.168.6.43"},
    #     {"hostname": "192.168.1.233"},
    #  ]

    # resource = {
    #     "dynamic_host": {
    #         "hosts": [
    #                     {'username': u'root', 'password': '123456', 'ip': '192.168.1.108','hostname':'nginx01','port':'22'},
    #                     {"hostname":"778da6afsdwf","ip": "192.168.1.109", "port": "22", "username": "root", "password":"123456"},
    #                   ],
    #         "vars": {
    #                  "var1":"ansible",
    #                  "var2":"saltstack"
    #                  }
    #     }
    # }

    resource = {
        'key_login': ['10.105.42.16']
    }
    rbt = ANSRunner(resource)

    # Ansible Adhoc
    rbt.run_model(host_list=resource['key_login'], module_name='setup')
    data = rbt.get_model_result()
    pass
    # Ansible playbook
    # rbt.run_playbook(playbook_path='/etc/ansible/playbook/OPUSE.yml')
    # print rbt.get_playbook_result()
    # rbt.run_model(host_list=[],module_name='yum',module_args="name=htop state=present")