class NetworkTest(object):
    def __init__(self, playbook):
        self.inventory = Inventory(host_list=[])
        self.playbook = playbook

        self.stac_nodes_group = Group(name='stac_nodes')
        self.inventory.add_group(self.stac_nodes_group)

        self.inv_vars = dict()

    def set_inventory_vars(self, inv_vars):
        self.inv_vars.update(inv_vars)

    def add_stac_node(self, node):
        stac_node = Host(name=node)
        self.stac_nodes_group.add_host(stac_node)

    def run(self):
        stats = AggregateStats()
        playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

        pb = playbook.PlayBook(playbook=self.playbook,
                               stats=stats,
                               callbacks=playbook_cb,
                               runner_callbacks=runner_cb,
                               inventory=self.inventory,
                               extra_vars=self.inv_vars,
                               check=False)

        pr = pb.run()

        print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
def build_inventory(loader, variable_manager, group_names, playbook_basedir):
    inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=['localhost'])

    # because we just pass in a "host list" which isn't a real inventory file,
    # we explicitly have to add all of the desired groups to the inventory. By
    # default an "all" group is created whenever a new inventory is created
    for group_name in group_names:
        if not inventory.get_group(group_name):
            inventory.add_group(Group(group_name))

    # because we are explicitly adding groups, we also need to make sure that a
    # playbook basedir is set so that `group_vars` can be loaded from the
    # correct directory.
    inventory.set_playbook_basedir(playbook_basedir)
    inventory_hosts = inventory.get_hosts()

    # for each group specified, ensure that the inventory's host (localhost) is
    # explicitly in the group.
    for group_name in group_names:
        group = inventory.get_group(group_name)
        if group.get_hosts():
            continue

        for host in inventory.get_hosts():
            group.add_host(host)

    return inventory
Beispiel #3
0
def run_ansible_in_python(task):
    stats = callbacks.AggregateStats()
    ## everything between this comment
    ## and the "end" should hopefully not be necessary
    ## after Ansible 1.4.6 or 1.5 is released, since there
    ## will be an implicit sys.executable interpreter for the localhost
    ## host. This will almost certainly need tweaking anyway for dynamic inventory
    ## in ec2. I'm not sure yet how this would work.
    localhost = Host('localhost')
    localhost.set_variable('ansible_python_interpreter', sys.executable)
    all_group = Group('all')
    all_group.add_host(localhost)
    inventory = Inventory(None)
    inventory.add_group(all_group)
    os.putenv('EC2_INI_PATH', 'lib/glue/ec2-external.ini')
    ec2_inventory = InventoryScript(filename='lib/glue/ec2.py')
    inventory.parser = ec2_inventory
    [inventory.add_group(group) for group in ec2_inventory.groups.values()]
    ## end

    pb = playbook.PlayBook(playbook=task.inputs[0].abspath(),
                           inventory=inventory,
                           stats=stats,
                           callbacks=callbacks.PlaybookCallbacks(verbose=3),
                           runner_callbacks=callbacks.PlaybookRunnerCallbacks(stats, verbose=3)
                           )
    pb.run()
Beispiel #4
0
class NetworkTest(object):
    def __init__(self, playbook):
        self.inventory = Inventory(host_list=[])
        self.playbook = playbook
 
        self.stac_nodes_group = Group(name='stac_nodes')
        self.inventory.add_group(self.stac_nodes_group)
 
        self.inv_vars = dict()

    def set_inventory_vars(self, inv_vars):
        self.inv_vars.update(inv_vars)

    def add_stac_node(self, node):
        stac_node = Host(name=node)
        self.stac_nodes_group.add_host(stac_node)

    def run(self):
        stats = AggregateStats()
        playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

        pb = playbook.PlayBook(playbook=self.playbook,
                               stats=stats,
                               callbacks=playbook_cb,
                               runner_callbacks=runner_cb,
                               inventory=self.inventory,
                               extra_vars=self.inv_vars,
                               check=False)

        pr = pb.run()

        print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
def build_inventory(loader, variable_manager, group_names, playbook_basedir):
    inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=['localhost'])

    # because we just pass in a "host list" which isn't a real inventory file,
    # we explicitly have to add all of the desired groups to the inventory. By
    # default an "all" group is created whenever a new inventory is created
    for group_name in group_names:
        if not inventory.get_group(group_name):
            inventory.add_group(Group(group_name))

    # because we are explicitly adding groups, we also need to make sure that a
    # playbook basedir is set so that `group_vars` can be loaded from the
    # correct directory.
    inventory.set_playbook_basedir(playbook_basedir)

    # for each group specified, ensure that the inventory's host (localhost) is
    # explicitly in the group.
    for group_name in group_names:
        group = inventory.get_group(group_name)
        if group.get_hosts():
            continue

        for host in inventory.get_hosts():
            group.add_host(host)

    return inventory
Beispiel #6
0
 def add_group(self, group):
     if isinstance(group, basestring):
         group = Group(group)
     try:
         self.log.debug('add inventory group: %s' % group.name)
         AnsibleInventory.add_group(self, group)
     except AnsibleError, emsg:
         raise InventoryError(emsg)
Beispiel #7
0
class MyInventory(Inventory):
    """
    this is my ansible inventory object.
    """
    def __init__(self, resource, loader, variable_manager):
        self.resource = resource
        self.inventory = Inventory(loader=loader,
                                   variable_manager=variable_manager,
                                   host_list=[])
        self.dynamic_inventory()

    def add_dynamic_group(self, hosts, groupname, groupvars=None):
        """
            add hosts to a group
        """
        my_group = Group(name=groupname)

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

                # add hosts to group
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            # set other variables
            for key, value in host.iteritems():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
                    # add to group
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def dynamic_inventory(self):
        """
            add hosts to inventory.
        """
        if isinstance(self.resource, list):
            self.add_dynamic_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.iteritems():
                self.add_dynamic_group(hosts_and_vars.get("hosts"), groupname,
                                       hosts_and_vars.get("vars"))
Beispiel #8
0
class MyInventory(object):
    def __init__(self, resource, loader, variable_manager):
        self.resource = resource
        # 创建主机配置清单对象
        self.inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[])
        self.dynamic_inventory()

    def add_dynamic_group(self, hosts, groupname, groupvars=None):
        """
        动态创建主机组
        :param hosts: 主机列表
        :param groupname: 组机组名
        :param groupvars: 组参数
        :return: 
        """
        my_group = Group(name=groupname)  # 创建主机组对象
        if groupvars:
            # 设置主机组参数
            for key, value in groupvars.items():
                my_group.set_variable(key, value)
        for host in hosts:
            # 设置链接参数
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)  # 创建主机对象
            # 设置主机参数
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_sudo_pass', password)
            my_host.set_variable('ansible_sudo', 'yes')
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)
            for key, value in host.items():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            my_group.add_host(my_host)  # 将主机对象添加到主机组对象中

        self.inventory.add_group(my_group)  # 将主机组添加到主机配置清单中

    def dynamic_inventory(self):
        """
        动态配置主机清单对象
        :return: 
        """
        if isinstance(self.resource, list):
            # 只是主机列表,也就是所有的主机都属于同一个默认的主机组
            self.add_dynamic_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            # 包含组的主机列表,也就是有若干个主机组
            for groupname, hosts_and_vars in self.resource.items():
                self.add_dynamic_group(hosts_and_vars.get("hosts"), groupname, hosts_and_vars.get("vars"))
Beispiel #9
0
class MyInventory(Inventory):
    """
    this is my ansible inventory object.
    """

    def __init__(self):
        self.inventory = Inventory(my_inventory)
        #self.gen_inventory()

    def my_add_group(self, hosts, groupname, groupvars=None):
        """
        add hosts to a group
        """
        my_group = Group(name=groupname)

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

        # add hosts to group
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            # set other variables
            for key, value in host.iteritems():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            # add to group
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def gen_inventory(self):
        """
        add hosts to inventory.
        """
        if isinstance(self.resource, list):
            self.my_add_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.iteritems():
                self.my_add_group(
                    hosts_and_vars.get("hosts"), groupname,
                    hosts_and_vars.get("vars"))
Beispiel #10
0
class MyInventory(Inventory):
    def __init__(self, resource):
        """
        resource的数据格式是一个列表字典,比如
            {
                "group1": {
                    "hosts": [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...],
                    "vars": {"var1": value1, "var2": value2, ...}
                }
            }

        如果你只传入1个列表,这默认该列表内的所有主机属于my_group组,比如
            [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...]
        """
        self.resource = resource
        self.inventory = Inventory(host_list=[])
        self.gen_inventory()
        
    def my_add_group(self, hosts, groupname, groupvars=None):
        my_group = Group(name=groupname)
        if groupvars:
            for key, value in groupvars.iteritems():
                my_group.set_variable(key, value)

        for host in hosts:
            hostname = host.get('hostname')
            hostip = host.get('ip', hostname)
            hostport = host.get('port', 22)
            username = host.get('username', 'root')
            password = host.get('password')
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            for key, value in host.iteritems():
                if key not in ['hostname', 'port', 'username', 'password']:
                    my_host.set_variable(key, value)
            my_group.add_host(my_host)
        self.inventory.add_group(my_group)
        

    def gen_inventory(self):
        if isinstance(self.resource, list):
            self.my_add_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.iteritems():
                self.my_add_group(hosts_and_vars.get('hosts'), groupname, hosts_and_vars.get('vars'))
Beispiel #11
0
class MyInventory(Inventory):
    """inventory"""

    def __init__(self, resource, loader, variable_manager):
        self.resource = resource
        self.inventory = Inventory(
            loader=loader, variable_manager=variable_manager, host_list=[])
        self.dynamic_inventory()

    def add_dynamic_group(self, hosts, groupname, groupvars=None):
        """dynamic inventory group"""
        my_group = Group(name=groupname)
        if groupvars:
            for key, value in groupvars.items():
                my_group.set_variable(key, value)
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)
            for key, value in host.items():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def dynamic_inventory(self):
        if isinstance(self.resource, list):
            self.add_dynamic_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.items():
                self.add_dynamic_group(
                    hosts_and_vars.get("hosts"), groupname,
                    hosts_and_vars.get("vars"))
class MyInventory(Inventory):
    def __init__(self, resource, loader, variable_manager):
        self.resource = resource
        self.inventory = Inventory(loader=loader,
                                   variable_manager=variable_manager,
                                   host_list=[])
        self.dynamic_inventory()
        # logger.info(self.resource)
        # logger.info(self.inventory.list_hosts("all"))

    def add_dynamic_group(self, hosts, groupname, groupvars=None):
        my_group = Group(name=groupname)
        if groupvars:
            for key, value in groupvars.items():
                my_group.set_variable(key, value)
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            # hostport = host.get("port")
            # username = host.get("username")
            # password = host.get("password")
            # ssh_key = host.get("ssh_key")
            # my_host = Host(name=hostname, port=hostport)
            my_host = Host(name=hostname)
            # my_host.set_variable('ansible_ssh_host', hostip)
            # my_host.set_variable('ansible_ssh_port', hostport)
            # my_host.set_variable('ansible_ssh_user', username)
            # my_host.set_variable('ansible_ssh_pass', password)
            # my_host.set_variable('ansible_ssh_private_key_file', ssh_key)
            for key, value in host.items():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def dynamic_inventory(self):
        if isinstance(self.resource, list):
            self.add_dynamic_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.items():
                self.add_dynamic_group(hosts_and_vars.get("hosts"), groupname,
                                       hosts_and_vars.get("vars"))
Beispiel #13
0
def playbook(**kwargs):
    group_vars = kwargs['group_vars']
    groups = kwargs['groups']
    host_list = kwargs['host_list']
    playbook_basedir = os.sep.join([ANSIBLE_PLAYBOOK_PATH, kwargs['playbook_basedir']])
    playbooks = []
    for pb in kwargs['playbooks']:
        playbooks.append(os.sep.join([playbook_basedir, pb]))

    job_id = kwargs['job_id']
    loader = DataLoader()
    vars = VariableManager()
    # 指定inventory为一个目录,设置所有主机,包含group和host
    invertory = Inventory(loader, vars,
                          host_list=host_list)

    invertory.set_playbook_basedir(playbook_basedir)
    for group_name, hosts in groups.items():
        t_group = Group(group_name)
        for host in hosts:
            t_host = Host(host)
            t_group.add_host(t_host)
        invertory.add_group(t_group)

    vars.set_inventory(invertory)
    display = LogDisplay(logname=job_id)
    callback = CALLBACKMODULE[CALLBACK](display=display)
    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',
                                     'listtags', 'listtasks', 'syntax'])

    options = Options(connection='smart', module_path='/usr/share/ansible', forks=100, timeout=10,
                      remote_user='******', ask_pass=False, 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='******', ask_value_pass=False, verbosity=None,
                      check=False, listhosts=None, listtags=None, listtasks=None, syntax=None)

    passwords = dict()
    pb_executor = PlaybookExecutor(playbooks, invertory, vars, loader, options, passwords)
    pb_executor._tqm._stdout_callback = callback
    pb_executor.run()
    return display.get_log_json()
Beispiel #14
0
    def _load(self):

        variable_manager = VariableManager()
        variable_manager.extra_vars = {}
        variable_manager.options_vars = {'ansible_check_mode': False}

        loader = DataLoader()
        passwords = dict(vault_pass='******')

        #display seems not to work yet :-(
        display = Display()
        display.verbosity = self.options.verbosity
        #        playbook_executor.display.verbosity = self.options.verbosity

        extra_vars = {
            'elastic_url': Configuration.elastic_url,
            'uuid': self._job.uuid
        }
        self.variable_manager.extra_vars = extra_vars

        inventory = Inventory(loader=loader,
                              variable_manager=variable_manager,
                              host_list=self.inventoryContainer.allHosts())
        for group in self.inventoryContainer.groups:
            if group.name == 'all':
                if group.vars:
                    inventory.get_group('all').vars.update(group.vars)
            else:
                group.parent_groups.append(inventory.get_group('all'))
                inventory.add_group(group)

        variable_manager.set_inventory(inventory)
        playbook = "%s/%s" % (self.pb_dir__, self.playbook__)

        pbx = PlaybookExecutor(playbooks=[playbook],
                               inventory=inventory,
                               variable_manager=variable_manager,
                               loader=loader,
                               options=self.options,
                               passwords=passwords)
        pbx.run()
Beispiel #15
0
class NetworkTest(object):
    def __init__(self, playbook):
        self.inventory = Inventory()
        self.playbook = playbook
        
        self.sender_group = Group(name = 'sender')
        self.inventory.add_group(self.sender_group)
        
        self.receiver_group = Group(name = 'receiver')
        self.inventory.add_group(self.receiver_group)
        
        self.master_group = Group(name = 'master')
        self.inventory.add_group(self.master_group)
        
        self.inv_vars = dict()

        
    def set_inventory_vars(self, inv_vars):
        self.inv_vars.update(inv_vars)


    def add_sender(self, sender):
        sender_host = Host(name = sender)
        self.sender_group.add_host(sender_host)


    def add_receiver(self, receiver):
        receiver_host = Host(name = receiver)
        self.receiver_group.add_host(receiver_host)

        
    def add_master(self, master):
        master_host = Host(name = master)
        self.master_group.add_host(master_host)


    def run(self):
        stats = AggregateStats()
        playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

        pb = playbook.PlayBook(playbook = self.playbook,
                               stats = stats,
                               callbacks = playbook_cb,
                               runner_callbacks = runner_cb,
                               inventory = self.inventory,
                               extra_vars = self.inv_vars,
                               check=False)

        pr = pb.run()

        print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
Beispiel #16
0
class StorageTest(object):
    def __init__(self, playbook):
        self.inventory = Inventory(host_list=[])
        self.playbook = playbook

        self.sender_group = Group(name='sender')
        self.inventory.add_group(self.sender_group)

        self.receiver_group = Group(name='receiver')
        self.inventory.add_group(self.receiver_group)

        self.master_group = Group(name='master')
        self.inventory.add_group(self.master_group)

        self.inv_vars = dict()

    def set_inventory_vars(self, inv_vars):
        self.inv_vars.update(inv_vars)

    def add_sender(self, sender):
        sender_host = Host(name=sender)
        self.sender_group.add_host(sender_host)

    def add_receiver(self, receiver):
        receiver_host = Host(name=receiver)
        self.receiver_group.add_host(receiver_host)

    def add_master(self, master):
        master_host = Host(name=master)
        self.master_group.add_host(master_host)

    def run(self):
        stats = AggregateStats()
        playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

        pb = playbook.PlayBook(playbook=self.playbook,
                               stats=stats,
                               callbacks=playbook_cb,
                               runner_callbacks=runner_cb,
                               inventory=self.inventory,
                               extra_vars=self.inv_vars,
                               check=False)

        pr = pb.run()

        print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
Beispiel #17
0
class NetworkTest(object):
    def __init__(self, playbook):
        self.inventory = Inventory(host_list=[])
        self.playbook = playbook

        self.producer_group = Group(name='producer')
        self.inventory.add_group(self.producer_group)

        self.consumer_group = Group(name='consumer')
        self.inventory.add_group(self.consumer_group)

        self.orchestrator_group = Group(name='orchestrator')
        self.inventory.add_group(self.orchestrator_group)

        self.inv_vars = dict()

    def set_inventory_vars(self, inv_vars):
        self.inv_vars.update(inv_vars)

    def add_producer(self, producer):
        producer_host = Host(name=producer)
        self.producer_group.add_host(producer_host)

    def add_consumer(self, consumer):
        consumer_host = Host(name=consumer)
        self.consumer_group.add_host(consumer_host)

    def add_orchestrator(self, orchestrator):
        orchestrator_host = Host(name=orchestrator)
        self.orchestrator_group.add_host(orchestrator_host)

    def run(self):
        stats = AggregateStats()
        playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

        pb = playbook.PlayBook(playbook=self.playbook,
                               stats=stats,
                               callbacks=playbook_cb,
                               runner_callbacks=runner_cb,
                               inventory=self.inventory,
                               extra_vars=self.inv_vars,
                               check=False)

        pr = pb.run()

        print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
Beispiel #18
0
    def run(self):
        # insert node
        for ip in self.hosts:
            self._node_map[ip] = Service.new_node(self.task_id, ip)

        variable_manager = VariableManager()

        Logger.debug("start write ssh_key for task: {} global_id : {}".format(
            self.task_id, self.global_id))

        key_files = []

        group = Group(self.task_id)

        for h in self.hosts:

            # get ssh_key content
            key_content = _get_ssh_key(h)

            Logger.debug("read ssh_key for host: {} global_id: {}".format(
                h, self.global_id))

            # write ssh private key
            key_path = _write_ssh_key(h, key_content)

            #key_path="./tmp/97"
            Logger.debug("write ssh_key for host: {} global_id: {}".format(
                h, self.global_id))

            host_vars = dict(ansible_port=22,
                             ansible_user=self.user,
                             ansible_ssh_private_key_file="./" + key_path)

            Logger.debug("key_path: {} global_id: {}".format(
                key_path, self.global_id))

            key_files.append(key_path)

            host = Host(h)

            host.vars = host_vars

            group.add_host(host)

        # add params to each host
        if self.params is not None and isinstance(self.params, dict):
            for h in group.hosts:
                for key in self.params.keys():
                    variable_manager.set_host_variable(h, key,
                                                       self.params[key])

        Logger.debug("success write ssh_key for task: {} global_id: {}".format(
            self.task_id, self.global_id))

        # other options
        ssh_args = '-oControlMaster=auto -oControlPersist=60s -oStrictHostKeyChecking=no'
        options = _Options(connection='ssh',
                           module_path='./ansible/library',
                           forks=self.forks,
                           timeout=10,
                           remote_user=None,
                           private_key_file=None,
                           ssh_common_args=ssh_args,
                           ssh_extra_args=None,
                           sftp_extra_args=None,
                           scp_extra_args=None,
                           become=None,
                           become_method=None,
                           become_user=None,
                           verbosity=None,
                           check=False)

        if self.tasktype == "ansible_task":
            Logger.debug(
                "ansible tasks set*******************  global_id: {}".format(
                    self.global_id))
            play_source = dict(name=self.task_id,
                               hosts=self.task_id,
                               gather_facts='yes',
                               tasks=self.tasks)
        else:

            Logger.debug(
                "ansible role set******************* global_id: {}".format(
                    self.global_id))
            play_source = dict(name=self.task_id,
                               hosts=self.task_id,
                               gather_facts='yes',
                               roles=self.tasks)

        Logger.debug("start load play for task: {} global_id: {}".format(
            self.task_id, self.global_id))

        # make playbook
        playbook = Play().load(play_source,
                               variable_manager=variable_manager,
                               loader=_Loader)

        inventory = Inventory(loader=_Loader,
                              variable_manager=variable_manager)

        inventory.add_group(group)

        call_back = SyncCallbackModule(debug=True,
                                       step_callback=self._step_callback,
                                       global_id=self.global_id,
                                       source=self.source,
                                       tag_hosts=self.hosts)

        Logger.debug("success load play for task: {} global_id: {}".format(
            self.task_id, self.global_id))

        # task queue
        tqm = TaskQueueManager(inventory=inventory,
                               variable_manager=variable_manager,
                               loader=_Loader,
                               options=options,
                               passwords=None,
                               stdout_callback=call_back)

        try:
            back = tqm.run(playbook)

            Logger.info("back: {} global_id : {}".format(
                str(back), self.global_id))

            if back != 0:
                raise Exception("playbook run failed")

            return back
        finally:
            if tqm is not None:
                tqm.cleanup()
                _rm_tmp_key(key_files)
Beispiel #19
0
class MyInventory(Inventory):
    """ 
    this is my ansible inventory object. 
    """
    def __init__(self, resource, loader, variable_manager):
        """ 
        resource的数据格式是一个列表字典,比如 
            { 
                "group1": { 
                    "hosts": [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...], 
                    "vars": {"var1": value1, "var2": value2, ...} 
                } 
            } 
 
        如果你只传入1个列表,这默认该列表内的所有主机属于my_group组,比如 
            [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...] 
        """
        self.resource = resource
        self.inventory = Inventory(loader=loader,
                                   variable_manager=variable_manager,
                                   host_list=[])
        self.gen_inventory()

    def my_add_group(self, hosts, groupname, groupvars=None):
        """ 
        add hosts to a group 
        """
        my_group = Group(name=groupname)

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

        # add hosts to group
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            # set other variables
            for key, value in host.iteritems():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            # add to group
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def gen_inventory(self):
        """ 
        add hosts to inventory. 
        """
        if isinstance(self.resource, list):
            self.my_add_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.iteritems():
                self.my_add_group(hosts_and_vars.get("hosts"), groupname,
                                  hosts_and_vars.get("vars"))
Beispiel #20
0
class NetworkTest(object):
    def __init__(self, playbook):
        self.variable_manager = VariableManager()
        self.loader = DataLoader()
        self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager,host_list=[])
        self.variable_manager.set_inventory(self.inventory)
        self.playbook = playbook
        
        self.sender_group = Group(name = 'sender')
        self.inventory.add_group(self.sender_group)
        
        self.receiver_group = Group(name = 'receiver')
        self.inventory.add_group(self.receiver_group)
        
        self.master_group = Group(name = 'master')
        self.inventory.add_group(self.master_group)
        
    def set_inventory_vars(self, inv_vars):
        self.variable_manager.extra_vars = inv_vars


    def add_sender(self, sender):
        sender_host = Host(name = sender)
        self.sender_group.add_host(sender_host)


    def add_receiver(self, receiver):
        receiver_host = Host(name = receiver)
        self.receiver_group.add_host(receiver_host)

        
    def add_master(self, master):
        master_host = Host(name = master)
        self.master_group.add_host(master_host)


    def run(self):

        Options = namedtuple('Options', 
                             ['listtags', 'listtasks', 'listhosts', 
                              'syntax', 'connection', 'module_path', 
                              'forks', 'remote_user', 'private_key_file', 
                              'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 
                              'scp_extra_args', 'become', 'become_method', 
                              'become_user', 'verbosity', 'check'])
        options = Options(listtags=False, listtasks=False, listhosts=False, 
                          syntax=False, connection='ssh', module_path=None, 
                          forks=100, remote_user='******', private_key_file=None, 
                          ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, 
                          scp_extra_args=None, become=True, become_method=None, 
                          become_user='******', verbosity=None, check=False)

        passwords = {}

        pbex = PlaybookExecutor(playbooks=[self.playbook], 
                                inventory=self.inventory, 
                                variable_manager=self.variable_manager, 
                                loader=self.loader, 
                                options=options, 
                                passwords=passwords)
        results = pbex.run()
        
        print json.dumps(results, sort_keys=True, indent=4, separators=(',', ': '))
    def run(self):

        sshpass = None
        becomepass = None
        b_vault_pass = None
        passwords = {}

        # initial error check, to make sure all specified playbooks are accessible
        # before we start running anything through the playbook executor
        for playbook in self.args:
            if not os.path.exists(playbook):
                raise AnsibleError("the playbook: %s could not be found" %
                                   playbook)
            if not (os.path.isfile(playbook)
                    or stat.S_ISFIFO(os.stat(playbook).st_mode)):
                raise AnsibleError(
                    "the playbook: %s does not appear to be a file" % playbook)

        # don't deal with privilege escalation or passwords when we don't need to
        if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax:
            self.normalize_become_options()
            (sshpass, becomepass) = self.ask_passwords()
            passwords = {'conn_pass': sshpass, 'become_pass': becomepass}

        loader = DataLoader()

        if self.options.vault_password_file:
            # read vault_pass from a file
            b_vault_pass = CLI.read_vault_password_file(
                self.options.vault_password_file, loader=loader)
            loader.set_vault_password(b_vault_pass)
        elif self.options.ask_vault_pass:
            b_vault_pass = self.ask_vault_passwords()
            loader.set_vault_password(b_vault_pass)

        # create the variable manager, which will be shared throughout
        # the code, ensuring a consistent view of global variables
        variable_manager = VariableManager()
        variable_manager.extra_vars = load_extra_vars(loader=loader,
                                                      options=self.options)

        #        extra_vars = {'elastic_url':Configuration.elastic_url,
        #                      'uuid':self._job.uuid }

        variable_manager.options_vars = load_options_vars(self.options)

        # create the inventory, and filter it based on the subset specified (if any)
        inventory = Inventory(loader=loader,
                              variable_manager=variable_manager,
                              host_list=self.options.inventory)

        # added by [email protected]
        inventory.host_list = []
        inventory.host_list = self.options.inventory
        for group in self.inventoryContainer.groups:
            if group.name == 'all':
                if group.vars:
                    inventory.get_group('all').vars.update(group.vars)
            else:
                group.parent_groups.append(inventory.get_group('all'))
                inventory.get_group('all').child_groups.append(group)
                #                inventory.get_group('all').hosts.extend(group.hosts)
                #                inventory.get_group('all').vars.update(group.vars)

                inventory.add_group(group)

        variable_manager.set_inventory(inventory)

        # (which is not returned in list_hosts()) is taken into account for
        # warning if inventory is empty.  But it can't be taken into account for
        # checking if limit doesn't match any hosts.  Instead we don't worry about
        # limit if only implicit localhost was in inventory to start with.
        #
        # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts())
        no_hosts = False
        #        if len(inventory.list_hosts()) == 0:
        # Empty inventory
        #            display.warning("provided hosts list is empty, only localhost is available")
        #            no_hosts = True
        inventory.subset(self.options.subset)
        #        if len(inventory.list_hosts()) == 0 and no_hosts is False:
        # Invalid limit
        #            raise AnsibleError("Specified --limit does not match any hosts")

        # flush fact cache if requested
        if self.options.flush_cache:
            self._flush_cache(inventory, variable_manager)

        # create the playbook executor, which manages running the plays via a task queue manager
        self.pbex = PlaybookExecutor(playbooks=[playbook],
                                     inventory=inventory,
                                     variable_manager=variable_manager,
                                     loader=loader,
                                     options=self.options,
                                     passwords=passwords)

        results = self.pbex.run()
        self.apijob.stats = self.pbex._tqm._stats
        self.apijob.finished()

        if isinstance(results, list):
            for p in self.results:

                display.display('\nplaybook: %s' % p['playbook'])
                for idx, play in enumerate(p['plays']):
                    if play._included_path is not None:
                        loader.set_basedir(play._included_path)
                    else:
                        pb_dir = os.path.realpath(
                            os.path.dirname(p['playbook']))
                        loader.set_basedir(pb_dir)

                    msg = "\n  play #%d (%s): %s" % (idx + 1, ','.join(
                        play.hosts), play.name)
                    mytags = set(play.tags)
                    msg += '\tTAGS: [%s]' % (','.join(mytags))

                    if self.options.listhosts:
                        playhosts = set(inventory.get_hosts(play.hosts))
                        msg += "\n    pattern: %s\n    hosts (%d):" % (
                            play.hosts, len(playhosts))
                        for host in playhosts:
                            msg += "\n      %s" % host

                    display.display(msg)

                    all_tags = set()
                    if self.options.listtags or self.options.listtasks:
                        taskmsg = ''
                        if self.options.listtasks:
                            taskmsg = '    tasks:\n'

                        def _process_block(b):
                            taskmsg = ''
                            for task in b.block:
                                if isinstance(task, Block):
                                    taskmsg += _process_block(task)
                                else:
                                    if task.action == 'meta':
                                        continue

                                    all_tags.update(task.tags)
                                    if self.options.listtasks:
                                        cur_tags = list(
                                            mytags.union(set(task.tags)))
                                        cur_tags.sort()
                                        if task.name:
                                            taskmsg += "      %s" % task.get_name(
                                            )
                                        else:
                                            taskmsg += "      %s" % task.action
                                        taskmsg += "\tTAGS: [%s]\n" % ', '.join(
                                            cur_tags)

                            return taskmsg

                        all_vars = variable_manager.get_vars(loader=loader,
                                                             play=play)
                        play_context = PlayContext(play=play,
                                                   options=self.options)
                        for block in play.compile():
                            block = block.filter_tagged_tasks(
                                play_context, all_vars)
                            if not block.has_tasks():
                                continue
                            taskmsg += _process_block(block)

                        if self.options.listtags:
                            cur_tags = list(mytags.union(all_tags))
                            cur_tags.sort()
                            taskmsg += "      TASK TAGS: [%s]\n" % ', '.join(
                                cur_tags)

                        display.display(taskmsg)

            return 0
        else:
            return results
Beispiel #22
0
class MyInventory(Inventory):
    """
    this is my ansible inventory object.
    """
    def __init__(self, resource):
        """
        resource的数据格式是一个列表字典,比如
            {
                "group1": {
                    "hosts": [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...],
                    "vars": {"var1": value1, "var2": value2, ...}
                }
            }

        如果你只传入1个列表,这默认该列表内的所有主机属于my_group组,比如
            [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...]
        """
        self.resource = resource
        self.inventory = Inventory(host_list=[])
        self.gen_inventory()

    def my_add_group(self, hosts, groupname, groupvars=None):
        """
        add hosts to a group
        """
        my_group = Group(name=groupname)

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

        # add hosts to group
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            ssh_key = host.get("ssh_key")
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            # set other variables 
            for key, value in host.iteritems():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)
            # add to group
            my_group.add_host(my_host)

        self.inventory.add_group(my_group)

    def gen_inventory(self):
        """
        add hosts to inventory.
        """
        if isinstance(self.resource, list):
            self.my_add_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, hosts_and_vars in self.resource.iteritems():
                self.my_add_group(hosts_and_vars.get("hosts"), groupname, hosts_and_vars.get("vars"))
Beispiel #23
0
def runInv(request, **kwargs):
    # Constants
    C.HOST_KEY_CHECKING = False

    template = JobTemplates.objects.get(pk=kwargs['pk'])
    hostobjects = Hosts.objects.filter(inventory=template.inventory.pk)
    inventoryName = template.inventory.name
    inventory = Inventory()

    # TODO: need to implement groups functionality
    #Groups
    #group = Group(inventoryName)
    group = Group('mygroup')

    for hostobj in hostobjects:
        # Host defining
        hostname = hostobj.name
        port = hostobj.port
        ip = hostobj.ipAddress
        username = hostobj.username
        password = hostobj.password
        host = Host(hostname)
        if ip:
            host.set_variable('ansible_ssh_host', ip)
        elif port:
            host.set_variable('ansible_ssh_port', port)
        host.set_variable('ansible_ssh_user', username)
        host.set_variable('ansible_ssh_pass', password)
        # Hostvars
        hostvars = yaml.load(hostobj.variables)
        if hostvars:
            host.vars.update(hostvars)
        group.add_host(host)

    inventory.add_group(group)



    # ExtraVars
    extraVars = yaml.load(template.extra_variables)

    # Callbacks
    utils.VERBOSITY = 3
    playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
    stats = callbacks.AggregateStats()
    runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)
    #runner_cb = myCustCallback(stats, template.pk, verbose=utils.VERBOSITY)

    # Playbook gathering
    playbookPath = os.path.join(template.project.directory, template.playbook)

    # Playbook run
    pb = PlayBook(
        playbook=playbookPath,
        host_list=None,
        inventory=inventory,     # Our hosts, the rendered inventory file
        #remote_user='******',
        #remote_pass='******',
        callbacks=playbook_cb,
        runner_callbacks=runner_cb,
        stats=stats,
        extra_vars=extraVars,
        #private_key_file='/path/to/key.pem'
    )
    pb.run()

    return HttpResponseRedirect(reverse('jobtemplates:index'))
class ResourceBase(object):
    """
    gen_inventory methods.

    Attributes:
        resource: the inventory's resource. format:
                    {
                        "group1": {
                            "hosts": [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...],
                            "vars": {"var1": value1, "var2": value2, ...}
                        }
                    }
                  if your pass a list, the list will add the default group(default_group)
                    [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...]
        inventory: ansible inventory object use gen_inventory to generate.
    Methods:
        gen_inventory: generate a ansible inventory object.
    """

    def __init__(self, resource):
        self.inventory = Inventory(host_list=[])
        self.resource = resource
        self.gen_inventory()

    @staticmethod
    def add_group_vars(group, group_vars=None):
        """
        if group_vars exists then, add group variable to group

        Args:
            group: <ansible group object> ansible group object
            group_vars: <dict> group variables
        """
        assert isinstance(group, Group), "the group must be an ansible group object."

        if group_vars:
            for key, value in group_vars.iteritems():
                group.set_variable(key, value)

    @staticmethod
    def gen_hosts(hosts=None):
        """
        if host_vars exists then, generate hosts

        Args:
             hosts: <list> [<host variable dict>, <host variable dict>, ...]
        Returns:
             host_objs: <list> [<host object>, <host object>, ...]
        """
        assert isinstance(hosts, list), "the hosts must be a list"
        host_objs = []
        if hosts:
            for host in hosts:
                hostname = host.get("hostname")
                hostip = host.get('ip', hostname)
                hostport = host.get("port")
                username = host.get("username")
                password = host.get("password")
                ssh_key = host.get("ssh_key")

                my_host = Host(name=hostname, port=hostport)
                my_host.set_variable('ansible_ssh_host', hostip)
                my_host.set_variable('ansible_ssh_port', hostport)
                my_host.set_variable('ansible_ssh_user', username)

                if password:
                    my_host.set_variable('ansible_ssh_pass', password)
                if ssh_key:
                    my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

                # set other variables
                for key, value in host.iteritems():
                    if key not in ["hostname", "port", "username", "password", "ip", "ssh_key"]:
                        my_host.set_variable(key, value)
                host_objs.append(my_host)
        return host_objs

    def my_add_group(self, hosts_vars, group_name, group_vars=None):
        """
        add hosts to group. use to generate a inventory.

        Args:
            hosts_vars: the hosts variables
            group_name: group name
            group_vars: group variables
        """
        my_group = Group(name=group_name)
        self.add_group_vars(my_group, group_vars)
        for host in self.gen_hosts(hosts_vars):
            my_group.add_host(host)
        self.inventory.add_group(my_group)

    def gen_inventory(self):
        """
        add hosts to an inventory.
        """
        if isinstance(self.resource, list):
            self.my_add_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for group_name, hosts_vars in self.resource.iteritems():
                self.my_add_group(hosts_vars.get("hosts"), group_name, hosts_vars.get("vars"))
Beispiel #25
0
def playbook(**kwargs):
    group_vars = kwargs['group_vars']
    groups = kwargs['groups']
    host_list = kwargs['host_list']
    playbook_basedir = os.sep.join(
        [ANSIBLE_PLAYBOOK_PATH, kwargs['playbook_basedir']])
    playbooks = []
    for pb in kwargs['playbooks']:
        playbooks.append(os.sep.join([playbook_basedir, pb]))

    job_id = kwargs['job_id']
    loader = DataLoader()
    vars = VariableManager()
    # 指定inventory为一个目录,设置所有主机,包含group和host
    invertory = Inventory(loader, vars, host_list=host_list)

    invertory.set_playbook_basedir(playbook_basedir)
    for group_name, hosts in groups.items():
        t_group = Group(group_name)
        for host in hosts:
            t_host = Host(host)
            t_group.add_host(t_host)
        invertory.add_group(t_group)

    vars.set_inventory(invertory)
    display = LogDisplay(logname=job_id)
    callback = CALLBACKMODULE[CALLBACK](display=display)
    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',
        'listtags', 'listtasks', 'syntax'
    ])

    options = Options(connection='smart',
                      module_path='/usr/share/ansible',
                      forks=100,
                      timeout=10,
                      remote_user='******',
                      ask_pass=False,
                      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='******',
                      ask_value_pass=False,
                      verbosity=None,
                      check=False,
                      listhosts=None,
                      listtags=None,
                      listtasks=None,
                      syntax=None)

    passwords = dict()
    pb_executor = PlaybookExecutor(playbooks, invertory, vars, loader, options,
                                   passwords)
    pb_executor._tqm._stdout_callback = callback
    pb_executor.run()
    return display.get_log_json()
Beispiel #26
0
def handle():
    host1 = Host("127.0.0.1")

    host1.vars = dict(ansible_port=22,
                      ansible_user="******",
                      ansible_ssh_private_key_file="../tmp/127.0.0.1")

    # none variable
    variable_manager = VariableManager()

    g = Group("group_wb")
    g.add_host(host1)

    # target ip list
    inventory = Inventory(loader=loader, variable_manager=variable_manager)

    inventory.add_group(g)

    # other options

    options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh',
                      module_path=None, forks=1,
                      remote_user='******', ssh_common_args=None,
                      ssh_extra_args=None,
                      sftp_extra_args=None, scp_extra_args=None, become=False, become_method=None,
                      become_user="******",
                      verbosity=None, check=False)

    tqm = TaskQueueManager(
        inventory=inventory,
        variable_manager=variable_manager,
        loader=loader,
        options=options,
        passwords=None
    )

    # test tasks
    task0 = dict(action=dict(module='shell', args='sleep 6'))
    task1 = dict(action=dict(module='shell', args='ls'))
    task2 = dict(action=dict(module='shell', args='echo "2333"'))

    play_source = dict(
        name="Test Play",
        hosts="group_wb",
        gather_facts='no',
        tasks=[
            task0, task1, task2
        ]
    )

    play = Play().load(play_source, variable_manager=variable_manager, loader=loader)

    try:
        result = tqm.run(play)

        print("Result code: " + str(result))
        print("Type: " + str(type(result)))

    # close queue manager
    finally:
        if tqm is not None:
            tqm.cleanup()
Beispiel #27
0
class ResourceBase(object):
    """
    generate inventory

    :param resource: inventory resource, format:
        {
            "hosts" : {
                "host1": {"port": "22", "username": "******", "password": "******"},
                "host2": {"port": "22", "username": "******", "password": "******"},
            },
            "groups": {
                "group1": {"hosts": ["host1", "host2",...], "vars": {'var1':'xxxx', 'var2':'yyy',...} },
                "group2": {"hosts": ["host1", "host2",...], "child": ["group1"], "vars": {'var1':'xxxx', 'var2':'yyy',...} },
            }
        }
    """
    def __init__(self, resource=None):
        host_list = not resource and ANS_CONS.DEFAULT_HOST_LIST or []
        self.loader = DataLoader()
        self.variable_manager = VariableManager()
        self.resource = resource
        self.inventory = Inventory(loader=self.loader,
                                   variable_manager=self.variable_manager,
                                   host_list=host_list)
        #resource and self.gen_inventory()
        self.gen_inventory()

    @staticmethod
    def gen_host(host_name=None, host_vars=None):
        """
        Generate ansible Host object
        :param host_name: <string> ansible inventory hostname
        :param host_vars: <dict> host variables
        :return: Host object
        """
        if host_vars is None:
            host_vars = {}
        ssh_host = host_vars.get('ip', host_name)
        ssh_port = host_vars.get('port', ANS_CONS.DEFAULT_REMOTE_PORT)
        ssh_user = host_vars.get('username')
        ssh_pass = host_vars.get('password')
        ssh_fkey = host_vars.get('ssh_key')
        # init Host
        host = Host(name=host_name, port=ssh_port)
        host.set_variable('ansible_ssh_host', ssh_host)
        # shortcut variables
        ssh_user and host.set_variable('ansible_ssh_user', ssh_user)
        ssh_pass and host.set_variable('ansible_ssh_pass', ssh_pass)
        ssh_fkey and host.set_variable('ansible_private_key_file', ssh_fkey)
        # extra variables
        for key, value in host_vars.items():
            if key not in ['ip', 'port', 'username', 'password', 'ssh_key']:
                host.set_variable(key, value)
        # return Host object
        return host

    @staticmethod
    def gen_group(group_name=None, group_vars=None):
        """
        Generate ansible Group object
        :param group_name: <string> Group Name
        :param group_vars: <dict> Group Variables
        :return: ansible Group object
        """
        if group_vars is None:
            group_vars = {}
        group = Group(name=group_name)
        for key, value in group_vars.items():
            group.set_variable(key, value)
        return group

    def gen_inventory(self):
        """
        :return: None
        """
        # set hosts
        if 'hosts' in self.resource.keys():
            for host, info in self.resource['hosts'].items():
                obj_host = self.gen_host(host, info)
                self.inventory.get_group('all').add_host(obj_host)
        # add group
        if 'groups' in self.resource.keys():
            for group, detail in self.resource['groups'].items():
                obj_group = self.gen_group(group, detail.get('vars', {}))
                for host in detail.get('hosts', []):
                    obj_group.add_host(self.inventory.get_host(host))
                if 'child' in detail.get('child', []):
                    for child in detail.get('child', []):
                        obj_group.add_child_group(
                            self.inventory.get_group(child))
                self.inventory.add_group(obj_group)

    def get_lists(self):
        print("Host: ")
        print("=================")
        for host in self.inventory.list_hosts():
            print(host)
        print("Group: ")
        print("=================")
        for group in self.inventory.list_groups():
            print(group)
Beispiel #28
0
# -*-coding:utf-8 -*-
Beispiel #29
0
class Runner(object):
    def __init__(self, groups, playbook, private_key_file, display, become_pass={}, extraVars={}):
        self.extraVars = extraVars

        self.options = Options()
        self.options.private_key_file = private_key_file
        self.options.verbosity = display.verbosity
        self.options.connection = 'ssh'  # Need a connection type 'smart' or 'ssh'
        self.options.become = True
        self.options.become_method = 'sudo'
        self.options.become_user = '******'

        # Executor appears to have it's own
        # verbosity object/setting as well
        playbook_executor.verbosity = self.options.verbosity

        # Become Pass Needed if not logging in as user root
        passwords = {'become_pass':become_pass}

        # Gets data from YAML/JSON files
        self.loader = DataLoader()
        self.loader.set_vault_password(os.environ.get('VAULT_PASS', 'xiaoy_pandan'))

        # All the variables from all the various places
        self.variable_manager = VariableManager()
        self.variable_manager.extra_vars = self.extraVars

        # Set inventory, using most of above objects
        self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=[])
        self.variable_manager.set_inventory(self.inventory)

        # Set groups info
        for info in groups:
            group = Group(info['name'])
            self.inventory.add_group(group)

            hostInfos = info.get('hosts')
            for hostInfo in hostInfos:
                hostname = hostInfo.get('hostname')
                hostip = hostInfo.get('ip', hostname)
                hostport = hostInfo.get('port')
                username = hostInfo.get('username')
                password = hostInfo.get('password')
                ssh_key = hostInfo.get('ssh_key')
                host = Host(name=hostname, port=hostport)
                host.set_variable('ansible_ssh_host', hostip)
                host.set_variable('ansible_ssh_port', hostport)
                host.set_variable('ansible_ssh_user', username)
                host.set_variable('ansible_ssh_pass', password)
                host.set_variable('ansible_ssh_private_key_file', ssh_key)
                for key, value in hostInfo.iteritems():
                    if key not in ['hostname', 'port', 'username', 'password', 'ssh_key']:
                        host.set_variable(key, value)
                group.add_host(host)

            varInfos = info.get('vars')
            if varInfos:
                for key, value in varInfos.iteritems():
                    group.set_variable(key, value)

        # Playbook to run. Assumes it is
        # local to this python file
        pb_dir = os.path.dirname(__file__)
        playbook = '%s/%s' % (pb_dir, playbook)

        # Setup playbook executor, but don't run until run() called
        self.pbex = playbook_executor.PlaybookExecutor(
            playbooks=[playbook],
            inventory=self.inventory,
            variable_manager=self.variable_manager,
            loader=self.loader,
            options=self.options,
            passwords=passwords)
        self.display = display
        self.callback = CallbackModule(self.display)
        self.pbex._tqm._stdout_callback = self.callback

    def run(self):
        # Results of PlaybookExecutor
        self.pbex.run()

        # calc result
        result = True
        hostResults = {}
        stats = self.pbex._tqm._stats
        hosts = sorted(stats.processed.keys())
        for h in hosts:
            t = stats.summarize(h)
            if t['unreachable'] > 0 or t['failures'] > 0:
                hostResult = result = False
            else:
                hostResult = True
            hostResults[h] = hostResult

        if result:
            self.display.display('success')
        else:
            self.display.display('fail', stderr=True)
        self.display.display('')

        return result, hostResults
Beispiel #30
0
    def run_ansible_on_host(host, logger, config):
        from ansible.plugins.callback import CallbackBase

        # A rough logger that logs dict messages to standard logger

        class ResultCallback(CallbackBase):
            def __init__(self):
                super(ResultCallback, self).__init__()

            def v2_runner_on_ok(self, result, **kwargs):
                self.log('ok :' + str(result._result), info=True)

            def v2_runner_on_failed(self, result, **kwargs):
                self.log(result._result, info=True)

            def v2_runner_on_skipped(self, result, **kwargs):
                self.log(result._result, info=True)

            def v2_runner_on_unreachable(self, result, **kwargs):
                self.log(result._result, info=True)

            def v2_playbook_on_no_hosts_matched(self, *args, **kwargs):
                self.log('no hosts matched!')

            def v2_playbook_on_no_hosts_remaining(self, *args, **kwargs):
                self.log('NO MORE HOSTS LEFT')

            def v2_playbook_on_task_start(self, task, **kwargs):
                self.log('starting task: ' + str(task))

            def v2_playbook_on_start(self, playbook, **kwargs):
                self.log('starting playbook' + str(playbook), info=True)

            def v2_playbook_on_play_start(self, play, **kwargs):
                self.log('starting play' + str(play), info=True)

            def v2_playbook_on_stats(self, stats, info=True, **kwargs):
                self.log('STATS FOR PLAY')
                hosts = sorted(stats.processed.keys())
                hosts.extend(stats.failures.keys())
                hosts.extend(stats.dark.keys())
                hosts.extend(stats.changed.keys())
                hosts.extend(stats.skipped.keys())
                hosts.extend(stats.ok.keys())
                for h in hosts:
                    t = stats.summarize(h)
                    self.log(str(t))

            def log(self, param, info=False):
                if not info:
                    logger.debug(str(param))
                else:
                    logger.info(str(param))

        from ansible.parsing.dataloader import DataLoader
        from ansible.inventory import Inventory, Group, Host
        from ansible.executor import playbook_executor
        from ansible.vars import VariableManager
        from collections import namedtuple

        Options = namedtuple('Options', [
            'connection', 'module_path', 'forks', 'become', 'become_method',
            'become_user', 'check', 'ansible_user', 'listhosts', 'listtasks',
            'listtags', 'syntax', 'ssh_private_key_file', 'host_key_checking'
        ])

        options = Options(connection='ssh',
                          become=True,
                          become_method='sudo',
                          become_user='******',
                          check=False,
                          module_path=None,
                          forks=100,
                          ansible_user='******',
                          listhosts=False,
                          listtasks=False,
                          listtags=False,
                          syntax=False,
                          ssh_private_key_file=PEBBLES_SSH_KEY_LOCATION,
                          host_key_checking=False)

        variable_manager = VariableManager()
        loader = DataLoader()

        a_host = Host(name=host['private_ip'])
        a_host.set_variable('ansible_host', host['private_ip'])
        a_group = Group(name='notebook_host')
        a_group.add_host(a_host)
        inventory = Inventory(loader=loader,
                              variable_manager=variable_manager,
                              host_list=[host['private_ip']])
        inventory.add_group(a_group)
        variable_manager.set_inventory(inventory)
        logger.debug('HOST:')
        logger.debug(a_host.serialize())
        logger.debug('HOSTs from inventory:')
        # for some reason setting these before adding the host to inventory didn't work so well
        # ToDo: read up on variable_manager and figure out a more elegant way to set the variables
        for h_ in inventory.get_hosts():
            h_.set_variable('ansible_user', 'cloud-user')
            h_.set_variable('ansible_ssh_common_args',
                            '-o StrictHostKeyChecking=no')
            h_.set_variable('ansible_ssh_private_key_file',
                            '/home/pebbles/.ssh/id_rsa')
        extra_vars = dict()
        extra_vars['ansible_ssh_extra_args'] = '-o StrictHostKeyChecking=no'

        if 'DD_HOST_DATA_VOLUME_DEVICE' in config:
            extra_vars['notebook_host_block_dev_path'] = config[
                'DD_HOST_DATA_VOLUME_DEVICE']

        variable_manager.extra_vars = extra_vars
        pb_executor = playbook_executor.PlaybookExecutor(
            playbooks=[
                '/webapps/pebbles/source/ansible/notebook_playbook.yml'
            ],
            inventory=inventory,
            variable_manager=variable_manager,
            loader=loader,
            options=options,
            passwords=None)
        rescb = ResultCallback()
        pb_executor._tqm._stdout_callback = rescb

        logger.info('_prepare_host(): running ansible')
        logger.info('_prepare_host(): inventory hosts')
        for h_ in inventory.get_hosts():
            logger.info(h_.serialize())
            logger.info(h_.get_vars())
        pb_executor.run()
        stats = pb_executor._tqm._stats
        run_success = True
        hosts_list = sorted(stats.processed.keys())
        if len(hosts_list) == 0:
            logger.debug('no hosts handled')
        for h in hosts_list:
            t = stats.summarize(h)
            logger.debug(t)
            logger.debug(h)
            if t['unreachable'] > 0 or t['failures'] > 0:
                run_success = False
        if run_success:
            logger.debug('_prepare_host(): run successfull')
        else:
            logger.debug('_prepare_host(): run failed')
        if getattr(pb_executor, '_unreachable_hosts', False):
            logger.debug('UNREACHABLE HOSTS ' +
                         str(pb_executor._unreachable_hosts))
        if getattr(pb_executor, '_failed_hosts', False):
            logger.debug('FAILED_HOSTS ' + str(pb_executor._failed_hosts))
            raise RuntimeError('run_ansible_on_host(%s) failed' % host['id'])
        logger.debug('_prepare_host():  done running ansible')
Beispiel #31
0
class AnsibleInventoryManager():
    """Class to handle the ansible inventory file.
    This class will allow you to add groups/hosts and remove them from the inventory file"""
    #FROM http://www.ansibleworks.com/docs/patterns.html
    ALLOWED_VARIABLES = ['ansible_ssh_host',
                         'ansible_ssh_port',
                         'ansible_ssh_user',
                         'ansible_ssh_pass',
                         'ansible_connection',
                         'ansible_ssh_private_key_file',
                         'ansible_syslog_facility',
                         'ansible_python_interpreter',
                         ]
    # NOTE:Works for anything such as ruby or perl and works just like
    # ansible_python_interpreter.
    # This replaces shebang of modules which will run on that host.

    def __init__(self, inventory_file="/etc/ansible/hosts"):
        self.__inventory_file = inventory_file
        self.__dirty = False
        if not os.path.exists(self.__inventory_file):
            raise AnsibleInventoryManagerFileNotFound("File: %s Not found or not accessible" % self.__inventory_file)
        self.__inventory = Inventory(inventory_file)

    def get_hosts(self):
        """return the list of hosts
        Returns a list host ips"""
        host_list = [host.name for host in self.__inventory.get_hosts()]
        return host_list

    def get_groups(self):
        """return the groups
        Returns a list of objects: ansible.inventory.group.Group"""
        return self.__inventory.get_groups()

    def get_groups_for_host(self,host):
        """return the groups list where the given host appears"""
        return self.__inventory.groups_for_host(host)

    def get_group(self, groupname):
        """Returns the given group"""
        return self.__inventory.get_group(groupname)

    def delete_host(self,host_ip,group=""):
        """Removes a host from a given group
        if group is empty, removes the host from all the groups
        """
        self.__dirty = True
        groups = []
        if group == "":
            groups = [group.name for group in self.get_groups_for_host(host_ip)]
        else:
            groups.append(group)
        for group in groups:
            grp = self.__inventory.get_group(group)
            new_host_list = [host for host in grp.get_hosts() if host.name != host_ip]
            grp.hosts = new_host_list

    def add_host(self, host_ip, add_to_root=True, group_list=[], var_list={}):
        """Add a host ip to the ansible host file
        This is a simple function to add hosts to
        add_to_root = Adds the host to the root group (unnamed)
        groups_list: List of groupnames where the host should appears.
        var_list: Variable list. see allowed_variables."""
        #root group in unnamed, but in the inventory object
        # is the 'ungrouped' group
        self.__dirty = True
        new_host = Host(host_ip)
        for key,value in var_list.iteritems():
            if self.is_allowed_variable(key):
                new_host.set_variable(key,value)
        if add_to_root:
            if 'ungrouped' not in group_list:
                group_list.append('ungrouped')

        #Check groups. The ansible inventory should contain each of the groups.
        for group in group_list:
            if not self.__inventory.get_group(group):
                new_group= Group(group)
                self.__inventory.add_group(new_group)
            grp = self.__inventory.get_group(group)
            host_names = [host.name for host in grp.get_hosts()]
            if new_host.name not in host_names:
                grp.add_host(new_host)

    def is_dirty(self):
        return self.__dirty

    def is_allowed_variable(self, variable):
        """Checks if the given variable is an allowed variable"""
        if variable in self.ALLOWED_VARIABLES:
            return True
        elif re.match("ansible_(.+)_interpreter", variable):
            return True
        return False

    def save_inventory(self, backup_file=""):
        """Saves the inventory file. If a backup_file is given,
        a backup will be done before re-write the file"""

        try:
            if backup_file != "":
                copyfile(self.__inventory_file, backup_file)
            data = ""
            for group in self.__inventory.get_groups():
                ingroup = False
                if group.name == "all":
                    continue
                elif group.name != "ungrouped":
                    data += "[%s]\n" % group.name
                    ingroup = True
                strvars = ""
                for host in group.get_hosts():
                    for key, value in host.get_variables().iteritems():
                        if key in AnsibleInventoryManager.ALLOWED_VARIABLES:
                            strvars += "%s=%s    " % (key, value)
                    if ingroup:
                        data += "\t%s\t%s\n" % (host.name, strvars)
                    else:
                        data += "%s\t%s\n" % (host.name, strvars)
            ansiblehostfile = open(self.__inventory_file, "w")
            ansiblehostfile.write(data)
            ansiblehostfile.close()
        except Exception, e:
            error("Error doing the %s backup: %s" % (self.__inventory_file, str(e)))
Beispiel #32
0
class MyInventory(Inventory):
    """
    this is my ansible inventory object.
    """
    def __init__(self, resource, loader, variable_manager):
        """
        ansible inventory object
        :param resource: 一个列表字典,如
            {
                "group1": {
                    "hosts": [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...],
                    "vars": {"var1": value1, "var2": value2, ...}
                }
            }
            如果只传入1个列表,这默认该列表内的所有主机属于 my_group 组,比如
            [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...]
        :param loader:
        :param variable_manager:
        """
        self.resource = resource
        self.inventory = Inventory(loader=loader,
                                   variable_manager=variable_manager,
                                   host_list=[])
        self.dynamic_inventory()

    def add_dynamic_group(self, hosts, groupname, groupvars=None):
        """
        add hosts to a group
        :param hosts:
        :param groupname:
        :param groupvars:
        :return:
        """
        my_group = Group(name=groupname)

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

        # add hosts to group
        for host in hosts:
            # set connection variables
            hostname = host.get("hostname")
            hostip = host.get('ip', hostname)
            hostport = host.get("port")
            username = host.get("username")
            password = host.get("password")
            if username == 'root':
                keyfile = "/root/.ssh/id_rsa"
            else:
                keyfile = "/home/{user}/.ssh/id_rsa".format(user=username)
            ssh_key = host.get("ssh_key", keyfile)
            my_host = Host(name=hostname, port=hostport)
            my_host.set_variable('ansible_ssh_host', hostip)
            my_host.set_variable('ansible_ssh_port', hostport)
            my_host.set_variable('ansible_ssh_user', username)
            my_host.set_variable('ansible_ssh_pass', password)
            my_host.set_variable('ansible_ssh_private_key_file', ssh_key)

            # set other variables
            for key, value in host.iteritems():
                if key not in ["hostname", "port", "username", "password"]:
                    my_host.set_variable(key, value)

            # add to group
            my_group.add_host(my_host)
        self.inventory.add_group(my_group)

    def dynamic_inventory(self):
        """
        add hosts to inventory.
        :return:
        """
        if isinstance(self.resource, list):
            self.add_dynamic_group(self.resource, 'default_group')
        elif isinstance(self.resource, dict):
            for groupname, host_and_vars in self.resource.iteritems():
                self.add_dynamic_group(host_and_vars.get("hosts"), groupname,
                                       host_and_vars.get("vars"))
    def run_ansible_on_host(host, logger, driver_config):
        from ansible.plugins.callback import CallbackBase
        # A rough logger that logs dict messages to standard logger

        class ResultCallback(CallbackBase):

            def __init__(self):
                super(ResultCallback, self).__init__()

            def v2_runner_on_ok(self, result, **kwargs):
                self.log('ok :' + str(result._result))

            def v2_runner_on_failed(self, result, **kwargs):
                warnings = result._result['warnings']
                error = result._result['stderr']
                if warnings:
                    self.log('warning : ' + str(result._result))
                elif error:
                    self.log('error : ' + str(result._result), info=True)

            def v2_runner_on_skipped(self, result, **kwargs):
                self.log('skipped : ' + str(result._result))

            def v2_runner_on_unreachable(self, result, **kwargs):
                self.log('unreachable : ' + str(result._result), info=True)

            def v2_playbook_on_no_hosts_matched(self, *args, **kwargs):
                self.log('no hosts matched!')

            def v2_playbook_on_no_hosts_remaining(self, *args, **kwargs):
                self.log('NO MORE HOSTS LEFT')

            def v2_playbook_on_task_start(self, task, **kwargs):
                self.log('starting task: ' + str(task))

            def v2_playbook_on_start(self, playbook, **kwargs):
                self.log('starting playbook' + str(playbook), info=True)

            def v2_playbook_on_play_start(self, play, **kwargs):
                self.log('starting play' + str(play), info=True)

            def v2_playbook_on_stats(self, stats, info=True, **kwargs):
                self.log('STATS FOR PLAY')
                hosts = sorted(stats.processed.keys())
                hosts.extend(stats.failures.keys())
                hosts.extend(stats.dark.keys())
                hosts.extend(stats.changed.keys())
                hosts.extend(stats.skipped.keys())
                hosts.extend(stats.ok.keys())
                for h in hosts:
                    t = stats.summarize(h)
                    self.log(str(t))

            def log(self, param, info=False):
                if not info:
                    logger.debug(str(param))
                else:
                    logger.info(str(param))

        from ansible.parsing.dataloader import DataLoader
        from ansible.inventory import Inventory, Group, Host
        from ansible.executor import playbook_executor
        from ansible.vars import VariableManager
        from collections import namedtuple

        Options = namedtuple(
            'Options',
            [
                'connection',
                'module_path',
                'forks',
                'become',
                'become_method',
                'become_user',
                'check',
                'ansible_user',
                'listhosts',
                'listtasks',
                'listtags',
                'syntax',
                'ssh_private_key_file',
                'host_key_checking'
            ]
        )

        options = Options(
            connection='ssh',
            become=True,
            become_method='sudo',
            become_user='******',
            check=False,
            module_path=None,
            forks=100,
            ansible_user='******',
            listhosts=False,
            listtasks=False,
            listtags=False,
            syntax=False,
            ssh_private_key_file=PEBBLES_SSH_KEY_LOCATION,
            host_key_checking=False
        )

        variable_manager = VariableManager()
        loader = DataLoader()

        a_host = Host(name=host['private_ip'])
        a_host.set_variable('ansible_host', host['private_ip'])
        a_group = Group(name='notebook_host')
        a_group.add_host(a_host)
        inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[host['private_ip']])
        inventory.add_group(a_group)
        variable_manager.set_inventory(inventory)
        logger.debug('HOST:')
        logger.debug(a_host.serialize()	)
        logger.debug('HOSTs from inventory:')
        # for some reason setting these before adding the host to inventory didn't work so well
        # ToDo: read up on variable_manager and figure out a more elegant way to set the variables
        for h_ in inventory.get_hosts():
            h_.set_variable('ansible_user', 'cloud-user')
            h_.set_variable('ansible_ssh_common_args', '-o StrictHostKeyChecking=no')
            h_.set_variable('ansible_ssh_private_key_file', '/home/pebbles/.ssh/id_rsa')
        extra_vars = dict()
        extra_vars['ansible_ssh_extra_args'] = '-o StrictHostKeyChecking=no'

        logger.debug('Setting driver config....')
        if 'DD_HOST_DATA_VOLUME_DEVICE' in driver_config:
            extra_vars['notebook_host_block_dev_path'] = driver_config['DD_HOST_DATA_VOLUME_DEVICE']
        variable_manager.extra_vars = extra_vars
        pb_executor = playbook_executor.PlaybookExecutor(
            playbooks=['/webapps/pebbles/source/ansible/notebook_playbook.yml'],
            inventory=inventory,
            variable_manager=variable_manager,
            loader=loader,
            options=options,
            passwords=None
        )
        rescb = ResultCallback()
        pb_executor._tqm._stdout_callback = rescb

        logger.info('_prepare_host(): running ansible')
        logger.info('_prepare_host(): inventory hosts')
        for h_ in inventory.get_hosts():
            logger.info(h_.serialize())
            logger.info(h_.get_vars())
        pb_executor.run()
        stats = pb_executor._tqm._stats
        run_success = True
        hosts_list = sorted(stats.processed.keys())
        if len(hosts_list) == 0:
            logger.debug('no hosts handled')
        for h in hosts_list:
            t = stats.summarize(h)
            logger.debug(t)
            logger.debug(h)
            if t['unreachable'] > 0 or t['failures'] > 0:
                run_success = False
        if run_success:
                logger.debug('_prepare_host(): run successfull')
        else:
                logger.debug('_prepare_host(): run failed')
        if getattr(pb_executor, '_unreachable_hosts', False):
            logger.debug('UNREACHABLE HOSTS ' + str(pb_executor._unreachable_hosts))
        if getattr(pb_executor, '_failed_hosts', False):
            logger.debug('FAILED_HOSTS ' + str(pb_executor._failed_hosts))
            raise RuntimeError('run_ansible_on_host(%s) failed' % host['id'])
        logger.debug('_prepare_host():  done running ansible')