def run(self, terms, inject=None, **kwargs): terms = utils.listify_lookup_plugin_terms(terms, self.basedir, inject) if not isinstance(terms, list): raise errors.AnsibleError( "with_inventory_hostnames expects a list") return flatten(inventory.Inventory(self.host_list).list_hosts(terms))
def prepare_runner(self, _playbook_path, options={}, tasks=None, _extra_vars={}, verbosity=3): _OPTIONS = self.__prepare_runner_metadata(options, tasks) _vb = _OPTIONS['verbosity'] _inventory = inventory.Inventory(self.HOSTS_INI_FILE) stats = callbacks.AggregateStats() playbook_cb = callbacks.PlaybookCallbacks(verbose=_vb) runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=_vb) runner = playbook.PlayBook( playbook=_playbook_path, inventory=_inventory, extra_vars=_extra_vars, private_key_file=self.PRIVATE_KEY, #vault_password=vaultpass, only_tags=tasks, stats=stats, callbacks=playbook_cb, runner_callbacks=runner_cb) return runner
def scan_inventory(path): """ Given an infrasim inventory path, analyze all host and group in dict. """ dict_group = {} for one_type in node_type: dict_group[one_type] = [] global ssh_username global ssh_password global hosts variable_manager = VariableManager() loader = DataLoader() inv = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=path) groups = inv.get_groups() for g in groups: group = groups[g] if group.name in node_type: hosts = group.get_hosts() for host in hosts: dict_group[group.name].append(host.name) elif group.name == full_group: vars = group.get_vars() ssh_username = vars["ansible_become_user"] ssh_password = vars["ansible_become_pass"] hosts = dict_group return
def HostsList(): """ :rtype: object """ hosts = [] a = inventory.Inventory() a= AnsibleV1Inv.get_inv() data = a.list_hosts() # data example # ['192.168.233.129', '192.168.233.131', '192.168.0.211'] #data = a.list_hosts() # groups example # {'ungrouped': [], # 'all': ['192.168.233.129', '192.168.233.131', '192.168.0.211'], # 'vmware': ['192.168.233.129', '192.168.233.131'], # 'atom': ['192.168.0.211']} groups = a.groups_list() for i in range(len(data)): group = search(groups,data[i]) try: host = { 'id': hosts[-1]['id'] + 1, 'host': str(data[i]), 'groups': group } except: host = { 'id': 1, 'host': data[i], 'groups': group } hosts.append(host) return hosts
def run_module(self, module_name='ping', module_args=None, hosts="all", inventory_file=None, **kwargs): if not module_args: check_raw = module_name in ('command', 'win_command', 'shell', 'win_shell', 'script', 'raw') module_args = parse_kv(constants.DEFAULT_MODULE_ARGS, check_raw) conn_pass = None if 'conn_pass' in kwargs: conn_pass = kwargs['conn_pass'] become_pass = None if 'become_pass' in kwargs: become_pass = kwargs['become_pass'] passwords = {'conn_pass': conn_pass, 'become_pass': become_pass} options = self._build_opt_dict(inventory_file, **kwargs) variable_manager = vars.VariableManager() loader = dataloader.DataLoader() variable_manager.extra_vars = options.extra_vars ansible_inv = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=options.inventory) variable_manager.set_inventory(ansible_inv) ansible_inv.subset(options.subset) play_ds = self._play_ds(hosts, module_name, module_args) play_obj = play.Play().load(play_ds, variable_manager=variable_manager, loader=loader) try: tqm = task_queue_manager.TaskQueueManager( inventory=ansible_inv, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback='minimal', run_additional_callbacks=True ) # There is no public API for adding callbacks, hence we use a # private property to add callbacks tqm._callback_plugins.extend(self._callbacks) result = tqm.run(play_obj) finally: if tqm: tqm.cleanup() if loader: loader.cleanup_all_tmp_files() stats = tqm._stats result = self._process_stats(stats) return result
def run_playbook(self, playbook_file, inventory_file=None, **kwargs): reload(constants) if not os.path.isfile(playbook_file): raise exceptions.FileNotFound(name=playbook_file) if inventory_file is None: inventory_file = self.inventory_file LOG.debug('Running with inventory file: %s', inventory_file) LOG.debug('Running with playbook file: %s', playbook_file) conn_pass = None if 'conn_pass' in kwargs: conn_pass = kwargs['conn_pass'] become_pass = None if 'become_pass' in kwargs: become_pass = kwargs['become_pass'] passwords = {'conn_pass': conn_pass, 'become_pass': become_pass} playbooks = [playbook_file] options = self._build_opt_dict(inventory_file, **kwargs) variable_manager = vars.VariableManager() loader = dataloader.DataLoader() options.extra_vars = {six.u(key): six.u(value) for key, value in options.extra_vars.items()} variable_manager.extra_vars = options.extra_vars ansible_inv = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=options.inventory) ansible_inv.set_playbook_basedir(os.path.dirname(playbook_file)) variable_manager.set_inventory(ansible_inv) ansible_inv.subset(options.subset) pbex = playbook_executor.PlaybookExecutor( playbooks=playbooks, inventory=ansible_inv, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) self.tqm = pbex._tqm errors_callback = ErrorsCallback() self.add_callback(errors_callback) # There is no public API for adding callbacks, hence we use a private # property to add callbacks pbex._tqm._callback_plugins.extend(self._callbacks) status = pbex.run() stats = pbex._tqm._stats failed_results = errors_callback.failed_results result = self._process_stats(stats, failed_results) return result
def ssh_to_host(hostname, remote_command=None): """ Compose cmd string of ssh and execute Uses Ansible to parse inventory file, gets ssh connection options :param hostname: str. Hostname from inventory """ workspace_manager = CoreServices.workspace_manager() workspace = workspace_manager.get_active_workspace() if workspace is None: raise exceptions.IRNoActiveWorkspaceFound() inventory_file = workspace.inventory invent = inventory.Inventory(DataLoader(), VariableManager(), host_list=inventory_file) host = invent.get_host(hostname) if host is None: raise exceptions.IRSshException( "Host {} is not in inventory {}".format(hostname, inventory_file)) if _get_magic_var(host, "connection") == "local": raise exceptions.IRSshException("Only ssh transport acceptable.") cmd = " ".join([ "ssh {priv_key} {comm_args}", "{extra_args} -p {port} -t {user}@{host}" ]) cmd_fields = {} cmd_fields["user"] = _get_magic_var(host, "remote_user", default="root") cmd_fields["port"] = _get_magic_var(host, "port", default=22) cmd_fields["host"] = _get_magic_var(host, "remote_addr") priv_key = _get_magic_var(host, "private_key_file") # NOTE(yfried): # ssh client needs key to be in the directory you're running one from # ('ssh -i id_rsa ...') or to be provided by absolute path. # assume paths are relative to inventory file. abspath = os.path.join(os.path.abspath(os.path.dirname(inventory_file)), priv_key) priv_key = abspath if os.path.exists(abspath) else priv_key cmd_fields["priv_key"] = "-i {}".format(priv_key if priv_key else "") cmd_fields["comm_args"] = _get_magic_var(host, "ssh_common_args") cmd_fields["extra_args"] = _get_magic_var(host, "ssh_extra_args") LOG.debug("Establishing ssh connection to {}".format(cmd_fields["host"])) compiled_cmd = cmd.format(**cmd_fields) if remote_command is not None: compiled_cmd = " ".join([compiled_cmd, '"{}"'.format(remote_command)]) result = os.WEXITSTATUS(os.system(compiled_cmd)) LOG.debug("Connection to {} closed".format(cmd_fields["host"])) return result
def get_inventory(loader, variable_manager, inventory_file): try: # Ansible 2.4 from ansible.inventory.manager import InventoryManager return InventoryManager(loader=loader, sources=inventory_file) except: # Ansible 2.3 from ansible import inventory inventory.HOSTS_PATTERNS_CACHE = {} # clean up previous cached hosts return inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory_file)
def run_playbook(playbook_file_name, inventory_file_name): stats = callbacks.AggregateStats() playbook_cb = callbacks.PlaybookCallbacks(verbose=0) runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=0) pb = ansible.playbook.PlayBook( playbook_file_name, inventory=inventory.Inventory(inventory_file_name), callbacks=playbook_cb, runner_callbacks=runner_cb, stats=stats) pb.run()
def set_group(name, host): a = inventory.Inventory() groups = a.groups_list() group_exist = False for i in groups: if name in i: group_exist=True if group_exist is True: inv_group = a.get_group(name) inv_group.add_host(host) else: inv_group = inventory.group.Group(name = name) return inv_group
def ssh_to_host(hostname, remote_command=None): """ Compose cmd string of ssh and execute Uses Ansible to parse inventory file, gets ssh connection options :param hostname: str. Hostname from inventory """ workspace_manager = CoreServices.workspace_manager() workspace = workspace_manager.get_active_workspace() if workspace is None: raise exceptions.IRNoActiveWorkspaceFound() inventory_file = workspace.inventory invent = inventory.Inventory(DataLoader(), VariableManager(), host_list=inventory_file) host = invent.get_host(hostname) if host is None: raise exceptions.IRSshException( "Host {} is not in inventory {}".format(hostname, inventory_file)) if _get_magic_var(host, "connection") == "local": raise exceptions.IRSshException("Only ssh transport acceptable.") cmd = " ".join([ "ssh {priv_key} {comm_args}", "{extra_args} -p {port} -t {user}@{host}" ]) cmd_fields = {} cmd_fields["user"] = _get_magic_var(host, "remote_user", default="root") cmd_fields["port"] = _get_magic_var(host, "port", default=22) cmd_fields["host"] = _get_magic_var(host, "remote_addr") priv_key = _get_magic_var(host, "private_key_file") cmd_fields["priv_key"] = "-i {}".format(priv_key if priv_key else "") cmd_fields["comm_args"] = _get_magic_var(host, "ssh_common_args") cmd_fields["extra_args"] = _get_magic_var(host, "ssh_extra_args") LOG.debug("Establishing ssh connection to {}".format(cmd_fields["host"])) compiled_cmd = cmd.format(**cmd_fields) if remote_command is not None: compiled_cmd = " ".join([compiled_cmd, '"{}"'.format(remote_command)]) os.system(compiled_cmd) LOG.debug("Connection to {} closed".format(cmd_fields["host"]))
def get_inventory_info(inv_file=inventory_source): """ """ print(os.getcwd()) if not os.path.isfile(inv_file): return inv = inventory.Inventory(inv_file) ret_dict = OrderedDict() for grp in inv.get_groups(): host_list = list() for host in grp.get_hosts(): host_list.append(host.name) ret_dict[grp.name] = host_list return ret_dict
def _get_inventory(self, workspace_name=None): """Returns Inventory object for the provided workspace. Use active workspace as default :param workspace_name: workspace name to list nodes from. """ workspace = self.get( workspace_name) if workspace_name else self.get_active_workspace() if workspace is None: if workspace_name is None: raise exceptions.IRNoActiveWorkspaceFound() else: raise exceptions.IRWorkspaceMissing(workspace=workspace_name) return inventory.Inventory(DataLoader(), VariableManager(), host_list=workspace.inventory)
def run_ansible(): vaultpass = "******" I = inventory.Inventory("hosts.ini") parsed_extra_vars = { 'tags' : ['two'], 'date': 2 } stats = callbacks.AggregateStats() playbook_cb = callbacks.PlaybookCallbacks(verbose=3) runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=3) pb = playbook.PlayBook( playbook='sample_playbook.yaml', inventory=I, extra_vars=parsed_extra_vars, #private_key_file="/path/to/key.pem", #vault_password=vaultpass, stats=stats, callbacks=playbook_cb, runner_callbacks=runner_cb ) pb.run() hosts = sorted(pb.stats.processed.keys()) failed_hosts = [] unreachable_hosts = [] for h in hosts: t = pb.stats.summarize(h) if t['failures'] > 0: failed_hosts.append(h) if t['unreachable'] > 0: unreachable_hosts.append(h) print("failed hosts: ", failed_hosts) print("unreachable hosts: ", unreachable_hosts) retries = failed_hosts + unreachable_hosts print("retries:", retries) if len(retries) > 0: return 1 return 0
def _run_play(self, play_source, host_vars): host_list = play_source['hosts'] loader = dataloader.DataLoader() variable_manager = VariableManager() inventory_inst = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory_inst) for host, variables in host_vars.items(): host_inst = inventory_inst.get_host(host) for var_name, value in variables.items(): if value is not None: variable_manager.set_host_variable(host_inst, var_name, value) storage = [] callback = MyCallback(storage) tqm = task_queue_manager.TaskQueueManager( inventory=inventory_inst, variable_manager=variable_manager, loader=loader, options=self.options, passwords=self.passwords, stdout_callback=callback, ) # create play play_inst = play.Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it try: tqm.run(play_inst) finally: tqm.cleanup() return storage
def GroupsList(): """ :rtype: object """ groups = [] a = inventory.Inventory() data = a.groups_list() for i in data: try: group = { 'id': groups[-1]['id'] + 1, 'group': str(i), 'hosts': str(data[i]), } except: group = { 'id': 1, 'group': i, 'hosts': data[i], } groups.append(group) return groups
def node_list(self, workspace_name=None): """Lists nodes and connection types from workspace's inventory nodes with connection type 'local' are skipped :param workspace_name: workspace name to list nodes from. Use active workspace as default """ workspace = self.get( workspace_name) if workspace_name else self.get_active_workspace() if workspace is None: if workspace_name is None: raise exceptions.IRNoActiveWorkspaceFound() else: raise exceptions.IRWorkspaceMissing(workspace=workspace_name) invent = inventory.Inventory(DataLoader(), VariableManager(), host_list=workspace.inventory) hosts = invent.get_hosts() return [(host.name, host.address) for host in hosts if host.vars.get("ansible_connection") != "local"]
def __init__(self, playbook, dci_context, options=None, verbosity=3): if options is None: self._options = Options() self._options.verbosity = verbosity self._options.connection = 'ssh' self._options.become = True self._options.become_method = 'sudo' self._options.become_user = '******' self._loader = dataloader.DataLoader() self._variable_manager = vars.VariableManager() task_queue_manager.display.verbosity = verbosity callback.global_display.verbosity = verbosity self._inventory = inventory.Inventory( loader=self._loader, variable_manager=self._variable_manager, host_list='/etc/ansible/hosts') self._variable_manager.set_inventory(self._inventory) # Instantiate our Callback plugin self._results_callback = DciCallback(dci_context=dci_context) self._playbook = Playbook.load(playbook, variable_manager=self._variable_manager, loader=self._loader) self._pbex = playbook_executor.PlaybookExecutor( playbooks=[playbook], inventory=self._inventory, variable_manager=self._variable_manager, loader=self._loader, options=self._options, passwords={})
def GroupVarsList(group): """ lists variables for group :rtype: object """ vars = [] a = inventory.Inventory() group_vars = a.get_group(group).get_variables() for i in range(len(vars)): try: host = { 'id': len(vars)[-1]['id'] + 1, 'group': str(group[i]), 'groups': group } except: host = { 'id': 1, 'group': str(group[i]), 'groups': group } vars.append(host) return vars
def _run_play(self, play_source): host_list = play_source['hosts'] loader = dataloader.DataLoader() variable_manager = VariableManager() inventory_inst = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory_inst) passwords = dict(vault_pass='******') # create play play_inst = play.Play().load(play_source, variable_manager=variable_manager, loader=loader) storage = [] callback = MyCallback(storage) # actually run it tqm = None try: tqm = task_queue_manager.TaskQueueManager( inventory=inventory_inst, variable_manager=variable_manager, loader=loader, options=self.options, passwords=passwords, stdout_callback=callback, ) tqm.run(play_inst) finally: if tqm is not None: tqm.cleanup() return storage
# the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Eisen is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Eisen. If not, see <http://www.gnu.org/licenses/>. # Make coding more python3-ish from __future__ import (absolute_import, division, print_function) from ansible import inventory __metaclass__ = type __version__ = '0.0.1' __author__ = 'Eisen' # Contain the async executed tasks result tasks_result = {} tasks_package = {} recepies_result = {} recepies_package = {} result2Db = {} # contain the dynamic inventory dynamic_inventory = inventory.Inventory()
def human_log(self, res, host): inventory_manager = inventory.Inventory() result = inventory_manager.get_variables(host) print result['ec2_tag_Name']
''' Test bundled filters ''' import os.path import unittest, tempfile, shutil from ansible import playbook, inventory, callbacks import ansible.runner.filter_plugins.core import ansible.runner.filter_plugins.mathstuff INVENTORY = inventory.Inventory(['localhost']) BOOK = ''' - hosts: localhost vars: var: { a: [1,2,3] } tasks: - template: src=%s dest=%s ''' SRC = ''' - {{ var|to_json }} - {{ var|to_nice_json }} - {{ var|to_yaml }} - {{ var|to_nice_yaml }} '''
from ansible import inventory from ansible import callbacks from ansible import utils utils.VERBOSITY = 3 ANSIBLE_HOSTS = 'local' INVENTORY_FILE = 'servers.yml' PLAYBOOK = 'playbook.yml' CONFIG_RECIPES_FILE = 'script-config.yml' playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY) stats = callbacks.AggregateStats() runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY) inventory = inventory.Inventory(INVENTORY_FILE) inventory.subset(ANSIBLE_HOSTS) inventory.set_playbook_basedir(os.path.dirname(PLAYBOOK)) hosts = inventory.list_hosts(ANSIBLE_HOSTS) if len(hosts) == 0: raise Exception( 'Could not find any host to match "%s" in the inventory "%s" file' % (ANSIBLE_HOSTS, INVENTORY_FILE)) stream = open(CONFIG_RECIPES_FILE, 'r') configurations = yaml.load(stream) for recipe in configurations: print recipe['only_tags']