mirror of https://github.com/ansible/ansible.git
Transition inventory into plugins (#23001)
* draft new inventory plugin arch, yaml sample - split classes, moved out of init - extra debug statements - allow mulitple invenotry files - dont add hosts more than once - simplified host vars - since now we can have multiple, inventory_dir/file needs to be per host - ported yaml/script/ini/virtualbox plugins, dir is 'built in manager' - centralized localhost handling - added plugin docs - leaner meaner inventory (split to data + manager) - moved noop vars plugin - added 'postprocessing' inventory plugins - fixed ini plugin, better info on plugin run group declarations can appear in any position relative to children entry that contains them - grouphost_vars loading as inventory plugin (postprocessing) - playbook_dir allways full path - use bytes for file operations - better handling of empty/null sources - added test target that skips networking modules - now var manager loads play group/host_vars independant from inventory - centralized play setup repeat code - updated changelog with inv features - asperioribus verbis spatium album - fixed dataloader to new sig - made yaml plugin more resistant to bad data - nicer error msgs - fixed undeclared group detection - fixed 'ungrouping' - docs updated s/INI/file/ as its not only format - made behaviour of var merge a toggle - made 'source over group' path follow existing rule for var precedence - updated add_host/group from strategy - made host_list a plugin and added it to defaults - added advanced_host_list as example variation - refactored 'display' to be availbe by default in class inheritance - optimized implicit handling as per @pilou's feedback - removed unused code and tests - added inventory cache and vbox plugin now uses it - added _compose method for variable expressions in plugins - vbox plugin now uses 'compose' - require yaml extension for yaml - fix for plugin loader to always add original_path, even when not using all() - fix py3 issues - added --inventory as clearer option - return name when stringifying host objects - ajdust checks to code moving * reworked vars and vars precedence - vars plugins now load group/host_vars dirs - precedence for host vars is now configurable - vars_plugins been reworked - removed unused vars cache - removed _gathered_facts as we are not keeping info in host anymore - cleaned up tests - fixed ansible-pull to work with new inventory - removed version added notation to please rst check - inventory in config relative to config - ensures full paths on passed inventories * implicit localhost connection localpull/24952/head
Brian Coca
8 years ago
committed by
GitHub
parent
91a72ce7da
commit
8f97aef1a3
@ -1,903 +0,0 @@
|
|||||||
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
#############################################
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
import fnmatch
|
|
||||||
import os
|
|
||||||
import subprocess
|
|
||||||
import sys
|
|
||||||
import re
|
|
||||||
import itertools
|
|
||||||
|
|
||||||
|
|
||||||
from ansible import constants as C
|
|
||||||
from ansible.errors import AnsibleError
|
|
||||||
from ansible.inventory.dir import InventoryDirectory, get_file_parser
|
|
||||||
from ansible.inventory.group import Group
|
|
||||||
from ansible.inventory.host import Host
|
|
||||||
from ansible.module_utils.six import string_types, iteritems
|
|
||||||
from ansible.module_utils._text import to_bytes, to_text
|
|
||||||
from ansible.parsing.utils.addresses import parse_address
|
|
||||||
from ansible.plugins import vars_loader
|
|
||||||
from ansible.utils.vars import combine_vars
|
|
||||||
from ansible.utils.path import unfrackpath
|
|
||||||
|
|
||||||
try:
|
|
||||||
from __main__ import display
|
|
||||||
except ImportError:
|
|
||||||
from ansible.utils.display import Display
|
|
||||||
display = Display()
|
|
||||||
|
|
||||||
|
|
||||||
HOSTS_PATTERNS_CACHE = {}
|
|
||||||
|
|
||||||
|
|
||||||
class Inventory(object):
|
|
||||||
"""
|
|
||||||
Host inventory for ansible.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, loader, variable_manager, host_list=C.DEFAULT_HOST_LIST):
|
|
||||||
|
|
||||||
# the host file file, or script path, or list of hosts
|
|
||||||
# if a list, inventory data will NOT be loaded
|
|
||||||
self.host_list = unfrackpath(host_list, follow=False)
|
|
||||||
self._loader = loader
|
|
||||||
self._variable_manager = variable_manager
|
|
||||||
self.localhost = None
|
|
||||||
|
|
||||||
# caching to avoid repeated calculations, particularly with
|
|
||||||
# external inventory scripts.
|
|
||||||
|
|
||||||
self._vars_per_host = {}
|
|
||||||
self._vars_per_group = {}
|
|
||||||
self._hosts_cache = {}
|
|
||||||
self._pattern_cache = {}
|
|
||||||
self._group_dict_cache = {}
|
|
||||||
self._vars_plugins = []
|
|
||||||
|
|
||||||
self._basedir = self.basedir()
|
|
||||||
|
|
||||||
# Contains set of filenames under group_vars directories
|
|
||||||
self._group_vars_files = self._find_group_vars_files(self._basedir)
|
|
||||||
self._host_vars_files = self._find_host_vars_files(self._basedir)
|
|
||||||
|
|
||||||
# to be set by calling set_playbook_basedir by playbook code
|
|
||||||
self._playbook_basedir = None
|
|
||||||
|
|
||||||
# the inventory object holds a list of groups
|
|
||||||
self.groups = {}
|
|
||||||
|
|
||||||
# a list of host(names) to contain current inquiries to
|
|
||||||
self._restriction = None
|
|
||||||
self._subset = None
|
|
||||||
|
|
||||||
# clear the cache here, which is only useful if more than
|
|
||||||
# one Inventory objects are created when using the API directly
|
|
||||||
self.clear_pattern_cache()
|
|
||||||
self.clear_group_dict_cache()
|
|
||||||
|
|
||||||
self.parse_inventory(host_list)
|
|
||||||
|
|
||||||
def serialize(self):
|
|
||||||
data = dict()
|
|
||||||
return data
|
|
||||||
|
|
||||||
def deserialize(self, data):
|
|
||||||
pass
|
|
||||||
|
|
||||||
def parse_inventory(self, host_list):
|
|
||||||
|
|
||||||
if isinstance(host_list, string_types):
|
|
||||||
if "," in host_list:
|
|
||||||
host_list = host_list.split(",")
|
|
||||||
host_list = [ h for h in host_list if h and h.strip() ]
|
|
||||||
|
|
||||||
self.parser = None
|
|
||||||
|
|
||||||
# Always create the 'all' and 'ungrouped' groups, even if host_list is
|
|
||||||
# empty: in this case we will subsequently add the implicit 'localhost' to it.
|
|
||||||
|
|
||||||
ungrouped = Group('ungrouped')
|
|
||||||
all = Group('all')
|
|
||||||
all.add_child_group(ungrouped)
|
|
||||||
base_groups = frozenset([all, ungrouped])
|
|
||||||
|
|
||||||
self.groups = dict(all=all, ungrouped=ungrouped)
|
|
||||||
|
|
||||||
if host_list is None:
|
|
||||||
pass
|
|
||||||
elif isinstance(host_list, list):
|
|
||||||
for h in host_list:
|
|
||||||
try:
|
|
||||||
(host, port) = parse_address(h, allow_ranges=False)
|
|
||||||
except AnsibleError as e:
|
|
||||||
display.vvv("Unable to parse address from hostname, leaving unchanged: %s" % to_text(e))
|
|
||||||
host = h
|
|
||||||
port = None
|
|
||||||
|
|
||||||
new_host = Host(host, port)
|
|
||||||
if h in C.LOCALHOST:
|
|
||||||
# set default localhost from inventory to avoid creating an implicit one. Last localhost defined 'wins'.
|
|
||||||
if self.localhost is not None:
|
|
||||||
display.warning("A duplicate localhost-like entry was found (%s). First found localhost was %s" % (h, self.localhost.name))
|
|
||||||
display.vvvv("Set default localhost to %s" % h)
|
|
||||||
self.localhost = new_host
|
|
||||||
all.add_host(new_host)
|
|
||||||
elif self._loader.path_exists(host_list):
|
|
||||||
# TODO: switch this to a plugin loader and a 'condition' per plugin on which it should be tried, restoring 'inventory pllugins'
|
|
||||||
if self.is_directory(host_list):
|
|
||||||
# Ensure basedir is inside the directory
|
|
||||||
host_list = os.path.join(self.host_list, "")
|
|
||||||
self.parser = InventoryDirectory(loader=self._loader, groups=self.groups, filename=host_list)
|
|
||||||
else:
|
|
||||||
self.parser = get_file_parser(host_list, self.groups, self._loader)
|
|
||||||
vars_loader.add_directory(self._basedir, with_subdir=True)
|
|
||||||
|
|
||||||
if not self.parser:
|
|
||||||
# should never happen, but JIC
|
|
||||||
raise AnsibleError("Unable to parse %s as an inventory source" % host_list)
|
|
||||||
else:
|
|
||||||
display.warning("Host file not found: %s" % to_text(host_list))
|
|
||||||
|
|
||||||
self._vars_plugins = [ x for x in vars_loader.all(self) ]
|
|
||||||
|
|
||||||
### POST PROCESS groups and hosts after specific parser was invoked
|
|
||||||
|
|
||||||
hosts = []
|
|
||||||
group_names = set()
|
|
||||||
# set group vars from group_vars/ files and vars plugins
|
|
||||||
for g in self.groups:
|
|
||||||
group = self.groups[g]
|
|
||||||
group.vars = combine_vars(group.vars, self.get_group_variables(group.name))
|
|
||||||
self.get_group_vars(group)
|
|
||||||
group_names.add(group.name)
|
|
||||||
hosts.extend(group.get_hosts())
|
|
||||||
|
|
||||||
host_names = set()
|
|
||||||
# get host vars from host_vars/ files and vars plugins
|
|
||||||
for host in hosts:
|
|
||||||
host.vars = combine_vars(host.vars, self.get_host_variables(host.name))
|
|
||||||
self.get_host_vars(host)
|
|
||||||
host_names.add(host.name)
|
|
||||||
|
|
||||||
mygroups = host.get_groups()
|
|
||||||
|
|
||||||
# ensure hosts are always in 'all'
|
|
||||||
if all not in mygroups:
|
|
||||||
all.add_host(host)
|
|
||||||
|
|
||||||
if ungrouped in mygroups:
|
|
||||||
# clear ungrouped of any incorrectly stored by parser
|
|
||||||
if set(mygroups).difference(base_groups):
|
|
||||||
host.remove_group(ungrouped)
|
|
||||||
else:
|
|
||||||
# add ungrouped hosts to ungrouped
|
|
||||||
length = len(mygroups)
|
|
||||||
if length == 0 or (length == 1 and all in mygroups):
|
|
||||||
ungrouped.add_host(host)
|
|
||||||
|
|
||||||
# warn if overloading identifier as both group and host
|
|
||||||
for conflict in group_names.intersection(host_names):
|
|
||||||
display.warning("Found both group and host with same name: %s" % conflict)
|
|
||||||
|
|
||||||
def _match(self, str, pattern_str):
|
|
||||||
try:
|
|
||||||
if pattern_str.startswith('~'):
|
|
||||||
return re.search(pattern_str[1:], str)
|
|
||||||
else:
|
|
||||||
return fnmatch.fnmatch(str, pattern_str)
|
|
||||||
except Exception:
|
|
||||||
raise AnsibleError('invalid host pattern: %s' % pattern_str)
|
|
||||||
|
|
||||||
def _match_list(self, items, item_attr, pattern_str):
|
|
||||||
results = []
|
|
||||||
try:
|
|
||||||
if not pattern_str.startswith('~'):
|
|
||||||
pattern = re.compile(fnmatch.translate(pattern_str))
|
|
||||||
else:
|
|
||||||
pattern = re.compile(pattern_str[1:])
|
|
||||||
except Exception:
|
|
||||||
raise AnsibleError('invalid host pattern: %s' % pattern_str)
|
|
||||||
|
|
||||||
for item in items:
|
|
||||||
if pattern.match(getattr(item, item_attr)):
|
|
||||||
results.append(item)
|
|
||||||
return results
|
|
||||||
|
|
||||||
def get_hosts(self, pattern="all", ignore_limits=False, ignore_restrictions=False, order=None):
|
|
||||||
"""
|
|
||||||
Takes a pattern or list of patterns and returns a list of matching
|
|
||||||
inventory host names, taking into account any active restrictions
|
|
||||||
or applied subsets
|
|
||||||
"""
|
|
||||||
|
|
||||||
# Check if pattern already computed
|
|
||||||
if isinstance(pattern, list):
|
|
||||||
pattern_hash = u":".join(pattern)
|
|
||||||
else:
|
|
||||||
pattern_hash = pattern
|
|
||||||
|
|
||||||
if not ignore_limits and self._subset:
|
|
||||||
pattern_hash += u":%s" % to_text(self._subset)
|
|
||||||
|
|
||||||
if not ignore_restrictions and self._restriction:
|
|
||||||
pattern_hash += u":%s" % to_text(self._restriction)
|
|
||||||
|
|
||||||
if pattern_hash not in HOSTS_PATTERNS_CACHE:
|
|
||||||
|
|
||||||
patterns = Inventory.split_host_pattern(pattern)
|
|
||||||
hosts = self._evaluate_patterns(patterns)
|
|
||||||
|
|
||||||
# mainly useful for hostvars[host] access
|
|
||||||
if not ignore_limits and self._subset:
|
|
||||||
# exclude hosts not in a subset, if defined
|
|
||||||
subset = self._evaluate_patterns(self._subset)
|
|
||||||
hosts = [ h for h in hosts if h in subset ]
|
|
||||||
|
|
||||||
if not ignore_restrictions and self._restriction:
|
|
||||||
# exclude hosts mentioned in any restriction (ex: failed hosts)
|
|
||||||
hosts = [ h for h in hosts if h.name in self._restriction ]
|
|
||||||
|
|
||||||
seen = set()
|
|
||||||
HOSTS_PATTERNS_CACHE[pattern_hash] = [x for x in hosts if x not in seen and not seen.add(x)]
|
|
||||||
|
|
||||||
# sort hosts list if needed (should only happen when called from strategy)
|
|
||||||
if order in ['sorted', 'reverse_sorted']:
|
|
||||||
from operator import attrgetter
|
|
||||||
hosts = sorted(HOSTS_PATTERNS_CACHE[pattern_hash][:], key=attrgetter('name'), reverse=(order == 'reverse_sorted'))
|
|
||||||
elif order == 'reverse_inventory':
|
|
||||||
hosts = sorted(HOSTS_PATTERNS_CACHE[pattern_hash][:], reverse=True)
|
|
||||||
else:
|
|
||||||
hosts = HOSTS_PATTERNS_CACHE[pattern_hash][:]
|
|
||||||
if order == 'shuffle':
|
|
||||||
from random import shuffle
|
|
||||||
shuffle(hosts)
|
|
||||||
elif order not in [None, 'inventory']:
|
|
||||||
AnsibleError("Invalid 'order' specified for inventory hosts: %s" % order)
|
|
||||||
|
|
||||||
return hosts
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def split_host_pattern(cls, pattern):
|
|
||||||
"""
|
|
||||||
Takes a string containing host patterns separated by commas (or a list
|
|
||||||
thereof) and returns a list of single patterns (which may not contain
|
|
||||||
commas). Whitespace is ignored.
|
|
||||||
|
|
||||||
Also accepts ':' as a separator for backwards compatibility, but it is
|
|
||||||
not recommended due to the conflict with IPv6 addresses and host ranges.
|
|
||||||
|
|
||||||
Example: 'a,b[1], c[2:3] , d' -> ['a', 'b[1]', 'c[2:3]', 'd']
|
|
||||||
"""
|
|
||||||
|
|
||||||
if isinstance(pattern, list):
|
|
||||||
return list(itertools.chain(*map(cls.split_host_pattern, pattern)))
|
|
||||||
|
|
||||||
# If it's got commas in it, we'll treat it as a straightforward
|
|
||||||
# comma-separated list of patterns.
|
|
||||||
|
|
||||||
elif ',' in pattern:
|
|
||||||
patterns = re.split('\s*,\s*', pattern)
|
|
||||||
|
|
||||||
# If it doesn't, it could still be a single pattern. This accounts for
|
|
||||||
# non-separator uses of colons: IPv6 addresses and [x:y] host ranges.
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
(base, port) = parse_address(pattern, allow_ranges=True)
|
|
||||||
patterns = [pattern]
|
|
||||||
except:
|
|
||||||
# The only other case we accept is a ':'-separated list of patterns.
|
|
||||||
# This mishandles IPv6 addresses, and is retained only for backwards
|
|
||||||
# compatibility.
|
|
||||||
patterns = re.findall(
|
|
||||||
r'''(?: # We want to match something comprising:
|
|
||||||
[^\s:\[\]] # (anything other than whitespace or ':[]'
|
|
||||||
| # ...or...
|
|
||||||
\[[^\]]*\] # a single complete bracketed expression)
|
|
||||||
)+ # occurring once or more
|
|
||||||
''', pattern, re.X
|
|
||||||
)
|
|
||||||
|
|
||||||
return [p.strip() for p in patterns]
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def order_patterns(cls, patterns):
|
|
||||||
|
|
||||||
# Host specifiers should be sorted to ensure consistent behavior
|
|
||||||
pattern_regular = []
|
|
||||||
pattern_intersection = []
|
|
||||||
pattern_exclude = []
|
|
||||||
for p in patterns:
|
|
||||||
if p.startswith("!"):
|
|
||||||
pattern_exclude.append(p)
|
|
||||||
elif p.startswith("&"):
|
|
||||||
pattern_intersection.append(p)
|
|
||||||
elif p:
|
|
||||||
pattern_regular.append(p)
|
|
||||||
|
|
||||||
# if no regular pattern was given, hence only exclude and/or intersection
|
|
||||||
# make that magically work
|
|
||||||
if pattern_regular == []:
|
|
||||||
pattern_regular = ['all']
|
|
||||||
|
|
||||||
# when applying the host selectors, run those without the "&" or "!"
|
|
||||||
# first, then the &s, then the !s.
|
|
||||||
return pattern_regular + pattern_intersection + pattern_exclude
|
|
||||||
|
|
||||||
def _evaluate_patterns(self, patterns):
|
|
||||||
"""
|
|
||||||
Takes a list of patterns and returns a list of matching host names,
|
|
||||||
taking into account any negative and intersection patterns.
|
|
||||||
"""
|
|
||||||
|
|
||||||
patterns = Inventory.order_patterns(patterns)
|
|
||||||
hosts = []
|
|
||||||
|
|
||||||
for p in patterns:
|
|
||||||
# avoid resolving a pattern that is a plain host
|
|
||||||
if p in self._hosts_cache:
|
|
||||||
hosts.append(self.get_host(p))
|
|
||||||
else:
|
|
||||||
that = self._match_one_pattern(p)
|
|
||||||
if p.startswith("!"):
|
|
||||||
hosts = [ h for h in hosts if h not in that ]
|
|
||||||
elif p.startswith("&"):
|
|
||||||
hosts = [ h for h in hosts if h in that ]
|
|
||||||
else:
|
|
||||||
to_append = [ h for h in that if h.name not in [ y.name for y in hosts ] ]
|
|
||||||
hosts.extend(to_append)
|
|
||||||
return hosts
|
|
||||||
|
|
||||||
def _match_one_pattern(self, pattern):
|
|
||||||
"""
|
|
||||||
Takes a single pattern and returns a list of matching host names.
|
|
||||||
Ignores intersection (&) and exclusion (!) specifiers.
|
|
||||||
|
|
||||||
The pattern may be:
|
|
||||||
|
|
||||||
1. A regex starting with ~, e.g. '~[abc]*'
|
|
||||||
2. A shell glob pattern with ?/*/[chars]/[!chars], e.g. 'foo*'
|
|
||||||
3. An ordinary word that matches itself only, e.g. 'foo'
|
|
||||||
|
|
||||||
The pattern is matched using the following rules:
|
|
||||||
|
|
||||||
1. If it's 'all', it matches all hosts in all groups.
|
|
||||||
2. Otherwise, for each known group name:
|
|
||||||
(a) if it matches the group name, the results include all hosts
|
|
||||||
in the group or any of its children.
|
|
||||||
(b) otherwise, if it matches any hosts in the group, the results
|
|
||||||
include the matching hosts.
|
|
||||||
|
|
||||||
This means that 'foo*' may match one or more groups (thus including all
|
|
||||||
hosts therein) but also hosts in other groups.
|
|
||||||
|
|
||||||
The built-in groups 'all' and 'ungrouped' are special. No pattern can
|
|
||||||
match these group names (though 'all' behaves as though it matches, as
|
|
||||||
described above). The word 'ungrouped' can match a host of that name,
|
|
||||||
and patterns like 'ungr*' and 'al*' can match either hosts or groups
|
|
||||||
other than all and ungrouped.
|
|
||||||
|
|
||||||
If the pattern matches one or more group names according to these rules,
|
|
||||||
it may have an optional range suffix to select a subset of the results.
|
|
||||||
This is allowed only if the pattern is not a regex, i.e. '~foo[1]' does
|
|
||||||
not work (the [1] is interpreted as part of the regex), but 'foo*[1]'
|
|
||||||
would work if 'foo*' matched the name of one or more groups.
|
|
||||||
|
|
||||||
Duplicate matches are always eliminated from the results.
|
|
||||||
"""
|
|
||||||
|
|
||||||
if pattern.startswith("&") or pattern.startswith("!"):
|
|
||||||
pattern = pattern[1:]
|
|
||||||
|
|
||||||
if pattern not in self._pattern_cache:
|
|
||||||
(expr, slice) = self._split_subscript(pattern)
|
|
||||||
hosts = self._enumerate_matches(expr)
|
|
||||||
try:
|
|
||||||
hosts = self._apply_subscript(hosts, slice)
|
|
||||||
except IndexError:
|
|
||||||
raise AnsibleError("No hosts matched the subscripted pattern '%s'" % pattern)
|
|
||||||
self._pattern_cache[pattern] = hosts
|
|
||||||
|
|
||||||
return self._pattern_cache[pattern]
|
|
||||||
|
|
||||||
def _split_subscript(self, pattern):
|
|
||||||
"""
|
|
||||||
Takes a pattern, checks if it has a subscript, and returns the pattern
|
|
||||||
without the subscript and a (start,end) tuple representing the given
|
|
||||||
subscript (or None if there is no subscript).
|
|
||||||
|
|
||||||
Validates that the subscript is in the right syntax, but doesn't make
|
|
||||||
sure the actual indices make sense in context.
|
|
||||||
"""
|
|
||||||
|
|
||||||
# Do not parse regexes for enumeration info
|
|
||||||
if pattern.startswith('~'):
|
|
||||||
return (pattern, None)
|
|
||||||
|
|
||||||
# We want a pattern followed by an integer or range subscript.
|
|
||||||
# (We can't be more restrictive about the expression because the
|
|
||||||
# fnmatch semantics permit [\[:\]] to occur.)
|
|
||||||
|
|
||||||
pattern_with_subscript = re.compile(
|
|
||||||
r'''^
|
|
||||||
(.+) # A pattern expression ending with...
|
|
||||||
\[(?: # A [subscript] expression comprising:
|
|
||||||
(-?[0-9]+)| # A single positive or negative number
|
|
||||||
([0-9]+)([:-]) # Or an x:y or x: range.
|
|
||||||
([0-9]*)
|
|
||||||
)\]
|
|
||||||
$
|
|
||||||
''', re.X
|
|
||||||
)
|
|
||||||
|
|
||||||
subscript = None
|
|
||||||
m = pattern_with_subscript.match(pattern)
|
|
||||||
if m:
|
|
||||||
(pattern, idx, start, sep, end) = m.groups()
|
|
||||||
if idx:
|
|
||||||
subscript = (int(idx), None)
|
|
||||||
else:
|
|
||||||
if not end:
|
|
||||||
end = -1
|
|
||||||
subscript = (int(start), int(end))
|
|
||||||
if sep == '-':
|
|
||||||
display.warning("Use [x:y] inclusive subscripts instead of [x-y] which has been removed")
|
|
||||||
|
|
||||||
return (pattern, subscript)
|
|
||||||
|
|
||||||
def _apply_subscript(self, hosts, subscript):
|
|
||||||
"""
|
|
||||||
Takes a list of hosts and a (start,end) tuple and returns the subset of
|
|
||||||
hosts based on the subscript (which may be None to return all hosts).
|
|
||||||
"""
|
|
||||||
|
|
||||||
if not hosts or not subscript:
|
|
||||||
return hosts
|
|
||||||
|
|
||||||
(start, end) = subscript
|
|
||||||
|
|
||||||
if end:
|
|
||||||
if end == -1:
|
|
||||||
end = len(hosts)-1
|
|
||||||
return hosts[start:end+1]
|
|
||||||
else:
|
|
||||||
return [ hosts[start] ]
|
|
||||||
|
|
||||||
def _enumerate_matches(self, pattern):
|
|
||||||
"""
|
|
||||||
Returns a list of host names matching the given pattern according to the
|
|
||||||
rules explained above in _match_one_pattern.
|
|
||||||
"""
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
def __append_host_to_results(host):
|
|
||||||
if host.name not in results:
|
|
||||||
if not host.implicit:
|
|
||||||
results.append(host)
|
|
||||||
|
|
||||||
groups = self.get_groups()
|
|
||||||
matched = False
|
|
||||||
for group in groups.values():
|
|
||||||
if self._match(group.name, pattern):
|
|
||||||
matched = True
|
|
||||||
for host in group.get_hosts():
|
|
||||||
__append_host_to_results(host)
|
|
||||||
else:
|
|
||||||
matching_hosts = self._match_list(group.get_hosts(), 'name', pattern)
|
|
||||||
if matching_hosts:
|
|
||||||
matched = True
|
|
||||||
for host in matching_hosts:
|
|
||||||
__append_host_to_results(host)
|
|
||||||
|
|
||||||
if pattern in C.LOCALHOST and len(results) == 0:
|
|
||||||
new_host = self._create_implicit_localhost(pattern)
|
|
||||||
results.append(new_host)
|
|
||||||
matched = True
|
|
||||||
|
|
||||||
if not matched:
|
|
||||||
display.warning("Could not match supplied host pattern, ignoring: %s" % pattern)
|
|
||||||
return results
|
|
||||||
|
|
||||||
def _create_implicit_localhost(self, pattern):
|
|
||||||
|
|
||||||
if self.localhost:
|
|
||||||
new_host = self.localhost
|
|
||||||
else:
|
|
||||||
new_host = Host(pattern)
|
|
||||||
new_host.address = "127.0.0.1"
|
|
||||||
new_host.implicit = True
|
|
||||||
new_host.vars = self.get_host_vars(new_host)
|
|
||||||
new_host.set_variable("ansible_connection", "local")
|
|
||||||
if "ansible_python_interpreter" not in new_host.vars:
|
|
||||||
py_interp = sys.executable
|
|
||||||
if not py_interp:
|
|
||||||
# sys.executable is not set in some cornercases. #13585
|
|
||||||
display.warning('Unable to determine python interpreter from sys.executable. Using /usr/bin/python default.'
|
|
||||||
' You can correct this by setting ansible_python_interpreter for localhost')
|
|
||||||
py_interp = '/usr/bin/python'
|
|
||||||
new_host.set_variable("ansible_python_interpreter", py_interp)
|
|
||||||
self.get_group("ungrouped").add_host(new_host)
|
|
||||||
self.localhost = new_host
|
|
||||||
return new_host
|
|
||||||
|
|
||||||
def clear_pattern_cache(self):
|
|
||||||
''' called exclusively by the add_host plugin to allow patterns to be recalculated '''
|
|
||||||
global HOSTS_PATTERNS_CACHE
|
|
||||||
HOSTS_PATTERNS_CACHE = {}
|
|
||||||
self._pattern_cache = {}
|
|
||||||
|
|
||||||
def clear_group_dict_cache(self):
|
|
||||||
''' called exclusively by the add_host and group_by plugins '''
|
|
||||||
self._group_dict_cache = {}
|
|
||||||
|
|
||||||
def groups_for_host(self, host):
|
|
||||||
if host in self._hosts_cache:
|
|
||||||
return self._hosts_cache[host].get_groups()
|
|
||||||
else:
|
|
||||||
return []
|
|
||||||
|
|
||||||
def get_groups(self):
|
|
||||||
return self.groups
|
|
||||||
|
|
||||||
def get_host(self, hostname):
|
|
||||||
if hostname not in self._hosts_cache:
|
|
||||||
self._hosts_cache[hostname] = self._get_host(hostname)
|
|
||||||
return self._hosts_cache[hostname]
|
|
||||||
|
|
||||||
def _get_host(self, hostname):
|
|
||||||
matching_host = None
|
|
||||||
if hostname in C.LOCALHOST:
|
|
||||||
if self.localhost:
|
|
||||||
matching_host= self.localhost
|
|
||||||
else:
|
|
||||||
for host in self.get_group('all').get_hosts():
|
|
||||||
if host.name in C.LOCALHOST:
|
|
||||||
matching_host = host
|
|
||||||
break
|
|
||||||
if not matching_host:
|
|
||||||
matching_host = self._create_implicit_localhost(hostname)
|
|
||||||
# update caches
|
|
||||||
self._hosts_cache[hostname] = matching_host
|
|
||||||
for host in C.LOCALHOST.difference((hostname,)):
|
|
||||||
self._hosts_cache[host] = self._hosts_cache[hostname]
|
|
||||||
else:
|
|
||||||
for group in self.groups.values():
|
|
||||||
for host in group.get_hosts():
|
|
||||||
if host not in self._hosts_cache:
|
|
||||||
self._hosts_cache[host.name] = host
|
|
||||||
if hostname == host.name:
|
|
||||||
matching_host = host
|
|
||||||
return matching_host
|
|
||||||
|
|
||||||
def get_group(self, groupname):
|
|
||||||
return self.groups.get(groupname)
|
|
||||||
|
|
||||||
def get_group_variables(self, groupname, update_cached=False, vault_password=None):
|
|
||||||
if groupname not in self._vars_per_group or update_cached:
|
|
||||||
self._vars_per_group[groupname] = self._get_group_variables(groupname, vault_password=vault_password)
|
|
||||||
return self._vars_per_group[groupname]
|
|
||||||
|
|
||||||
def _get_group_variables(self, groupname, vault_password=None):
|
|
||||||
|
|
||||||
group = self.get_group(groupname)
|
|
||||||
if group is None:
|
|
||||||
raise Exception("group not found: %s" % groupname)
|
|
||||||
|
|
||||||
vars = {}
|
|
||||||
|
|
||||||
# plugin.get_group_vars retrieves just vars for specific group
|
|
||||||
vars_results = [ plugin.get_group_vars(group, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'get_group_vars')]
|
|
||||||
for updated in vars_results:
|
|
||||||
if updated is not None:
|
|
||||||
vars = combine_vars(vars, updated)
|
|
||||||
|
|
||||||
# Read group_vars/ files
|
|
||||||
vars = combine_vars(vars, self.get_group_vars(group))
|
|
||||||
|
|
||||||
return vars
|
|
||||||
|
|
||||||
def get_group_dict(self):
|
|
||||||
"""
|
|
||||||
In get_vars() we merge a 'magic' dictionary 'groups' with group name
|
|
||||||
keys and hostname list values into every host variable set.
|
|
||||||
|
|
||||||
Cache the creation of this structure here
|
|
||||||
"""
|
|
||||||
|
|
||||||
if not self._group_dict_cache:
|
|
||||||
for (group_name, group) in iteritems(self.groups):
|
|
||||||
self._group_dict_cache[group_name] = [h.name for h in group.get_hosts()]
|
|
||||||
|
|
||||||
return self._group_dict_cache
|
|
||||||
|
|
||||||
def get_vars(self, hostname, update_cached=False, vault_password=None):
|
|
||||||
|
|
||||||
host = self.get_host(hostname)
|
|
||||||
if not host:
|
|
||||||
raise AnsibleError("no vars as host is not in inventory: %s" % hostname)
|
|
||||||
return host.get_vars()
|
|
||||||
|
|
||||||
def get_host_variables(self, hostname, update_cached=False, vault_password=None):
|
|
||||||
|
|
||||||
if hostname not in self._vars_per_host or update_cached:
|
|
||||||
self._vars_per_host[hostname] = self._get_host_variables(hostname, vault_password=vault_password)
|
|
||||||
return self._vars_per_host[hostname]
|
|
||||||
|
|
||||||
def _get_host_variables(self, hostname, vault_password=None):
|
|
||||||
|
|
||||||
host = self.get_host(hostname)
|
|
||||||
if host is None:
|
|
||||||
raise AnsibleError("no host vars as host is not in inventory: %s" % hostname)
|
|
||||||
|
|
||||||
vars = {}
|
|
||||||
|
|
||||||
# plugin.run retrieves all vars (also from groups) for host
|
|
||||||
vars_results = [ plugin.run(host, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'run')]
|
|
||||||
for updated in vars_results:
|
|
||||||
if updated is not None:
|
|
||||||
vars = combine_vars(vars, updated)
|
|
||||||
|
|
||||||
# plugin.get_host_vars retrieves just vars for specific host
|
|
||||||
vars_results = [ plugin.get_host_vars(host, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'get_host_vars')]
|
|
||||||
for updated in vars_results:
|
|
||||||
if updated is not None:
|
|
||||||
vars = combine_vars(vars, updated)
|
|
||||||
|
|
||||||
# still need to check InventoryParser per host vars
|
|
||||||
# which actually means InventoryScript per host,
|
|
||||||
# which is not performant
|
|
||||||
if self.parser is not None:
|
|
||||||
vars = combine_vars(vars, self.parser.get_host_variables(host))
|
|
||||||
|
|
||||||
return vars
|
|
||||||
|
|
||||||
def add_group(self, group):
|
|
||||||
if group.name not in self.groups:
|
|
||||||
self.groups[group.name] = group
|
|
||||||
else:
|
|
||||||
raise AnsibleError("group already in inventory: %s" % group.name)
|
|
||||||
|
|
||||||
def list_hosts(self, pattern="all"):
|
|
||||||
|
|
||||||
""" return a list of hostnames for a pattern """
|
|
||||||
|
|
||||||
result = [ h for h in self.get_hosts(pattern) ]
|
|
||||||
if len(result) == 0 and pattern in C.LOCALHOST:
|
|
||||||
result = [pattern]
|
|
||||||
return result
|
|
||||||
|
|
||||||
def list_groups(self):
|
|
||||||
return sorted(self.groups.keys(), key=lambda x: x)
|
|
||||||
|
|
||||||
def restrict_to_hosts(self, restriction):
|
|
||||||
"""
|
|
||||||
Restrict list operations to the hosts given in restriction. This is used
|
|
||||||
to batch serial operations in main playbook code, don't use this for other
|
|
||||||
reasons.
|
|
||||||
"""
|
|
||||||
if restriction is None:
|
|
||||||
return
|
|
||||||
elif not isinstance(restriction, list):
|
|
||||||
restriction = [ restriction ]
|
|
||||||
self._restriction = [ h.name for h in restriction ]
|
|
||||||
|
|
||||||
def subset(self, subset_pattern):
|
|
||||||
"""
|
|
||||||
Limits inventory results to a subset of inventory that matches a given
|
|
||||||
pattern, such as to select a given geographic of numeric slice amongst
|
|
||||||
a previous 'hosts' selection that only select roles, or vice versa.
|
|
||||||
Corresponds to --limit parameter to ansible-playbook
|
|
||||||
"""
|
|
||||||
if subset_pattern is None:
|
|
||||||
self._subset = None
|
|
||||||
else:
|
|
||||||
subset_patterns = Inventory.split_host_pattern(subset_pattern)
|
|
||||||
results = []
|
|
||||||
# allow Unix style @filename data
|
|
||||||
for x in subset_patterns:
|
|
||||||
if x.startswith("@"):
|
|
||||||
fd = open(x[1:])
|
|
||||||
results.extend(fd.read().split("\n"))
|
|
||||||
fd.close()
|
|
||||||
else:
|
|
||||||
results.append(x)
|
|
||||||
self._subset = results
|
|
||||||
|
|
||||||
def remove_restriction(self):
|
|
||||||
""" Do not restrict list operations """
|
|
||||||
self._restriction = None
|
|
||||||
|
|
||||||
def is_file(self):
|
|
||||||
"""
|
|
||||||
Did inventory come from a file? We don't use the equivalent loader
|
|
||||||
methods in inventory, due to the fact that the loader does an implict
|
|
||||||
DWIM on the path, which may be incorrect for inventory paths relative
|
|
||||||
to the playbook basedir.
|
|
||||||
"""
|
|
||||||
if not isinstance(self.host_list, string_types):
|
|
||||||
return False
|
|
||||||
return os.path.isfile(self.host_list) or self.host_list == os.devnull
|
|
||||||
|
|
||||||
def is_directory(self, path):
|
|
||||||
"""
|
|
||||||
Is the inventory host list a directory? Same caveat for here as with
|
|
||||||
the is_file() method above.
|
|
||||||
"""
|
|
||||||
if not isinstance(self.host_list, string_types):
|
|
||||||
return False
|
|
||||||
return os.path.isdir(path)
|
|
||||||
|
|
||||||
def basedir(self):
|
|
||||||
""" if inventory came from a file, what's the directory? """
|
|
||||||
dname = self.host_list
|
|
||||||
if self.is_directory(self.host_list):
|
|
||||||
dname = self.host_list
|
|
||||||
elif not self.is_file():
|
|
||||||
dname = None
|
|
||||||
else:
|
|
||||||
dname = os.path.dirname(self.host_list)
|
|
||||||
if dname is None or dname == '' or dname == '.':
|
|
||||||
dname = os.getcwd()
|
|
||||||
if dname:
|
|
||||||
dname = os.path.abspath(dname)
|
|
||||||
return dname
|
|
||||||
|
|
||||||
def src(self):
|
|
||||||
""" if inventory came from a file, what's the directory and file name? """
|
|
||||||
if not self.is_file():
|
|
||||||
return None
|
|
||||||
return self.host_list
|
|
||||||
|
|
||||||
def playbook_basedir(self):
|
|
||||||
""" returns the directory of the current playbook """
|
|
||||||
return self._playbook_basedir
|
|
||||||
|
|
||||||
def set_playbook_basedir(self, dir_name):
|
|
||||||
"""
|
|
||||||
sets the base directory of the playbook so inventory can use it as a
|
|
||||||
basedir for host_ and group_vars, and other things.
|
|
||||||
"""
|
|
||||||
# Only update things if dir is a different playbook basedir
|
|
||||||
if dir_name != self._playbook_basedir:
|
|
||||||
# we're changing the playbook basedir, so if we had set one previously
|
|
||||||
# clear the host/group vars entries from the VariableManager so they're
|
|
||||||
# not incorrectly used by playbooks from different directories
|
|
||||||
if self._playbook_basedir:
|
|
||||||
self._variable_manager.clear_playbook_hostgroup_vars_files(self._playbook_basedir)
|
|
||||||
|
|
||||||
self._playbook_basedir = dir_name
|
|
||||||
# get group vars from group_vars/ files
|
|
||||||
# TODO: excluding the new_pb_basedir directory may result in group_vars
|
|
||||||
# files loading more than they should, however with the file caching
|
|
||||||
# we do this shouldn't be too much of an issue. Still, this should
|
|
||||||
# be fixed at some point to allow a "first load" to touch all of the
|
|
||||||
# directories, then later runs only touch the new basedir specified
|
|
||||||
found_group_vars = self._find_group_vars_files(self._playbook_basedir)
|
|
||||||
if found_group_vars:
|
|
||||||
self._group_vars_files = self._group_vars_files.union(found_group_vars)
|
|
||||||
for group in self.groups.values():
|
|
||||||
self.get_group_vars(group)
|
|
||||||
|
|
||||||
found_host_vars = self._find_host_vars_files(self._playbook_basedir)
|
|
||||||
if found_host_vars:
|
|
||||||
self._host_vars_files = self._host_vars_files.union(found_host_vars)
|
|
||||||
# get host vars from host_vars/ files
|
|
||||||
for host in self.get_hosts():
|
|
||||||
self.get_host_vars(host)
|
|
||||||
# invalidate cache
|
|
||||||
self._vars_per_host = {}
|
|
||||||
self._vars_per_group = {}
|
|
||||||
|
|
||||||
def get_host_vars(self, host, new_pb_basedir=False, return_results=False):
|
|
||||||
""" Read host_vars/ files """
|
|
||||||
return self._get_hostgroup_vars(host=host, group=None, new_pb_basedir=new_pb_basedir, return_results=return_results)
|
|
||||||
|
|
||||||
def get_group_vars(self, group, new_pb_basedir=False, return_results=False):
|
|
||||||
""" Read group_vars/ files """
|
|
||||||
return self._get_hostgroup_vars(host=None, group=group, new_pb_basedir=new_pb_basedir, return_results=return_results)
|
|
||||||
|
|
||||||
def _find_group_vars_files(self, basedir):
|
|
||||||
""" Find group_vars/ files """
|
|
||||||
if basedir in ('', None):
|
|
||||||
basedir = './'
|
|
||||||
path = os.path.realpath(os.path.join(basedir, 'group_vars'))
|
|
||||||
found_vars = set()
|
|
||||||
if os.path.exists(path):
|
|
||||||
if os.path.isdir(path):
|
|
||||||
found_vars = set(os.listdir(to_text(path)))
|
|
||||||
else:
|
|
||||||
display.warning("Found group_vars that is not a directory, skipping: %s" % path)
|
|
||||||
return found_vars
|
|
||||||
|
|
||||||
def _find_host_vars_files(self, basedir):
|
|
||||||
""" Find host_vars/ files """
|
|
||||||
if basedir in ('', None):
|
|
||||||
basedir = './'
|
|
||||||
path = os.path.realpath(os.path.join(basedir, 'host_vars'))
|
|
||||||
found_vars = set()
|
|
||||||
if os.path.exists(path):
|
|
||||||
found_vars = set(os.listdir(to_text(path)))
|
|
||||||
return found_vars
|
|
||||||
|
|
||||||
def _get_hostgroup_vars(self, host=None, group=None, new_pb_basedir=False, return_results=False):
|
|
||||||
"""
|
|
||||||
Loads variables from group_vars/<groupname> and host_vars/<hostname> in directories parallel
|
|
||||||
to the inventory base directory or in the same directory as the playbook. Variables in the playbook
|
|
||||||
dir will win over the inventory dir if files are in both.
|
|
||||||
"""
|
|
||||||
|
|
||||||
results = {}
|
|
||||||
scan_pass = 0
|
|
||||||
_basedir = self._basedir
|
|
||||||
_playbook_basedir = self._playbook_basedir
|
|
||||||
|
|
||||||
# look in both the inventory base directory and the playbook base directory
|
|
||||||
# unless we do an update for a new playbook base dir
|
|
||||||
if not new_pb_basedir and _playbook_basedir:
|
|
||||||
basedirs = [_basedir, _playbook_basedir]
|
|
||||||
else:
|
|
||||||
basedirs = [_basedir]
|
|
||||||
|
|
||||||
for basedir in basedirs:
|
|
||||||
# this can happen from particular API usages, particularly if not run
|
|
||||||
# from /usr/bin/ansible-playbook
|
|
||||||
if basedir in ('', None):
|
|
||||||
basedir = './'
|
|
||||||
|
|
||||||
scan_pass = scan_pass + 1
|
|
||||||
|
|
||||||
# it's not an eror if the directory does not exist, keep moving
|
|
||||||
if not os.path.exists(basedir):
|
|
||||||
continue
|
|
||||||
|
|
||||||
# save work of second scan if the directories are the same
|
|
||||||
if _basedir == _playbook_basedir and scan_pass != 1:
|
|
||||||
continue
|
|
||||||
|
|
||||||
# Before trying to load vars from file, check that the directory contains relvant file names
|
|
||||||
if host is None and any(map(lambda ext: group.name + ext in self._group_vars_files, C.YAML_FILENAME_EXTENSIONS)):
|
|
||||||
# load vars in dir/group_vars/name_of_group
|
|
||||||
base_path = to_text(os.path.abspath(os.path.join(to_bytes(basedir), b"group_vars/" + to_bytes(group.name))), errors='surrogate_or_strict')
|
|
||||||
host_results = self._variable_manager.add_group_vars_file(base_path, self._loader)
|
|
||||||
if return_results:
|
|
||||||
results = combine_vars(results, host_results)
|
|
||||||
elif group is None and any(map(lambda ext: host.name + ext in self._host_vars_files, C.YAML_FILENAME_EXTENSIONS)):
|
|
||||||
# same for hostvars in dir/host_vars/name_of_host
|
|
||||||
base_path = to_text(os.path.abspath(os.path.join(to_bytes(basedir), b"host_vars/" + to_bytes(host.name))), errors='surrogate_or_strict')
|
|
||||||
group_results = self._variable_manager.add_host_vars_file(base_path, self._loader)
|
|
||||||
if return_results:
|
|
||||||
results = combine_vars(results, group_results)
|
|
||||||
|
|
||||||
# all done, results is a dictionary of variables for this particular host.
|
|
||||||
return results
|
|
||||||
|
|
||||||
def refresh_inventory(self):
|
|
||||||
|
|
||||||
self.clear_pattern_cache()
|
|
||||||
self.clear_group_dict_cache()
|
|
||||||
|
|
||||||
self._hosts_cache = {}
|
|
||||||
self._vars_per_host = {}
|
|
||||||
self._vars_per_group = {}
|
|
||||||
self.groups = {}
|
|
||||||
|
|
||||||
self.parse_inventory(self.host_list)
|
|
||||||
@ -0,0 +1,281 @@
|
|||||||
|
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
#############################################
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import re
|
||||||
|
|
||||||
|
from ansible import constants as C
|
||||||
|
from ansible.errors import AnsibleError
|
||||||
|
from ansible.inventory.group import Group
|
||||||
|
from ansible.inventory.host import Host
|
||||||
|
from ansible.module_utils.six import iteritems
|
||||||
|
from ansible.module_utils._text import to_bytes
|
||||||
|
from ansible.plugins.cache import FactCache
|
||||||
|
from ansible.utils.vars import combine_vars
|
||||||
|
from ansible.utils.path import basedir
|
||||||
|
|
||||||
|
try:
|
||||||
|
from __main__ import display
|
||||||
|
except ImportError:
|
||||||
|
from ansible.utils.display import Display
|
||||||
|
display = Display()
|
||||||
|
|
||||||
|
class InventoryData(object):
|
||||||
|
"""
|
||||||
|
Holds inventory data (host and group objects).
|
||||||
|
Using it's methods should guarantee expected relationships and data.
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
|
||||||
|
# the inventory object holds a list of groups
|
||||||
|
self.groups = {}
|
||||||
|
self.hosts = {}
|
||||||
|
|
||||||
|
# provides 'groups' magic var, host object has group_names
|
||||||
|
self._groups_dict_cache = {}
|
||||||
|
|
||||||
|
# current localhost, implicit or explicit
|
||||||
|
self.localhost = None
|
||||||
|
|
||||||
|
self.current_source = None
|
||||||
|
|
||||||
|
# Always create the 'all' and 'ungrouped' groups,
|
||||||
|
for group in ('all', 'ungrouped'):
|
||||||
|
self.add_group(group)
|
||||||
|
self.add_child('all', 'ungrouped')
|
||||||
|
|
||||||
|
# prime cache
|
||||||
|
self.cache = FactCache()
|
||||||
|
|
||||||
|
def serialize(self):
|
||||||
|
data = dict()
|
||||||
|
return data
|
||||||
|
|
||||||
|
def deserialize(self, data):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def _create_implicit_localhost(self, pattern):
|
||||||
|
|
||||||
|
if self.localhost:
|
||||||
|
new_host = self.localhost
|
||||||
|
else:
|
||||||
|
new_host = Host(pattern)
|
||||||
|
|
||||||
|
# use 'all' vars but not part of all group
|
||||||
|
new_host.vars = self.groups['all'].get_vars()
|
||||||
|
|
||||||
|
new_host.address = "127.0.0.1"
|
||||||
|
new_host.implicit = True
|
||||||
|
|
||||||
|
if "ansible_python_interpreter" not in new_host.vars:
|
||||||
|
py_interp = sys.executable
|
||||||
|
if not py_interp:
|
||||||
|
# sys.executable is not set in some cornercases. #13585
|
||||||
|
py_interp = '/usr/bin/python'
|
||||||
|
display.warning('Unable to determine python interpreter from sys.executable. Using /usr/bin/python default.'
|
||||||
|
' You can correct this by setting ansible_python_interpreter for localhost')
|
||||||
|
new_host.set_variable("ansible_python_interpreter", py_interp)
|
||||||
|
|
||||||
|
if "ansible_connection" not in new_host.vars:
|
||||||
|
new_host.set_variable("ansible_connection", 'local')
|
||||||
|
|
||||||
|
self.localhost = new_host
|
||||||
|
|
||||||
|
return new_host
|
||||||
|
|
||||||
|
|
||||||
|
def _scan_groups_for_host(self, hostname, localhost=False):
|
||||||
|
''' in case something did not update inventory correctly, fallback to group scan '''
|
||||||
|
|
||||||
|
found = None
|
||||||
|
for group in self.groups.values():
|
||||||
|
for host in group.get_hosts():
|
||||||
|
if hostname == host.name:
|
||||||
|
found = host
|
||||||
|
break
|
||||||
|
if found:
|
||||||
|
break
|
||||||
|
|
||||||
|
if found:
|
||||||
|
display.debug('Found host (%s) in groups but it was missing from main inventory' % hostname)
|
||||||
|
|
||||||
|
return found
|
||||||
|
|
||||||
|
|
||||||
|
def reconcile_inventory(self):
|
||||||
|
''' Ensure inventory basic rules, run after updates '''
|
||||||
|
|
||||||
|
display.debug('Reconcile groups and hosts in inventory.')
|
||||||
|
self.current_source = None
|
||||||
|
|
||||||
|
group_names = set()
|
||||||
|
# set group vars from group_vars/ files and vars plugins
|
||||||
|
for g in self.groups:
|
||||||
|
group = self.groups[g]
|
||||||
|
group_names.add(group.name)
|
||||||
|
|
||||||
|
host_names = set()
|
||||||
|
# get host vars from host_vars/ files and vars plugins
|
||||||
|
for host in self.hosts.values():
|
||||||
|
host_names.add(host.name)
|
||||||
|
|
||||||
|
mygroups = host.get_groups()
|
||||||
|
|
||||||
|
# ensure hosts are always in 'all'
|
||||||
|
if 'all' not in mygroups and not host.implicit:
|
||||||
|
self.add_child('all', host.name)
|
||||||
|
|
||||||
|
if self.groups['ungrouped'] in mygroups:
|
||||||
|
# clear ungrouped of any incorrectly stored by parser
|
||||||
|
if set(mygroups).difference(set([self.groups['all'], self.groups['ungrouped']])):
|
||||||
|
host.remove_group(self.groups['ungrouped'])
|
||||||
|
|
||||||
|
elif not host.implicit:
|
||||||
|
# add ungrouped hosts to ungrouped, except implicit
|
||||||
|
length = len(mygroups)
|
||||||
|
if length == 0 or (length == 1 and all in mygroups):
|
||||||
|
self.add_child('ungrouped', host.name)
|
||||||
|
|
||||||
|
# special case for implicit hosts
|
||||||
|
if host.implicit:
|
||||||
|
host.vars = combine_vars(self.groups['all'].get_vars(), host.vars)
|
||||||
|
|
||||||
|
# warn if overloading identifier as both group and host
|
||||||
|
for conflict in group_names.intersection(host_names):
|
||||||
|
display.warning("Found both group and host with same name: %s" % conflict)
|
||||||
|
|
||||||
|
self._groups_dict_cache = {}
|
||||||
|
|
||||||
|
def get_host(self, hostname):
|
||||||
|
''' fetch host object using name
|
||||||
|
deal with implicit localhost
|
||||||
|
and possible inconsistent inventory '''
|
||||||
|
|
||||||
|
matching_host = self.hosts.get(hostname, None)
|
||||||
|
|
||||||
|
# if host is not in hosts dict
|
||||||
|
if matching_host is None:
|
||||||
|
|
||||||
|
# might need to create implicit localhost
|
||||||
|
if hostname in C.LOCALHOST:
|
||||||
|
matching_host = self._create_implicit_localhost(hostname)
|
||||||
|
|
||||||
|
# might be inconsistent inventory, search groups
|
||||||
|
if matching_host is None:
|
||||||
|
matching_host = self._scan_groups_for_host(hostname)
|
||||||
|
|
||||||
|
# if found/created update hosts dict
|
||||||
|
if matching_host:
|
||||||
|
self.hosts[hostname] = matching_host
|
||||||
|
|
||||||
|
return matching_host
|
||||||
|
|
||||||
|
|
||||||
|
def add_group(self, group):
|
||||||
|
''' adds a group to inventory if not there already '''
|
||||||
|
|
||||||
|
if group not in self.groups:
|
||||||
|
g = Group(group)
|
||||||
|
self.groups[group] = g
|
||||||
|
self._groups_dict_cache = {}
|
||||||
|
display.debug("Added group %s to inventory" % group)
|
||||||
|
else:
|
||||||
|
display.debug("group %s already in inventory" % group)
|
||||||
|
|
||||||
|
def add_host(self, host, group=None, port=None):
|
||||||
|
''' adds a host to inventory and possibly a group if not there already '''
|
||||||
|
|
||||||
|
g = None
|
||||||
|
if group:
|
||||||
|
if group in self.groups:
|
||||||
|
g = self.groups[group]
|
||||||
|
else:
|
||||||
|
raise AnsibleError("Could not find group %s in inventory" % group)
|
||||||
|
|
||||||
|
if host not in self.hosts:
|
||||||
|
h = Host(host, port)
|
||||||
|
self.hosts[host] = h
|
||||||
|
if self.current_source: # set to 'first source' in which host was encountered
|
||||||
|
self.set_variable(host, 'inventory_file', os.path.basename(self.current_source))
|
||||||
|
self.set_variable(host, 'inventory_dir', basedir(self.current_source))
|
||||||
|
else:
|
||||||
|
self.set_variable(host, 'inventory_file', None)
|
||||||
|
self.set_variable(host, 'inventory_dir', None)
|
||||||
|
display.debug("Added host %s to inventory" % (host))
|
||||||
|
|
||||||
|
# set default localhost from inventory to avoid creating an implicit one. Last localhost defined 'wins'.
|
||||||
|
if host in C.LOCALHOST:
|
||||||
|
if self.localhost is None:
|
||||||
|
self.localhost = self.hosts[host]
|
||||||
|
display.vvvv("Set default localhost to %s" % h)
|
||||||
|
else:
|
||||||
|
display.warning("A duplicate localhost-like entry was found (%s). First found localhost was %s" % (h, self.localhost.name))
|
||||||
|
else:
|
||||||
|
h = self.hosts[host]
|
||||||
|
|
||||||
|
if g and host not in g.get_hosts():
|
||||||
|
g.add_host(h)
|
||||||
|
self._groups_dict_cache = {}
|
||||||
|
display.debug("Added host %s to group %s" % (host,group))
|
||||||
|
|
||||||
|
|
||||||
|
def set_variable(self, entity, varname, value):
|
||||||
|
''' sets a varible for an inventory object '''
|
||||||
|
|
||||||
|
if entity in self.groups:
|
||||||
|
inv_object = self.groups[entity]
|
||||||
|
elif entity in self.hosts:
|
||||||
|
inv_object = self.hosts[entity]
|
||||||
|
else:
|
||||||
|
raise AnsibleError("Could not identify group or host named %s" % entity)
|
||||||
|
|
||||||
|
inv_object.set_variable(varname, value)
|
||||||
|
display.debug('set %s for %s' % (varname, entity))
|
||||||
|
|
||||||
|
|
||||||
|
def add_child(self, group, child):
|
||||||
|
''' Add host or group to group '''
|
||||||
|
|
||||||
|
if group in self.groups:
|
||||||
|
g = self.groups[group]
|
||||||
|
if child in self.groups:
|
||||||
|
g.add_child_group(self.groups[child])
|
||||||
|
elif child in self.hosts:
|
||||||
|
g.add_host(self.hosts[child])
|
||||||
|
else:
|
||||||
|
raise AnsibleError("%s is not a known host nor group" % child)
|
||||||
|
self._groups_dict_cache = {}
|
||||||
|
display.debug('Group %s now contains %s' % (group, child))
|
||||||
|
else:
|
||||||
|
raise AnsibleError("%s is not a known group" % group)
|
||||||
|
|
||||||
|
def get_groups_dict(self):
|
||||||
|
"""
|
||||||
|
We merge a 'magic' var 'groups' with group name keys and hostname list values into every host variable set. Cache for speed.
|
||||||
|
"""
|
||||||
|
if not self._groups_dict_cache:
|
||||||
|
for (group_name, group) in iteritems(self.groups):
|
||||||
|
self._groups_dict_cache[group_name] = [h.name for h in group.get_hosts()]
|
||||||
|
|
||||||
|
return self._groups_dict_cache
|
||||||
|
|
||||||
@ -1,299 +0,0 @@
|
|||||||
# (c) 2013, Daniel Hokka Zakrisson <daniel@hozac.com>
|
|
||||||
# (c) 2014, Serge van Ginderachter <serge@vanginderachter.be>
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
#############################################
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
import os
|
|
||||||
|
|
||||||
from ansible import constants as C
|
|
||||||
from ansible.errors import AnsibleError
|
|
||||||
from ansible.utils.vars import combine_vars
|
|
||||||
from ansible.module_utils._text import to_native
|
|
||||||
|
|
||||||
#FIXME: make into plugins
|
|
||||||
from ansible.inventory.ini import InventoryParser as InventoryINIParser
|
|
||||||
from ansible.inventory.yaml import InventoryParser as InventoryYAMLParser
|
|
||||||
from ansible.inventory.script import InventoryScript
|
|
||||||
|
|
||||||
__all__ = ['get_file_parser']
|
|
||||||
|
|
||||||
def get_file_parser(hostsfile, groups, loader):
|
|
||||||
# check to see if the specified file starts with a
|
|
||||||
# shebang (#!/), so if an error is raised by the parser
|
|
||||||
# class we can show a more apropos error
|
|
||||||
|
|
||||||
shebang_present = False
|
|
||||||
processed = False
|
|
||||||
myerr = []
|
|
||||||
parser = None
|
|
||||||
|
|
||||||
try:
|
|
||||||
with open(hostsfile, 'rb') as inv_file:
|
|
||||||
initial_chars = inv_file.read(2)
|
|
||||||
if initial_chars.startswith(b'#!'):
|
|
||||||
shebang_present = True
|
|
||||||
except:
|
|
||||||
pass
|
|
||||||
|
|
||||||
#FIXME: make this 'plugin loop'
|
|
||||||
# script
|
|
||||||
if loader.is_executable(hostsfile):
|
|
||||||
try:
|
|
||||||
parser = InventoryScript(loader=loader, groups=groups, filename=hostsfile)
|
|
||||||
processed = True
|
|
||||||
except Exception as e:
|
|
||||||
myerr.append('Attempted to execute "%s" as inventory script: %s' % (hostsfile, to_native(e)))
|
|
||||||
elif shebang_present:
|
|
||||||
|
|
||||||
myerr.append("The inventory file \'%s\' looks like it should be an executable inventory script, but is not marked executable. "
|
|
||||||
"Perhaps you want to correct this with `chmod +x %s`?" % (hostsfile, hostsfile))
|
|
||||||
|
|
||||||
# YAML/JSON
|
|
||||||
if not processed and not shebang_present and os.path.splitext(hostsfile)[-1] in C.YAML_FILENAME_EXTENSIONS:
|
|
||||||
try:
|
|
||||||
parser = InventoryYAMLParser(loader=loader, groups=groups, filename=hostsfile)
|
|
||||||
processed = True
|
|
||||||
except Exception as e:
|
|
||||||
myerr.append('Attempted to read "%s" as YAML: %s' % (to_native(hostsfile), to_native(e)))
|
|
||||||
|
|
||||||
# ini
|
|
||||||
if not processed and not shebang_present:
|
|
||||||
try:
|
|
||||||
parser = InventoryINIParser(loader=loader, groups=groups, filename=hostsfile)
|
|
||||||
processed = True
|
|
||||||
except Exception as e:
|
|
||||||
myerr.append('Attempted to read "%s" as ini file: %s ' % (to_native(hostsfile), to_native(e)))
|
|
||||||
|
|
||||||
if not processed and myerr:
|
|
||||||
raise AnsibleError('\n'.join(myerr))
|
|
||||||
|
|
||||||
return parser
|
|
||||||
|
|
||||||
class InventoryDirectory(object):
|
|
||||||
''' Host inventory parser for ansible using a directory of inventories. '''
|
|
||||||
|
|
||||||
def __init__(self, loader, groups=None, filename=C.DEFAULT_HOST_LIST):
|
|
||||||
if groups is None:
|
|
||||||
groups = dict()
|
|
||||||
|
|
||||||
self.names = os.listdir(filename)
|
|
||||||
self.names.sort()
|
|
||||||
self.directory = filename
|
|
||||||
self.parsers = []
|
|
||||||
self.hosts = {}
|
|
||||||
self.groups = groups
|
|
||||||
|
|
||||||
self._loader = loader
|
|
||||||
|
|
||||||
for i in self.names:
|
|
||||||
|
|
||||||
# Skip files that end with certain extensions or characters
|
|
||||||
if any(i.endswith(ext) for ext in C.DEFAULT_INVENTORY_IGNORE):
|
|
||||||
continue
|
|
||||||
# Skip hidden files
|
|
||||||
if i.startswith('.') and not i.startswith('./'):
|
|
||||||
continue
|
|
||||||
# These are things inside of an inventory basedir
|
|
||||||
if i in ("host_vars", "group_vars", "vars_plugins"):
|
|
||||||
continue
|
|
||||||
fullpath = os.path.join(self.directory, i)
|
|
||||||
if os.path.isdir(fullpath):
|
|
||||||
parser = InventoryDirectory(loader=loader, groups=groups, filename=fullpath)
|
|
||||||
else:
|
|
||||||
parser = get_file_parser(fullpath, self.groups, loader)
|
|
||||||
if parser is None:
|
|
||||||
#FIXME: needs to use display
|
|
||||||
import warnings
|
|
||||||
warnings.warning("Could not find parser for %s, skipping" % fullpath)
|
|
||||||
continue
|
|
||||||
|
|
||||||
self.parsers.append(parser)
|
|
||||||
|
|
||||||
# retrieve all groups and hosts form the parser and add them to
|
|
||||||
# self, don't look at group lists yet, to avoid
|
|
||||||
# recursion trouble, but just make sure all objects exist in self
|
|
||||||
newgroups = parser.groups.values()
|
|
||||||
for group in newgroups:
|
|
||||||
for host in group.hosts:
|
|
||||||
self._add_host(host)
|
|
||||||
for group in newgroups:
|
|
||||||
self._add_group(group)
|
|
||||||
|
|
||||||
# now check the objects lists so they contain only objects from
|
|
||||||
# self; membership data in groups is already fine (except all &
|
|
||||||
# ungrouped, see later), but might still reference objects not in self
|
|
||||||
for group in self.groups.values():
|
|
||||||
# iterate on a copy of the lists, as those lists get changed in
|
|
||||||
# the loop
|
|
||||||
# list with group's child group objects:
|
|
||||||
for child in group.child_groups[:]:
|
|
||||||
if child != self.groups[child.name]:
|
|
||||||
group.child_groups.remove(child)
|
|
||||||
group.child_groups.append(self.groups[child.name])
|
|
||||||
# list with group's parent group objects:
|
|
||||||
for parent in group.parent_groups[:]:
|
|
||||||
if parent != self.groups[parent.name]:
|
|
||||||
group.parent_groups.remove(parent)
|
|
||||||
group.parent_groups.append(self.groups[parent.name])
|
|
||||||
# list with group's host objects:
|
|
||||||
for host in group.hosts[:]:
|
|
||||||
if host != self.hosts[host.name]:
|
|
||||||
group.hosts.remove(host)
|
|
||||||
group.hosts.append(self.hosts[host.name])
|
|
||||||
# also check here that the group that contains host, is
|
|
||||||
# also contained in the host's group list
|
|
||||||
if group not in self.hosts[host.name].groups:
|
|
||||||
self.hosts[host.name].groups.append(group)
|
|
||||||
|
|
||||||
# extra checks on special groups all and ungrouped
|
|
||||||
# remove hosts from 'ungrouped' if they became member of other groups
|
|
||||||
if 'ungrouped' in self.groups:
|
|
||||||
ungrouped = self.groups['ungrouped']
|
|
||||||
# loop on a copy of ungrouped hosts, as we want to change that list
|
|
||||||
for host in frozenset(ungrouped.hosts):
|
|
||||||
if len(host.groups) > 1:
|
|
||||||
host.groups.remove(ungrouped)
|
|
||||||
ungrouped.hosts.remove(host)
|
|
||||||
|
|
||||||
# remove hosts from 'all' if they became member of other groups
|
|
||||||
# all should only contain direct children, not grandchildren
|
|
||||||
# direct children should have dept == 1
|
|
||||||
if 'all' in self.groups:
|
|
||||||
allgroup = self.groups['all' ]
|
|
||||||
# loop on a copy of all's child groups, as we want to change that list
|
|
||||||
for group in allgroup.child_groups[:]:
|
|
||||||
# groups might once have beeen added to all, and later be added
|
|
||||||
# to another group: we need to remove the link wit all then
|
|
||||||
if len(group.parent_groups) > 1 and allgroup in group.parent_groups:
|
|
||||||
# real children of all have just 1 parent, all
|
|
||||||
# this one has more, so not a direct child of all anymore
|
|
||||||
group.parent_groups.remove(allgroup)
|
|
||||||
allgroup.child_groups.remove(group)
|
|
||||||
elif allgroup not in group.parent_groups:
|
|
||||||
# this group was once added to all, but doesn't list it as
|
|
||||||
# a parent any more; the info in the group is the correct
|
|
||||||
# info
|
|
||||||
allgroup.child_groups.remove(group)
|
|
||||||
|
|
||||||
def _add_group(self, group):
|
|
||||||
""" Merge an existing group or add a new one;
|
|
||||||
Track parent and child groups, and hosts of the new one """
|
|
||||||
|
|
||||||
if group.name not in self.groups:
|
|
||||||
# it's brand new, add him!
|
|
||||||
self.groups[group.name] = group
|
|
||||||
# the Group class does not (yet) implement __eq__/__ne__,
|
|
||||||
# so unlike Host we do a regular comparison here
|
|
||||||
if self.groups[group.name] != group:
|
|
||||||
# different object, merge
|
|
||||||
self._merge_groups(self.groups[group.name], group)
|
|
||||||
|
|
||||||
def _add_host(self, host):
|
|
||||||
if host.name not in self.hosts:
|
|
||||||
# Papa's got a brand new host
|
|
||||||
self.hosts[host.name] = host
|
|
||||||
# because the __eq__/__ne__ methods in Host() compare the
|
|
||||||
# name fields rather than references, we use id() here to
|
|
||||||
# do the object comparison for merges
|
|
||||||
if self.hosts[host.name] != host:
|
|
||||||
# different object, merge
|
|
||||||
self._merge_hosts(self.hosts[host.name], host)
|
|
||||||
|
|
||||||
def _merge_groups(self, group, newgroup):
|
|
||||||
""" Merge all of instance newgroup into group,
|
|
||||||
update parent/child relationships
|
|
||||||
group lists may still contain group objects that exist in self with
|
|
||||||
same name, but was instanciated as a different object in some other
|
|
||||||
inventory parser; these are handled later """
|
|
||||||
|
|
||||||
# name
|
|
||||||
if group.name != newgroup.name:
|
|
||||||
raise AnsibleError("Cannot merge inventory group %s with %s" % (group.name, newgroup.name))
|
|
||||||
|
|
||||||
# depth
|
|
||||||
group.depth = max([group.depth, newgroup.depth])
|
|
||||||
|
|
||||||
# hosts list (host objects are by now already added to self.hosts)
|
|
||||||
for host in newgroup.hosts:
|
|
||||||
grouphosts = dict([(h.name, h) for h in group.hosts])
|
|
||||||
if host.name in grouphosts:
|
|
||||||
# same host name but different object, merge
|
|
||||||
self._merge_hosts(grouphosts[host.name], host)
|
|
||||||
else:
|
|
||||||
# new membership, add host to group from self
|
|
||||||
# group from self will also be added again to host.groups, but
|
|
||||||
# as different object
|
|
||||||
group.add_host(self.hosts[host.name])
|
|
||||||
# now remove this the old object for group in host.groups
|
|
||||||
for hostgroup in [g for g in host.groups]:
|
|
||||||
if hostgroup.name == group.name and hostgroup != self.groups[group.name]:
|
|
||||||
self.hosts[host.name].groups.remove(hostgroup)
|
|
||||||
|
|
||||||
# group child membership relation
|
|
||||||
for newchild in newgroup.child_groups:
|
|
||||||
# dict with existing child groups:
|
|
||||||
childgroups = dict([(g.name, g) for g in group.child_groups])
|
|
||||||
# check if child of new group is already known as a child
|
|
||||||
if newchild.name not in childgroups:
|
|
||||||
self.groups[group.name].add_child_group(newchild)
|
|
||||||
|
|
||||||
# group parent membership relation
|
|
||||||
for newparent in newgroup.parent_groups:
|
|
||||||
# dict with existing parent groups:
|
|
||||||
parentgroups = dict([(g.name, g) for g in group.parent_groups])
|
|
||||||
# check if parent of new group is already known as a parent
|
|
||||||
if newparent.name not in parentgroups:
|
|
||||||
if newparent.name not in self.groups:
|
|
||||||
# group does not exist yet in self, import him
|
|
||||||
self.groups[newparent.name] = newparent
|
|
||||||
# group now exists but not yet as a parent here
|
|
||||||
self.groups[newparent.name].add_child_group(group)
|
|
||||||
|
|
||||||
# variables
|
|
||||||
group.vars = combine_vars(group.vars, newgroup.vars)
|
|
||||||
|
|
||||||
def _merge_hosts(self,host, newhost):
|
|
||||||
""" Merge all of instance newhost into host """
|
|
||||||
|
|
||||||
# name
|
|
||||||
if host.name != newhost.name:
|
|
||||||
raise AnsibleError("Cannot merge host %s with %s" % (host.name, newhost.name))
|
|
||||||
|
|
||||||
# group membership relation
|
|
||||||
for newgroup in newhost.groups:
|
|
||||||
# dict with existing groups:
|
|
||||||
hostgroups = dict([(g.name, g) for g in host.groups])
|
|
||||||
# check if new group is already known as a group
|
|
||||||
if newgroup.name not in hostgroups:
|
|
||||||
if newgroup.name not in self.groups:
|
|
||||||
# group does not exist yet in self, import him
|
|
||||||
self.groups[newgroup.name] = newgroup
|
|
||||||
# group now exists but doesn't have host yet
|
|
||||||
self.groups[newgroup.name].add_host(host)
|
|
||||||
|
|
||||||
# variables
|
|
||||||
host.vars = combine_vars(host.vars, newhost.vars)
|
|
||||||
|
|
||||||
def get_host_variables(self, host):
|
|
||||||
""" Gets additional host variables from all inventories """
|
|
||||||
vars = {}
|
|
||||||
for i in self.parsers:
|
|
||||||
vars.update(i.get_host_variables(host))
|
|
||||||
return vars
|
|
||||||
@ -0,0 +1,35 @@
|
|||||||
|
# (c) 2017, Ansible by RedHat Inc,
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
#############################################
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
from ansible.utils.vars import combine_vars
|
||||||
|
|
||||||
|
|
||||||
|
def sort_groups(groups):
|
||||||
|
return sorted(groups, key=lambda g: (g.depth, g.priority, g.name))
|
||||||
|
|
||||||
|
|
||||||
|
def get_group_vars(groups):
|
||||||
|
|
||||||
|
results = {}
|
||||||
|
for group in sort_groups(groups):
|
||||||
|
results = combine_vars(results, group.get_vars())
|
||||||
|
|
||||||
|
return results
|
||||||
@ -0,0 +1,599 @@
|
|||||||
|
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
#############################################
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import fnmatch
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import itertools
|
||||||
|
|
||||||
|
from ansible import constants as C
|
||||||
|
from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError
|
||||||
|
from ansible.inventory.data import InventoryData
|
||||||
|
from ansible.module_utils.six import string_types
|
||||||
|
from ansible.module_utils._text import to_bytes, to_text
|
||||||
|
from ansible.parsing.utils.addresses import parse_address
|
||||||
|
from ansible.plugins import PluginLoader
|
||||||
|
from ansible.utils.path import unfrackpath
|
||||||
|
|
||||||
|
try:
|
||||||
|
from __main__ import display
|
||||||
|
except ImportError:
|
||||||
|
from ansible.utils.display import Display
|
||||||
|
display = Display()
|
||||||
|
|
||||||
|
HOSTS_PATTERNS_CACHE = {}
|
||||||
|
|
||||||
|
IGNORED_ALWAYS = [b"^\.", b"^host_vars$", b"^group_vars$", b"^vars_plugins$"]
|
||||||
|
IGNORED_PATTERNS = [ to_bytes(x) for x in C.INVENTORY_IGNORE_PATTERNS ]
|
||||||
|
IGNORED_EXTS = [b'%s$' % to_bytes(re.escape(x)) for x in C.INVENTORY_IGNORE_EXTS]
|
||||||
|
|
||||||
|
IGNORED = re.compile(b'|'.join(IGNORED_ALWAYS + IGNORED_PATTERNS + IGNORED_EXTS))
|
||||||
|
|
||||||
|
def order_patterns(patterns):
|
||||||
|
''' takes a list of patterns and reorders them by modifier to apply them consistently '''
|
||||||
|
|
||||||
|
# FIXME: this goes away if we apply patterns incrementally or by groups
|
||||||
|
pattern_regular = []
|
||||||
|
pattern_intersection = []
|
||||||
|
pattern_exclude = []
|
||||||
|
for p in patterns:
|
||||||
|
if p.startswith("!"):
|
||||||
|
pattern_exclude.append(p)
|
||||||
|
elif p.startswith("&"):
|
||||||
|
pattern_intersection.append(p)
|
||||||
|
elif p:
|
||||||
|
pattern_regular.append(p)
|
||||||
|
|
||||||
|
# if no regular pattern was given, hence only exclude and/or intersection
|
||||||
|
# make that magically work
|
||||||
|
if pattern_regular == []:
|
||||||
|
pattern_regular = ['all']
|
||||||
|
|
||||||
|
# when applying the host selectors, run those without the "&" or "!"
|
||||||
|
# first, then the &s, then the !s.
|
||||||
|
return pattern_regular + pattern_intersection + pattern_exclude
|
||||||
|
|
||||||
|
|
||||||
|
def split_host_pattern(pattern):
|
||||||
|
"""
|
||||||
|
Takes a string containing host patterns separated by commas (or a list
|
||||||
|
thereof) and returns a list of single patterns (which may not contain
|
||||||
|
commas). Whitespace is ignored.
|
||||||
|
|
||||||
|
Also accepts ':' as a separator for backwards compatibility, but it is
|
||||||
|
not recommended due to the conflict with IPv6 addresses and host ranges.
|
||||||
|
|
||||||
|
Example: 'a,b[1], c[2:3] , d' -> ['a', 'b[1]', 'c[2:3]', 'd']
|
||||||
|
"""
|
||||||
|
|
||||||
|
if isinstance(pattern, list):
|
||||||
|
return list(itertools.chain(*map(split_host_pattern, pattern)))
|
||||||
|
|
||||||
|
# If it's got commas in it, we'll treat it as a straightforward
|
||||||
|
# comma-separated list of patterns.
|
||||||
|
|
||||||
|
elif ',' in pattern:
|
||||||
|
patterns = re.split('\s*,\s*', pattern)
|
||||||
|
|
||||||
|
# If it doesn't, it could still be a single pattern. This accounts for
|
||||||
|
# non-separator uses of colons: IPv6 addresses and [x:y] host ranges.
|
||||||
|
else:
|
||||||
|
try:
|
||||||
|
(base, port) = parse_address(pattern, allow_ranges=True)
|
||||||
|
patterns = [pattern]
|
||||||
|
except:
|
||||||
|
# The only other case we accept is a ':'-separated list of patterns.
|
||||||
|
# This mishandles IPv6 addresses, and is retained only for backwards
|
||||||
|
# compatibility.
|
||||||
|
patterns = re.findall(
|
||||||
|
r'''(?: # We want to match something comprising:
|
||||||
|
[^\s:\[\]] # (anything other than whitespace or ':[]'
|
||||||
|
| # ...or...
|
||||||
|
\[[^\]]*\] # a single complete bracketed expression)
|
||||||
|
)+ # occurring once or more
|
||||||
|
''', pattern, re.X
|
||||||
|
)
|
||||||
|
|
||||||
|
return [p.strip() for p in patterns]
|
||||||
|
|
||||||
|
class InventoryManager(object):
|
||||||
|
''' Creates and manages inventory '''
|
||||||
|
|
||||||
|
def __init__(self, loader, sources=None):
|
||||||
|
|
||||||
|
# base objects
|
||||||
|
self._loader = loader
|
||||||
|
self._inventory = InventoryData()
|
||||||
|
|
||||||
|
# a list of host(names) to contain current inquiries to
|
||||||
|
self._restriction = None
|
||||||
|
self._subset = None
|
||||||
|
|
||||||
|
# caches
|
||||||
|
self._pattern_cache = {} # resolved host patterns
|
||||||
|
self._inventory_plugins = {} # for generating inventory
|
||||||
|
|
||||||
|
# the inventory dirs, files, script paths or lists of hosts
|
||||||
|
if sources is None:
|
||||||
|
self._sources = []
|
||||||
|
elif isinstance(sources, string_types):
|
||||||
|
self._sources = [ sources ]
|
||||||
|
else:
|
||||||
|
self._sources = sources
|
||||||
|
|
||||||
|
# get to work!
|
||||||
|
self.parse_sources()
|
||||||
|
|
||||||
|
@property
|
||||||
|
def localhost(self):
|
||||||
|
return self._inventory.localhost
|
||||||
|
|
||||||
|
@property
|
||||||
|
def groups(self):
|
||||||
|
return self._inventory.groups
|
||||||
|
|
||||||
|
@property
|
||||||
|
def hosts(self):
|
||||||
|
return self._inventory.hosts
|
||||||
|
|
||||||
|
def get_vars(self, *args, **kwargs):
|
||||||
|
return self._inventory.get_vars(args, kwargs)
|
||||||
|
|
||||||
|
def add_host(self, host, group=None, port=None):
|
||||||
|
return self._inventory.add_host(host, group, port)
|
||||||
|
|
||||||
|
def add_group(self, group):
|
||||||
|
return self._inventory.add_group(group)
|
||||||
|
|
||||||
|
def get_groups_dict(self):
|
||||||
|
return self._inventory.get_groups_dict()
|
||||||
|
|
||||||
|
def reconcile_inventory(self):
|
||||||
|
return self._inventory.reconcile_inventory()
|
||||||
|
|
||||||
|
def get_host(self, hostname):
|
||||||
|
return self._inventory.get_host(hostname)
|
||||||
|
|
||||||
|
def _setup_inventory_plugins(self):
|
||||||
|
''' sets up loaded inventory plugins for usage '''
|
||||||
|
|
||||||
|
inventory_loader = PluginLoader( 'InventoryModule', 'ansible.plugins.inventory', 'inventory_plugins', 'inventory_plugins')
|
||||||
|
display.vvvv('setting up inventory plugins')
|
||||||
|
|
||||||
|
for name in C.INVENTORY_ENABLED:
|
||||||
|
plugin = inventory_loader.get(name)
|
||||||
|
name = os.path.splitext(os.path.basename(plugin._original_path))[0]
|
||||||
|
self._inventory_plugins[name] = plugin
|
||||||
|
|
||||||
|
if not self._inventory_plugins:
|
||||||
|
raise AnsibleError("No inventory plugins available to generate inventory, make sure you have at least one whitelisted.")
|
||||||
|
|
||||||
|
def parse_sources(self, cache=True):
|
||||||
|
''' iterate over inventory sources and parse each one to populate it'''
|
||||||
|
|
||||||
|
self._setup_inventory_plugins()
|
||||||
|
|
||||||
|
parsed = False
|
||||||
|
# allow for multiple inventory parsing
|
||||||
|
for source in self._sources:
|
||||||
|
|
||||||
|
if source:
|
||||||
|
if ',' not in source:
|
||||||
|
source = unfrackpath(source, follow=False)
|
||||||
|
parse = self.parse_source(source, cache=cache)
|
||||||
|
if parse and not parsed:
|
||||||
|
parsed = True
|
||||||
|
|
||||||
|
if parsed:
|
||||||
|
# do post processing
|
||||||
|
self._inventory.reconcile_inventory()
|
||||||
|
else:
|
||||||
|
display.warning("No inventory was parsed, only implicit localhost is available")
|
||||||
|
|
||||||
|
self._inventory_plugins = {}
|
||||||
|
|
||||||
|
def parse_source(self, source, cache=True):
|
||||||
|
''' Generate or update inventory for the source provided '''
|
||||||
|
|
||||||
|
parsed = False
|
||||||
|
display.debug(u'Examining possible inventory source: %s' % source)
|
||||||
|
|
||||||
|
b_source = to_bytes(source)
|
||||||
|
# process directories as a collection of inventories
|
||||||
|
if os.path.isdir(b_source):
|
||||||
|
display.debug(u'Searching for inventory files in directory: %s' % source)
|
||||||
|
for i in sorted(os.listdir(b_source)):
|
||||||
|
|
||||||
|
display.debug(u'Considering %s' % i)
|
||||||
|
# Skip hidden files and stuff we explicitly ignore
|
||||||
|
if IGNORED.search(i):
|
||||||
|
continue
|
||||||
|
|
||||||
|
# recursively deal with directory entries
|
||||||
|
fullpath = os.path.join(b_source, i)
|
||||||
|
parsed_this_one = self.parse_source(to_text(fullpath))
|
||||||
|
display.debug(u'parsed %s as %s' % (fullpath, parsed_this_one))
|
||||||
|
if not parsed:
|
||||||
|
parsed = parsed_this_one
|
||||||
|
else:
|
||||||
|
# left with strings or files, let plugins figure it out
|
||||||
|
|
||||||
|
# set so new hosts can use for inventory_file/dir vasr
|
||||||
|
self._inventory.current_source = source
|
||||||
|
|
||||||
|
# get inventory plugins if needed, there should always be at least one generator
|
||||||
|
if not self._inventory_plugins:
|
||||||
|
self._setup_inventory_plugins()
|
||||||
|
|
||||||
|
# try source with each plugin
|
||||||
|
failures = []
|
||||||
|
for plugin in self._inventory_plugins:
|
||||||
|
display.debug(u'Attempting to use plugin %s' % plugin)
|
||||||
|
|
||||||
|
# initialize
|
||||||
|
inv = self._inventory_plugins[plugin]
|
||||||
|
if inv.verify_file(source):
|
||||||
|
try:
|
||||||
|
inv.parse(self._inventory, self._loader, source, cache=cache)
|
||||||
|
parsed = True
|
||||||
|
display.vvv(u'Parsed %s inventory source with %s plugin' % (to_text(source), plugin))
|
||||||
|
break
|
||||||
|
except AnsibleParserError as e:
|
||||||
|
failures.append(u'\n* Failed to parse %s with %s inventory plugin: %s\n' %(to_text(source), plugin, to_text(e)))
|
||||||
|
else:
|
||||||
|
display.debug(u'%s did not meet %s requirements' % (to_text(source), plugin))
|
||||||
|
else:
|
||||||
|
if failures:
|
||||||
|
# only if no plugin processed files should we show errors.
|
||||||
|
for fail in failures:
|
||||||
|
display.warning(fail)
|
||||||
|
|
||||||
|
if not parsed:
|
||||||
|
display.warning(u"Unable to parse %s as an inventory source" % to_text(source))
|
||||||
|
|
||||||
|
# clear up, jic
|
||||||
|
self._inventory.current_source = None
|
||||||
|
|
||||||
|
return parsed
|
||||||
|
|
||||||
|
def clear_caches(self):
|
||||||
|
''' clear all caches '''
|
||||||
|
global HOSTS_PATTERNS_CACHE
|
||||||
|
HOSTS_PATTERNS_CACHE = {}
|
||||||
|
self._pattern_cache = {}
|
||||||
|
#FIXME: flush inventory cache
|
||||||
|
|
||||||
|
def refresh_inventory(self):
|
||||||
|
''' recalculate inventory '''
|
||||||
|
|
||||||
|
self.clear_caches()
|
||||||
|
self._inventory = InventoryData()
|
||||||
|
self.parse_sources(cache=False)
|
||||||
|
|
||||||
|
def _match(self, string, pattern_str):
|
||||||
|
try:
|
||||||
|
if pattern_str.startswith('~'):
|
||||||
|
return re.search(pattern_str[1:], string)
|
||||||
|
else:
|
||||||
|
return fnmatch.fnmatch(string, pattern_str)
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleError('invalid host pattern (%s): %s' % (pattern_str, str(e)))
|
||||||
|
|
||||||
|
def _match_list(self, items, item_attr, pattern_str):
|
||||||
|
results = []
|
||||||
|
try:
|
||||||
|
if not pattern_str.startswith('~'):
|
||||||
|
pattern = re.compile(fnmatch.translate(pattern_str))
|
||||||
|
else:
|
||||||
|
pattern = re.compile(pattern_str[1:])
|
||||||
|
except Exception:
|
||||||
|
raise AnsibleError('invalid host list pattern: %s' % pattern_str)
|
||||||
|
|
||||||
|
for item in items:
|
||||||
|
if pattern.match(getattr(item, item_attr)):
|
||||||
|
results.append(item)
|
||||||
|
return results
|
||||||
|
|
||||||
|
def get_hosts(self, pattern="all", ignore_limits=False, ignore_restrictions=False, order=None):
|
||||||
|
"""
|
||||||
|
Takes a pattern or list of patterns and returns a list of matching
|
||||||
|
inventory host names, taking into account any active restrictions
|
||||||
|
or applied subsets
|
||||||
|
"""
|
||||||
|
|
||||||
|
# Check if pattern already computed
|
||||||
|
if isinstance(pattern, list):
|
||||||
|
pattern_hash = u":".join(pattern)
|
||||||
|
else:
|
||||||
|
pattern_hash = pattern
|
||||||
|
|
||||||
|
if not ignore_limits and self._subset:
|
||||||
|
pattern_hash += u":%s" % to_text(self._subset)
|
||||||
|
|
||||||
|
if not ignore_restrictions and self._restriction:
|
||||||
|
pattern_hash += u":%s" % to_text(self._restriction)
|
||||||
|
|
||||||
|
if pattern_hash not in HOSTS_PATTERNS_CACHE:
|
||||||
|
|
||||||
|
patterns = split_host_pattern(pattern)
|
||||||
|
hosts = self._evaluate_patterns(patterns)
|
||||||
|
|
||||||
|
# mainly useful for hostvars[host] access
|
||||||
|
if not ignore_limits and self._subset:
|
||||||
|
# exclude hosts not in a subset, if defined
|
||||||
|
subset = self._evaluate_patterns(self._subset)
|
||||||
|
hosts = [ h for h in hosts if h in subset ]
|
||||||
|
|
||||||
|
if not ignore_restrictions and self._restriction:
|
||||||
|
# exclude hosts mentioned in any restriction (ex: failed hosts)
|
||||||
|
hosts = [ h for h in hosts if h.name in self._restriction ]
|
||||||
|
|
||||||
|
seen = set()
|
||||||
|
HOSTS_PATTERNS_CACHE[pattern_hash] = [x for x in hosts if x not in seen and not seen.add(x)]
|
||||||
|
|
||||||
|
# sort hosts list if needed (should only happen when called from strategy)
|
||||||
|
if order in ['sorted', 'reverse_sorted']:
|
||||||
|
from operator import attrgetter
|
||||||
|
hosts = sorted(HOSTS_PATTERNS_CACHE[pattern_hash][:], key=attrgetter('name'), reverse=(order == 'reverse_sorted'))
|
||||||
|
elif order == 'reverse_inventory':
|
||||||
|
hosts = sorted(HOSTS_PATTERNS_CACHE[pattern_hash][:], reverse=True)
|
||||||
|
else:
|
||||||
|
hosts = HOSTS_PATTERNS_CACHE[pattern_hash][:]
|
||||||
|
if order == 'shuffle':
|
||||||
|
from random import shuffle
|
||||||
|
shuffle(hosts)
|
||||||
|
elif order not in [None, 'inventory']:
|
||||||
|
AnsibleOptionsError("Invalid 'order' specified for inventory hosts: %s" % order)
|
||||||
|
|
||||||
|
return hosts
|
||||||
|
|
||||||
|
|
||||||
|
def _evaluate_patterns(self, patterns):
|
||||||
|
"""
|
||||||
|
Takes a list of patterns and returns a list of matching host names,
|
||||||
|
taking into account any negative and intersection patterns.
|
||||||
|
"""
|
||||||
|
|
||||||
|
patterns = order_patterns(patterns)
|
||||||
|
hosts = []
|
||||||
|
|
||||||
|
for p in patterns:
|
||||||
|
# avoid resolving a pattern that is a plain host
|
||||||
|
if p in self._inventory.hosts:
|
||||||
|
hosts.append(self._inventory.get_host(p))
|
||||||
|
else:
|
||||||
|
that = self._match_one_pattern(p)
|
||||||
|
if p.startswith("!"):
|
||||||
|
hosts = [ h for h in hosts if h not in that ]
|
||||||
|
elif p.startswith("&"):
|
||||||
|
hosts = [ h for h in hosts if h in that ]
|
||||||
|
else:
|
||||||
|
to_append = [ h for h in that if h.name not in [ y.name for y in hosts ] ]
|
||||||
|
hosts.extend(to_append)
|
||||||
|
return hosts
|
||||||
|
|
||||||
|
def _match_one_pattern(self, pattern):
|
||||||
|
"""
|
||||||
|
Takes a single pattern and returns a list of matching host names.
|
||||||
|
Ignores intersection (&) and exclusion (!) specifiers.
|
||||||
|
|
||||||
|
The pattern may be:
|
||||||
|
|
||||||
|
1. A regex starting with ~, e.g. '~[abc]*'
|
||||||
|
2. A shell glob pattern with ?/*/[chars]/[!chars], e.g. 'foo*'
|
||||||
|
3. An ordinary word that matches itself only, e.g. 'foo'
|
||||||
|
|
||||||
|
The pattern is matched using the following rules:
|
||||||
|
|
||||||
|
1. If it's 'all', it matches all hosts in all groups.
|
||||||
|
2. Otherwise, for each known group name:
|
||||||
|
(a) if it matches the group name, the results include all hosts
|
||||||
|
in the group or any of its children.
|
||||||
|
(b) otherwise, if it matches any hosts in the group, the results
|
||||||
|
include the matching hosts.
|
||||||
|
|
||||||
|
This means that 'foo*' may match one or more groups (thus including all
|
||||||
|
hosts therein) but also hosts in other groups.
|
||||||
|
|
||||||
|
The built-in groups 'all' and 'ungrouped' are special. No pattern can
|
||||||
|
match these group names (though 'all' behaves as though it matches, as
|
||||||
|
described above). The word 'ungrouped' can match a host of that name,
|
||||||
|
and patterns like 'ungr*' and 'al*' can match either hosts or groups
|
||||||
|
other than all and ungrouped.
|
||||||
|
|
||||||
|
If the pattern matches one or more group names according to these rules,
|
||||||
|
it may have an optional range suffix to select a subset of the results.
|
||||||
|
This is allowed only if the pattern is not a regex, i.e. '~foo[1]' does
|
||||||
|
not work (the [1] is interpreted as part of the regex), but 'foo*[1]'
|
||||||
|
would work if 'foo*' matched the name of one or more groups.
|
||||||
|
|
||||||
|
Duplicate matches are always eliminated from the results.
|
||||||
|
"""
|
||||||
|
|
||||||
|
if pattern.startswith("&") or pattern.startswith("!"):
|
||||||
|
pattern = pattern[1:]
|
||||||
|
|
||||||
|
if pattern not in self._pattern_cache:
|
||||||
|
(expr, slice) = self._split_subscript(pattern)
|
||||||
|
hosts = self._enumerate_matches(expr)
|
||||||
|
try:
|
||||||
|
hosts = self._apply_subscript(hosts, slice)
|
||||||
|
except IndexError:
|
||||||
|
raise AnsibleError("No hosts matched the subscripted pattern '%s'" % pattern)
|
||||||
|
self._pattern_cache[pattern] = hosts
|
||||||
|
|
||||||
|
return self._pattern_cache[pattern]
|
||||||
|
|
||||||
|
def _split_subscript(self, pattern):
|
||||||
|
"""
|
||||||
|
Takes a pattern, checks if it has a subscript, and returns the pattern
|
||||||
|
without the subscript and a (start,end) tuple representing the given
|
||||||
|
subscript (or None if there is no subscript).
|
||||||
|
|
||||||
|
Validates that the subscript is in the right syntax, but doesn't make
|
||||||
|
sure the actual indices make sense in context.
|
||||||
|
"""
|
||||||
|
|
||||||
|
# Do not parse regexes for enumeration info
|
||||||
|
if pattern.startswith('~'):
|
||||||
|
return (pattern, None)
|
||||||
|
|
||||||
|
# We want a pattern followed by an integer or range subscript.
|
||||||
|
# (We can't be more restrictive about the expression because the
|
||||||
|
# fnmatch semantics permit [\[:\]] to occur.)
|
||||||
|
|
||||||
|
pattern_with_subscript = re.compile(
|
||||||
|
r'''^
|
||||||
|
(.+) # A pattern expression ending with...
|
||||||
|
\[(?: # A [subscript] expression comprising:
|
||||||
|
(-?[0-9]+)| # A single positive or negative number
|
||||||
|
([0-9]+)([:-]) # Or an x:y or x: range.
|
||||||
|
([0-9]*)
|
||||||
|
)\]
|
||||||
|
$
|
||||||
|
''', re.X
|
||||||
|
)
|
||||||
|
|
||||||
|
subscript = None
|
||||||
|
m = pattern_with_subscript.match(pattern)
|
||||||
|
if m:
|
||||||
|
(pattern, idx, start, sep, end) = m.groups()
|
||||||
|
if idx:
|
||||||
|
subscript = (int(idx), None)
|
||||||
|
else:
|
||||||
|
if not end:
|
||||||
|
end = -1
|
||||||
|
subscript = (int(start), int(end))
|
||||||
|
if sep == '-':
|
||||||
|
display.warning("Use [x:y] inclusive subscripts instead of [x-y] which has been removed")
|
||||||
|
|
||||||
|
return (pattern, subscript)
|
||||||
|
|
||||||
|
def _apply_subscript(self, hosts, subscript):
|
||||||
|
"""
|
||||||
|
Takes a list of hosts and a (start,end) tuple and returns the subset of
|
||||||
|
hosts based on the subscript (which may be None to return all hosts).
|
||||||
|
"""
|
||||||
|
|
||||||
|
if not hosts or not subscript:
|
||||||
|
return hosts
|
||||||
|
|
||||||
|
(start, end) = subscript
|
||||||
|
|
||||||
|
if end:
|
||||||
|
if end == -1:
|
||||||
|
end = len(hosts)-1
|
||||||
|
return hosts[start:end+1]
|
||||||
|
else:
|
||||||
|
return [ hosts[start] ]
|
||||||
|
|
||||||
|
def _enumerate_matches(self, pattern):
|
||||||
|
"""
|
||||||
|
Returns a list of host names matching the given pattern according to the
|
||||||
|
rules explained above in _match_one_pattern.
|
||||||
|
"""
|
||||||
|
|
||||||
|
results = []
|
||||||
|
|
||||||
|
def __append_host_to_results(host):
|
||||||
|
if host.name not in results:
|
||||||
|
if not host.implicit:
|
||||||
|
results.append(host)
|
||||||
|
|
||||||
|
matched = False
|
||||||
|
for group in self._inventory.groups.values():
|
||||||
|
if self._match(to_text(group.name), pattern):
|
||||||
|
matched = True
|
||||||
|
for host in group.get_hosts():
|
||||||
|
__append_host_to_results(host)
|
||||||
|
else:
|
||||||
|
matching_hosts = self._match_list(group.get_hosts(), 'name', pattern)
|
||||||
|
if matching_hosts:
|
||||||
|
matched = True
|
||||||
|
for host in matching_hosts:
|
||||||
|
__append_host_to_results(host)
|
||||||
|
|
||||||
|
if not results and pattern in C.LOCALHOST:
|
||||||
|
# get_host autocreates implicit when needed
|
||||||
|
implicit = self._inventory.get_host(pattern)
|
||||||
|
if implicit:
|
||||||
|
results.append(implicit)
|
||||||
|
matched = True
|
||||||
|
|
||||||
|
if not matched:
|
||||||
|
display.warning("Could not match supplied host pattern, ignoring: %s" % pattern)
|
||||||
|
return results
|
||||||
|
|
||||||
|
def list_hosts(self, pattern="all"):
|
||||||
|
""" return a list of hostnames for a pattern """
|
||||||
|
#FIXME: cache?
|
||||||
|
result = [ h for h in self.get_hosts(pattern) ]
|
||||||
|
|
||||||
|
# allow implicit localhost if pattern matches and no other results
|
||||||
|
if len(result) == 0 and pattern in C.LOCALHOST:
|
||||||
|
result = [pattern]
|
||||||
|
|
||||||
|
return result
|
||||||
|
|
||||||
|
def list_groups(self):
|
||||||
|
#FIXME: cache?
|
||||||
|
return sorted(self._inventory.groups.keys(), key=lambda x: x)
|
||||||
|
|
||||||
|
def restrict_to_hosts(self, restriction):
|
||||||
|
"""
|
||||||
|
Restrict list operations to the hosts given in restriction. This is used
|
||||||
|
to batch serial operations in main playbook code, don't use this for other
|
||||||
|
reasons.
|
||||||
|
"""
|
||||||
|
if restriction is None:
|
||||||
|
return
|
||||||
|
elif not isinstance(restriction, list):
|
||||||
|
restriction = [ restriction ]
|
||||||
|
self._restriction = [ h.name for h in restriction ]
|
||||||
|
|
||||||
|
def subset(self, subset_pattern):
|
||||||
|
"""
|
||||||
|
Limits inventory results to a subset of inventory that matches a given
|
||||||
|
pattern, such as to select a given geographic of numeric slice amongst
|
||||||
|
a previous 'hosts' selection that only select roles, or vice versa.
|
||||||
|
Corresponds to --limit parameter to ansible-playbook
|
||||||
|
"""
|
||||||
|
if subset_pattern is None:
|
||||||
|
self._subset = None
|
||||||
|
else:
|
||||||
|
subset_patterns = split_host_pattern(subset_pattern)
|
||||||
|
results = []
|
||||||
|
# allow Unix style @filename data
|
||||||
|
for x in subset_patterns:
|
||||||
|
if x.startswith("@"):
|
||||||
|
fd = open(x[1:])
|
||||||
|
results.extend(fd.read().split("\n"))
|
||||||
|
fd.close()
|
||||||
|
else:
|
||||||
|
results.append(x)
|
||||||
|
self._subset = results
|
||||||
|
|
||||||
|
def remove_restriction(self):
|
||||||
|
""" Do not restrict list operations """
|
||||||
|
self._restriction = None
|
||||||
|
|
||||||
|
def clear_pattern_cache(self):
|
||||||
|
self._pattern_cache = {}
|
||||||
@ -1,170 +0,0 @@
|
|||||||
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
#############################################
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
import os
|
|
||||||
import subprocess
|
|
||||||
import sys
|
|
||||||
from collections import Mapping
|
|
||||||
|
|
||||||
from ansible import constants as C
|
|
||||||
from ansible.errors import AnsibleError
|
|
||||||
from ansible.inventory.host import Host
|
|
||||||
from ansible.inventory.group import Group
|
|
||||||
from ansible.module_utils.basic import json_dict_bytes_to_unicode
|
|
||||||
from ansible.module_utils.six import iteritems
|
|
||||||
from ansible.module_utils._text import to_native, to_text
|
|
||||||
|
|
||||||
|
|
||||||
class InventoryScript:
|
|
||||||
''' Host inventory parser for ansible using external inventory scripts. '''
|
|
||||||
|
|
||||||
def __init__(self, loader, groups=None, filename=C.DEFAULT_HOST_LIST):
|
|
||||||
if groups is None:
|
|
||||||
groups = dict()
|
|
||||||
|
|
||||||
self._loader = loader
|
|
||||||
self.groups = groups
|
|
||||||
|
|
||||||
# Support inventory scripts that are not prefixed with some
|
|
||||||
# path information but happen to be in the current working
|
|
||||||
# directory when '.' is not in PATH.
|
|
||||||
self.filename = os.path.abspath(filename)
|
|
||||||
cmd = [ self.filename, "--list" ]
|
|
||||||
try:
|
|
||||||
sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
||||||
except OSError as e:
|
|
||||||
raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
|
|
||||||
(stdout, stderr) = sp.communicate()
|
|
||||||
|
|
||||||
if sp.returncode != 0:
|
|
||||||
raise AnsibleError("Inventory script (%s) had an execution error: %s " % (filename,stderr))
|
|
||||||
|
|
||||||
# make sure script output is unicode so that json loader will output
|
|
||||||
# unicode strings itself
|
|
||||||
try:
|
|
||||||
self.data = to_text(stdout, errors="strict")
|
|
||||||
except Exception as e:
|
|
||||||
raise AnsibleError("inventory data from {0} contained characters that cannot be interpreted as UTF-8: {1}".format(to_native(self.filename),
|
|
||||||
to_native(e)))
|
|
||||||
|
|
||||||
# see comment about _meta below
|
|
||||||
self.host_vars_from_top = None
|
|
||||||
self._parse(stderr)
|
|
||||||
|
|
||||||
def _parse(self, err):
|
|
||||||
|
|
||||||
all_hosts = {}
|
|
||||||
|
|
||||||
# not passing from_remote because data from CMDB is trusted
|
|
||||||
try:
|
|
||||||
self.raw = self._loader.load(self.data)
|
|
||||||
except Exception as e:
|
|
||||||
sys.stderr.write(to_native(err) + "\n")
|
|
||||||
raise AnsibleError("failed to parse executable inventory script results from {0}: {1}".format(to_native(self.filename), to_native(e)))
|
|
||||||
|
|
||||||
if not isinstance(self.raw, Mapping):
|
|
||||||
sys.stderr.write(to_native(err) + "\n")
|
|
||||||
raise AnsibleError("failed to parse executable inventory script results from {0}: data needs to be formatted "
|
|
||||||
"as a json dict".format(to_native(self.filename)))
|
|
||||||
|
|
||||||
group = None
|
|
||||||
for (group_name, data) in self.raw.items():
|
|
||||||
|
|
||||||
# in Ansible 1.3 and later, a "_meta" subelement may contain
|
|
||||||
# a variable "hostvars" which contains a hash for each host
|
|
||||||
# if this "hostvars" exists at all then do not call --host for each
|
|
||||||
# host. This is for efficiency and scripts should still return data
|
|
||||||
# if called with --host for backwards compat with 1.2 and earlier.
|
|
||||||
|
|
||||||
if group_name == '_meta':
|
|
||||||
if 'hostvars' in data:
|
|
||||||
self.host_vars_from_top = data['hostvars']
|
|
||||||
continue
|
|
||||||
|
|
||||||
if group_name not in self.groups:
|
|
||||||
group = self.groups[group_name] = Group(group_name)
|
|
||||||
|
|
||||||
group = self.groups[group_name]
|
|
||||||
host = None
|
|
||||||
|
|
||||||
if not isinstance(data, dict):
|
|
||||||
data = {'hosts': data}
|
|
||||||
# is not those subkeys, then simplified syntax, host with vars
|
|
||||||
elif not any(k in data for k in ('hosts','vars','children')):
|
|
||||||
data = {'hosts': [group_name], 'vars': data}
|
|
||||||
|
|
||||||
if 'hosts' in data:
|
|
||||||
if not isinstance(data['hosts'], list):
|
|
||||||
raise AnsibleError("You defined a group \"%s\" with bad "
|
|
||||||
"data for the host list:\n %s" % (group_name, data))
|
|
||||||
|
|
||||||
for hostname in data['hosts']:
|
|
||||||
if hostname not in all_hosts:
|
|
||||||
all_hosts[hostname] = Host(hostname)
|
|
||||||
host = all_hosts[hostname]
|
|
||||||
group.add_host(host)
|
|
||||||
|
|
||||||
if 'vars' in data:
|
|
||||||
if not isinstance(data['vars'], dict):
|
|
||||||
raise AnsibleError("You defined a group \"%s\" with bad "
|
|
||||||
"data for variables:\n %s" % (group_name, data))
|
|
||||||
|
|
||||||
for k, v in iteritems(data['vars']):
|
|
||||||
group.set_variable(k, v)
|
|
||||||
|
|
||||||
# Separate loop to ensure all groups are defined
|
|
||||||
for (group_name, data) in self.raw.items():
|
|
||||||
if group_name == '_meta':
|
|
||||||
continue
|
|
||||||
if isinstance(data, dict) and 'children' in data:
|
|
||||||
for child_name in data['children']:
|
|
||||||
if child_name in self.groups:
|
|
||||||
self.groups[group_name].add_child_group(self.groups[child_name])
|
|
||||||
|
|
||||||
# Finally, add all top-level groups as children of 'all'.
|
|
||||||
# We exclude ungrouped here because it was already added as a child of
|
|
||||||
# 'all' at the time it was created.
|
|
||||||
|
|
||||||
for group in self.groups.values():
|
|
||||||
if group.depth == 0 and group.name not in ('all', 'ungrouped'):
|
|
||||||
self.groups['all'].add_child_group(group)
|
|
||||||
|
|
||||||
def get_host_variables(self, host):
|
|
||||||
""" Runs <script> --host <hostname> to determine additional host variables """
|
|
||||||
if self.host_vars_from_top is not None:
|
|
||||||
try:
|
|
||||||
got = self.host_vars_from_top.get(host.name, {})
|
|
||||||
except AttributeError as e:
|
|
||||||
raise AnsibleError("Improperly formatted host information for %s: %s" % (host.name,to_native(e)))
|
|
||||||
return got
|
|
||||||
|
|
||||||
cmd = [self.filename, "--host", host.name]
|
|
||||||
try:
|
|
||||||
sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
||||||
except OSError as e:
|
|
||||||
raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
|
|
||||||
(out, err) = sp.communicate()
|
|
||||||
if out.strip() == '':
|
|
||||||
return dict()
|
|
||||||
try:
|
|
||||||
return json_dict_bytes_to_unicode(self._loader.load(out))
|
|
||||||
except ValueError:
|
|
||||||
raise AnsibleError("could not parse post variable response: %s, %s" % (cmd, out))
|
|
||||||
@ -1,4 +0,0 @@
|
|||||||
# Make coding more python3-ish
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
@ -1,50 +0,0 @@
|
|||||||
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
||||||
# (c) 2014, Serge van Ginderachter <serge@vanginderachter.be>
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
class VarsModule(object):
|
|
||||||
|
|
||||||
"""
|
|
||||||
Loads variables for groups and/or hosts
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, inventory):
|
|
||||||
|
|
||||||
""" constructor """
|
|
||||||
|
|
||||||
self.inventory = inventory
|
|
||||||
self.inventory_basedir = inventory.basedir()
|
|
||||||
|
|
||||||
|
|
||||||
def run(self, host, vault_password=None):
|
|
||||||
""" For backwards compatibility, when only vars per host were retrieved
|
|
||||||
This method should return both host specific vars as well as vars
|
|
||||||
calculated from groups it is a member of """
|
|
||||||
return {}
|
|
||||||
|
|
||||||
|
|
||||||
def get_host_vars(self, host, vault_password=None):
|
|
||||||
""" Get host specific variables. """
|
|
||||||
return {}
|
|
||||||
|
|
||||||
|
|
||||||
def get_group_vars(self, group, vault_password=None):
|
|
||||||
""" Get group specific variables. """
|
|
||||||
return {}
|
|
||||||
|
|
||||||
@ -1,170 +0,0 @@
|
|||||||
# Copyright 2016 RedHat, inc
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
#############################################
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
import re
|
|
||||||
|
|
||||||
from ansible import constants as C
|
|
||||||
from ansible.inventory.host import Host
|
|
||||||
from ansible.inventory.group import Group
|
|
||||||
from ansible.inventory.expand_hosts import detect_range
|
|
||||||
from ansible.inventory.expand_hosts import expand_hostname_range
|
|
||||||
from ansible.module_utils.six import string_types
|
|
||||||
from ansible.parsing.utils.addresses import parse_address
|
|
||||||
|
|
||||||
|
|
||||||
class InventoryParser(object):
|
|
||||||
"""
|
|
||||||
Takes a YAML-format inventory file and builds a list of groups and subgroups
|
|
||||||
with their associated hosts and variable settings.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, loader, groups, filename=C.DEFAULT_HOST_LIST):
|
|
||||||
self._loader = loader
|
|
||||||
self.filename = filename
|
|
||||||
|
|
||||||
# Start with an empty host list and whatever groups we're passed in
|
|
||||||
# (which should include the default 'all' and 'ungrouped' groups).
|
|
||||||
|
|
||||||
self.hosts = {}
|
|
||||||
self.patterns = {}
|
|
||||||
self.groups = groups
|
|
||||||
|
|
||||||
# Read in the hosts, groups, and variables defined in the
|
|
||||||
# inventory file.
|
|
||||||
data = loader.load_from_file(filename)
|
|
||||||
|
|
||||||
self._parse(data)
|
|
||||||
|
|
||||||
def _parse(self, data):
|
|
||||||
'''
|
|
||||||
Populates self.groups from the given array of lines. Raises an error on
|
|
||||||
any parse failure.
|
|
||||||
'''
|
|
||||||
|
|
||||||
self._compile_patterns()
|
|
||||||
|
|
||||||
# We expect top level keys to correspond to groups, iterate over them
|
|
||||||
# to get host, vars and subgroups (which we iterate over recursivelly)
|
|
||||||
for group_name in data.keys():
|
|
||||||
self._parse_groups(group_name, data[group_name])
|
|
||||||
|
|
||||||
# Finally, add all top-level groups as children of 'all'.
|
|
||||||
# We exclude ungrouped here because it was already added as a child of
|
|
||||||
# 'all' at the time it was created.
|
|
||||||
for group in self.groups.values():
|
|
||||||
if group.depth == 0 and group.name not in ('all', 'ungrouped'):
|
|
||||||
self.groups['all'].add_child_group(group)
|
|
||||||
|
|
||||||
def _parse_groups(self, group, group_data):
|
|
||||||
|
|
||||||
if group not in self.groups:
|
|
||||||
self.groups[group] = Group(name=group)
|
|
||||||
|
|
||||||
if isinstance(group_data, dict):
|
|
||||||
#make sure they are dicts
|
|
||||||
for section in ['vars', 'children', 'hosts']:
|
|
||||||
if section in group_data and isinstance(group_data[section], string_types):
|
|
||||||
group_data[section] = { group_data[section]: None}
|
|
||||||
|
|
||||||
if 'vars' in group_data:
|
|
||||||
for var in group_data['vars']:
|
|
||||||
self.groups[group].set_variable(var, group_data['vars'][var])
|
|
||||||
|
|
||||||
if 'children' in group_data:
|
|
||||||
for subgroup in group_data['children']:
|
|
||||||
self._parse_groups(subgroup, group_data['children'][subgroup])
|
|
||||||
self.groups[group].add_child_group(self.groups[subgroup])
|
|
||||||
|
|
||||||
if 'hosts' in group_data:
|
|
||||||
for host_pattern in group_data['hosts']:
|
|
||||||
hosts = self._parse_host(host_pattern, group_data['hosts'][host_pattern])
|
|
||||||
for h in hosts:
|
|
||||||
self.groups[group].add_host(h)
|
|
||||||
|
|
||||||
|
|
||||||
def _parse_host(self, host_pattern, host_data):
|
|
||||||
'''
|
|
||||||
Each host key can be a pattern, try to process it and add variables as needed
|
|
||||||
'''
|
|
||||||
(hostnames, port) = self._expand_hostpattern(host_pattern)
|
|
||||||
hosts = self._Hosts(hostnames, port)
|
|
||||||
|
|
||||||
if isinstance(host_data, dict):
|
|
||||||
for k in host_data:
|
|
||||||
for h in hosts:
|
|
||||||
h.set_variable(k, host_data[k])
|
|
||||||
if k in ['ansible_host', 'ansible_ssh_host']:
|
|
||||||
h.address = host_data[k]
|
|
||||||
return hosts
|
|
||||||
|
|
||||||
def _expand_hostpattern(self, hostpattern):
|
|
||||||
'''
|
|
||||||
Takes a single host pattern and returns a list of hostnames and an
|
|
||||||
optional port number that applies to all of them.
|
|
||||||
'''
|
|
||||||
|
|
||||||
# Can the given hostpattern be parsed as a host with an optional port
|
|
||||||
# specification?
|
|
||||||
|
|
||||||
try:
|
|
||||||
(pattern, port) = parse_address(hostpattern, allow_ranges=True)
|
|
||||||
except:
|
|
||||||
# not a recognizable host pattern
|
|
||||||
pattern = hostpattern
|
|
||||||
port = None
|
|
||||||
|
|
||||||
# Once we have separated the pattern, we expand it into list of one or
|
|
||||||
# more hostnames, depending on whether it contains any [x:y] ranges.
|
|
||||||
|
|
||||||
if detect_range(pattern):
|
|
||||||
hostnames = expand_hostname_range(pattern)
|
|
||||||
else:
|
|
||||||
hostnames = [pattern]
|
|
||||||
|
|
||||||
return (hostnames, port)
|
|
||||||
|
|
||||||
def _Hosts(self, hostnames, port):
|
|
||||||
'''
|
|
||||||
Takes a list of hostnames and a port (which may be None) and returns a
|
|
||||||
list of Hosts (without recreating anything in self.hosts).
|
|
||||||
'''
|
|
||||||
|
|
||||||
hosts = []
|
|
||||||
|
|
||||||
# Note that we decide whether or not to create a Host based solely on
|
|
||||||
# the (non-)existence of its hostname in self.hosts. This means that one
|
|
||||||
# cannot add both "foo:22" and "foo:23" to the inventory.
|
|
||||||
|
|
||||||
for hn in hostnames:
|
|
||||||
if hn not in self.hosts:
|
|
||||||
self.hosts[hn] = Host(name=hn, port=port)
|
|
||||||
hosts.append(self.hosts[hn])
|
|
||||||
|
|
||||||
return hosts
|
|
||||||
|
|
||||||
def get_host_variables(self, host):
|
|
||||||
return {}
|
|
||||||
|
|
||||||
def _compile_patterns(self):
|
|
||||||
'''
|
|
||||||
Compiles the regular expressions required to parse the inventory and stores them in self.patterns.
|
|
||||||
'''
|
|
||||||
self.patterns['groupname'] = re.compile( r'''^[A-Za-z_][A-Za-z0-9_]*$''')
|
|
||||||
@ -0,0 +1,103 @@
|
|||||||
|
# Copyright 2017 RedHat, inc
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
#############################################
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
inventory: advanced_host_list
|
||||||
|
version_added: "2.4"
|
||||||
|
short_description: Parses a 'host list' with ranges
|
||||||
|
description:
|
||||||
|
- Parses a host list string as a comma separated values of hosts and supports host ranges.
|
||||||
|
- This plugin only applies to inventory sources that are not paths and contain at least one comma.
|
||||||
|
EXAMPLES:
|
||||||
|
# simple range
|
||||||
|
ansible -i 'host[1:10],' -m ping
|
||||||
|
|
||||||
|
# still supports w/o ranges also
|
||||||
|
ansible-playbook -i 'localhost,' play.yml
|
||||||
|
'''
|
||||||
|
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
|
||||||
|
from ansible.errors import AnsibleError, AnsibleParserError
|
||||||
|
from ansible.module_utils._text import to_bytes, to_text, to_native
|
||||||
|
from ansible.parsing.utils.addresses import parse_address
|
||||||
|
from ansible.plugins.inventory import BaseInventoryPlugin, detect_range, expand_hostname_range
|
||||||
|
|
||||||
|
|
||||||
|
class InventoryModule(BaseInventoryPlugin):
|
||||||
|
|
||||||
|
NAME = 'advanced_host_list'
|
||||||
|
|
||||||
|
def verify_file(self, host_list):
|
||||||
|
|
||||||
|
valid = False
|
||||||
|
b_path = to_bytes(host_list)
|
||||||
|
if not os.path.exists(b_path) and ',' in host_list:
|
||||||
|
valid = True
|
||||||
|
return valid
|
||||||
|
|
||||||
|
def parse(self, inventory, loader, host_list, cache=True):
|
||||||
|
''' parses the inventory file '''
|
||||||
|
|
||||||
|
super(InventoryModule, self).parse(inventory, loader, host_list)
|
||||||
|
|
||||||
|
try:
|
||||||
|
for h in host_list.split(','):
|
||||||
|
if h:
|
||||||
|
try:
|
||||||
|
(hostnames, port) = self._expand_hostpattern(h)
|
||||||
|
except AnsibleError as e:
|
||||||
|
self.display.vvv("Unable to parse address from hostname, leaving unchanged: %s" % to_native(e))
|
||||||
|
host = [h]
|
||||||
|
port = None
|
||||||
|
|
||||||
|
for host in hostnames:
|
||||||
|
if host not in self.inventory.hosts:
|
||||||
|
self.inventory.add_host(host, group='ungrouped', port=port)
|
||||||
|
else:
|
||||||
|
self.display.warning("Skipping invalid hostname: %s" % to_text(h))
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError("Invalid data from string, could not parse: %s" % str(e))
|
||||||
|
|
||||||
|
def _expand_hostpattern(self, hostpattern):
|
||||||
|
'''
|
||||||
|
Takes a single host pattern and returns a list of hostnames and an
|
||||||
|
optional port number that applies to all of them.
|
||||||
|
'''
|
||||||
|
# Can the given hostpattern be parsed as a host with an optional port
|
||||||
|
# specification?
|
||||||
|
|
||||||
|
try:
|
||||||
|
(pattern, port) = parse_address(hostpattern, allow_ranges=True)
|
||||||
|
except:
|
||||||
|
# not a recognizable host pattern
|
||||||
|
pattern = hostpattern
|
||||||
|
port = None
|
||||||
|
|
||||||
|
# Once we have separated the pattern, we expand it into list of one or
|
||||||
|
# more hostnames, depending on whether it contains any [x:y] ranges.
|
||||||
|
|
||||||
|
if detect_range(pattern):
|
||||||
|
hostnames = expand_hostname_range(pattern)
|
||||||
|
else:
|
||||||
|
hostnames = [pattern]
|
||||||
|
|
||||||
|
return (hostnames, port)
|
||||||
@ -0,0 +1,78 @@
|
|||||||
|
# Copyright 2017 RedHat, inc
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
inventory: host_list
|
||||||
|
version_added: "2.4"
|
||||||
|
short_description: Parses a 'host list' string
|
||||||
|
description:
|
||||||
|
- Parses a host list string as a comma separated values of hosts
|
||||||
|
- This plugin only applies to inventory strings that are not paths and contain a comma.
|
||||||
|
EXAMPLES: |
|
||||||
|
# define 2 hosts in command line
|
||||||
|
ansible -i '10.10.2.6, 10.10.2.4' -m ping all
|
||||||
|
|
||||||
|
# DNS resolvable names
|
||||||
|
ansible -i 'host1.example.com, host2' -m user -a 'name=me state=abset' all
|
||||||
|
|
||||||
|
# just use localhost
|
||||||
|
ansible-playbook -i 'localhost,' play.yml -c local
|
||||||
|
'''
|
||||||
|
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
|
||||||
|
from ansible.errors import AnsibleError, AnsibleParserError
|
||||||
|
from ansible.module_utils.six import string_types
|
||||||
|
from ansible.module_utils._text import to_bytes, to_text, to_native
|
||||||
|
from ansible.parsing.utils.addresses import parse_address
|
||||||
|
from ansible.plugins.inventory import BaseInventoryPlugin
|
||||||
|
|
||||||
|
|
||||||
|
class InventoryModule(BaseInventoryPlugin):
|
||||||
|
|
||||||
|
NAME = 'host_list'
|
||||||
|
|
||||||
|
def verify_file(self, host_list):
|
||||||
|
|
||||||
|
valid = False
|
||||||
|
b_path = to_bytes(host_list)
|
||||||
|
if not os.path.exists(b_path) and ',' in host_list:
|
||||||
|
valid = True
|
||||||
|
return valid
|
||||||
|
|
||||||
|
def parse(self, inventory, loader, host_list, cache=True):
|
||||||
|
''' parses the inventory file '''
|
||||||
|
|
||||||
|
super(InventoryModule, self).parse(inventory, loader, host_list)
|
||||||
|
|
||||||
|
try:
|
||||||
|
for h in host_list.split(','):
|
||||||
|
if h:
|
||||||
|
try:
|
||||||
|
(host, port) = parse_address(h, allow_ranges=False)
|
||||||
|
except AnsibleError as e:
|
||||||
|
self.display.vvv("Unable to parse address from hostname, leaving unchanged: %s" % to_native(e))
|
||||||
|
host = h
|
||||||
|
port = None
|
||||||
|
|
||||||
|
if host not in self.inventory.hosts:
|
||||||
|
self.inventory.add_host(host, group='ungrouped', port=port)
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError("Invalid data from string, could not parse: %s" % str(e))
|
||||||
@ -0,0 +1,188 @@
|
|||||||
|
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
inventory: script
|
||||||
|
version_added: "2.4"
|
||||||
|
short_description: Executes an inventory script that returns JSON
|
||||||
|
description:
|
||||||
|
- The source provided must an executable that returns Ansible inventory JSON
|
||||||
|
- The source must accept C(--list) and C(--host <hostname>) as arguments.
|
||||||
|
C(--host) will only be used if no C(_meta) key is present (performance optimization)
|
||||||
|
notes:
|
||||||
|
- It takes the place of the previously hardcoded script inventory.
|
||||||
|
- To function it requires being whitelisted in configuration, which is true by default.
|
||||||
|
'''
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
import subprocess
|
||||||
|
from collections import Mapping
|
||||||
|
|
||||||
|
from ansible.errors import AnsibleError, AnsibleParserError
|
||||||
|
from ansible.module_utils.basic import json_dict_bytes_to_unicode
|
||||||
|
from ansible.module_utils.six import iteritems
|
||||||
|
from ansible.module_utils._text import to_native, to_text
|
||||||
|
from ansible.plugins.inventory import BaseInventoryPlugin
|
||||||
|
|
||||||
|
|
||||||
|
class InventoryModule(BaseInventoryPlugin):
|
||||||
|
''' Host inventory parser for ansible using external inventory scripts. '''
|
||||||
|
|
||||||
|
NAME = 'script'
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
|
||||||
|
super(InventoryModule, self).__init__()
|
||||||
|
|
||||||
|
self._hosts = set()
|
||||||
|
|
||||||
|
def verify_file(self, path):
|
||||||
|
''' Verify if file is usable by this plugin, base does minimal accesability check '''
|
||||||
|
|
||||||
|
valid = super(InventoryModule, self).verify_file(path)
|
||||||
|
|
||||||
|
if valid:
|
||||||
|
# not only accessible, file must be executable and/or have shebang
|
||||||
|
shebang_present = False
|
||||||
|
try:
|
||||||
|
with open(path, 'rb') as inv_file:
|
||||||
|
initial_chars = inv_file.read(2)
|
||||||
|
if initial_chars.startswith(b'#!'):
|
||||||
|
shebang_present = True
|
||||||
|
except:
|
||||||
|
pass
|
||||||
|
|
||||||
|
if not os.access(path, os.X_OK) and not shebang_present:
|
||||||
|
valid = False
|
||||||
|
|
||||||
|
return valid
|
||||||
|
|
||||||
|
def parse(self, inventory, loader, path, cache=True):
|
||||||
|
|
||||||
|
super(InventoryModule, self).parse(inventory, loader, path)
|
||||||
|
|
||||||
|
# Support inventory scripts that are not prefixed with some
|
||||||
|
# path information but happen to be in the current working
|
||||||
|
# directory when '.' is not in PATH.
|
||||||
|
path = os.path.abspath(path)
|
||||||
|
cmd = [ path, "--list" ]
|
||||||
|
try:
|
||||||
|
try:
|
||||||
|
sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||||
|
except OSError as e:
|
||||||
|
raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
|
||||||
|
(stdout, stderr) = sp.communicate()
|
||||||
|
|
||||||
|
path = to_native(path)
|
||||||
|
if stderr:
|
||||||
|
err = to_native(stderr) + "\n"
|
||||||
|
|
||||||
|
if sp.returncode != 0:
|
||||||
|
raise AnsibleError("Inventory script (%s) had an execution error: %s " % (path, err))
|
||||||
|
|
||||||
|
# make sure script output is unicode so that json loader will output
|
||||||
|
# unicode strings itself
|
||||||
|
try:
|
||||||
|
data = to_text(stdout, errors="strict")
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleError("Inventory {0} contained characters that cannot be interpreted as UTF-8: {1}".format(path, to_native(e)))
|
||||||
|
|
||||||
|
try:
|
||||||
|
processed = self.loader.load(data)
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleError("failed to parse executable inventory script results from {0}: {1}\n{2}".format(path, to_native(e), err))
|
||||||
|
|
||||||
|
if not isinstance(processed, Mapping):
|
||||||
|
raise AnsibleError("failed to parse executable inventory script results from {0}: needs to be a json dict\n{1}".format(path, err))
|
||||||
|
|
||||||
|
group = None
|
||||||
|
data_from_meta = None
|
||||||
|
for (group, gdata) in data.items():
|
||||||
|
if group == '_meta':
|
||||||
|
if 'hostvars' in data:
|
||||||
|
data_from_meta = data['hostvars']
|
||||||
|
else:
|
||||||
|
self.parse_group(group, gdata)
|
||||||
|
|
||||||
|
# in Ansible 1.3 and later, a "_meta" subelement may contain
|
||||||
|
# a variable "hostvars" which contains a hash for each host
|
||||||
|
# if this "hostvars" exists at all then do not call --host for each
|
||||||
|
# host. This is for efficiency and scripts should still return data
|
||||||
|
# if called with --host for backwards compat with 1.2 and earlier.
|
||||||
|
for host in self._hosts:
|
||||||
|
got = {}
|
||||||
|
if data_from_meta is None:
|
||||||
|
got = self.get_host_variables(path, host, data_from_meta)
|
||||||
|
else:
|
||||||
|
try:
|
||||||
|
got = data.get(host, {})
|
||||||
|
except AttributeError as e:
|
||||||
|
raise AnsibleError("Improperly formatted host information for %s: %s" % (host,to_native(e)))
|
||||||
|
|
||||||
|
self.populate_host_vars(host, got, group)
|
||||||
|
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError(e)
|
||||||
|
|
||||||
|
|
||||||
|
def _parse_group(self, group, data):
|
||||||
|
|
||||||
|
self.inventory.add_group(group)
|
||||||
|
|
||||||
|
if not isinstance(data, dict):
|
||||||
|
data = {'hosts': data}
|
||||||
|
# is not those subkeys, then simplified syntax, host with vars
|
||||||
|
elif not any(k in data for k in ('hosts','vars','children')):
|
||||||
|
data = {'hosts': [group], 'vars': data}
|
||||||
|
|
||||||
|
if 'hosts' in data:
|
||||||
|
if not isinstance(data['hosts'], list):
|
||||||
|
raise AnsibleError("You defined a group '%s' with bad data for the host list:\n %s" % (group, data))
|
||||||
|
|
||||||
|
for hostname in data['hosts']:
|
||||||
|
self._hosts.add(hostname)
|
||||||
|
self.inventory.add_host(hostname, group)
|
||||||
|
|
||||||
|
if 'vars' in data:
|
||||||
|
if not isinstance(data['vars'], dict):
|
||||||
|
raise AnsibleError("You defined a group '%s' with bad data for variables:\n %s" % (group, data))
|
||||||
|
|
||||||
|
for k, v in iteritems(data['vars']):
|
||||||
|
self.inventory.set_variable(group, k, v)
|
||||||
|
|
||||||
|
if group != 'meta' and isinstance(data, dict) and 'children' in data:
|
||||||
|
for child_name in data['children']:
|
||||||
|
self.inventory.add_group(child_name)
|
||||||
|
self.inventory.add_child(group, child_name)
|
||||||
|
|
||||||
|
def get_host_variables(self, path, host):
|
||||||
|
""" Runs <script> --host <hostname>, to determine additional host variables """
|
||||||
|
|
||||||
|
cmd = [path, "--host", host]
|
||||||
|
try:
|
||||||
|
sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||||
|
except OSError as e:
|
||||||
|
raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
|
||||||
|
(out, err) = sp.communicate()
|
||||||
|
if out.strip() == '':
|
||||||
|
return {}
|
||||||
|
try:
|
||||||
|
return json_dict_bytes_to_unicode(self.loader.load(out))
|
||||||
|
except ValueError:
|
||||||
|
raise AnsibleError("could not parse post variable response: %s, %s" % (cmd, out))
|
||||||
@ -0,0 +1,169 @@
|
|||||||
|
# This file is part of Ansible,
|
||||||
|
# (c) 2012-2017, Michael DeHaan <michael.dehaan@gmail.com>
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
#############################################
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
name: virtualbox
|
||||||
|
plugin_type: inventory
|
||||||
|
short_description: virtualbox inventory source
|
||||||
|
description:
|
||||||
|
- Get inventory hosts from the local virtualbox installation.
|
||||||
|
- Uses a <name>.vbox.conf YAML configuration file.
|
||||||
|
options:
|
||||||
|
running_only:
|
||||||
|
description: toggles showing all vms vs only those currently running
|
||||||
|
default: False
|
||||||
|
settings_password_file:
|
||||||
|
description: provide a file containing the settings password (equivalent to --settingspwfile)
|
||||||
|
network_info_path:
|
||||||
|
description: property path to query for network information (ansible_host)
|
||||||
|
default: "/VirtualBox/GuestInfo/Net/0/V4/IP"
|
||||||
|
'''
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
from subprocess import Popen, PIPE
|
||||||
|
|
||||||
|
from ansible.errors import AnsibleParserError
|
||||||
|
from ansible.module_utils._text import to_bytes
|
||||||
|
from ansible.plugins.inventory import BaseInventoryPlugin
|
||||||
|
|
||||||
|
|
||||||
|
class InventoryModule(BaseInventoryPlugin):
|
||||||
|
''' Host inventory parser for ansible using external inventory scripts. '''
|
||||||
|
|
||||||
|
NAME = 'virtualbox'
|
||||||
|
|
||||||
|
def verify_file(self, path):
|
||||||
|
|
||||||
|
valid = False
|
||||||
|
if super(InventoryModule, self).verify_file(path):
|
||||||
|
if path.endswith('.vbox.conf'):
|
||||||
|
valid = True
|
||||||
|
return valid
|
||||||
|
|
||||||
|
def parse(self, inventory, loader, path, cache=True):
|
||||||
|
|
||||||
|
super(InventoryModule, self).parse(inventory, loader, path)
|
||||||
|
|
||||||
|
VBOX = "VBoxManage"
|
||||||
|
cache_key = self.get_cache_prefix(path)
|
||||||
|
|
||||||
|
if cache and cache_key not in inventory.cache:
|
||||||
|
source_data = inventory.cache[cache_key]
|
||||||
|
else:
|
||||||
|
# file is config file
|
||||||
|
try:
|
||||||
|
data = self.loader.load_from_file(path)
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError(e)
|
||||||
|
|
||||||
|
if not data or data.get('plugin') != self.NAME:
|
||||||
|
return False
|
||||||
|
|
||||||
|
pwfile = to_bytes(data.get('settings_password_file'))
|
||||||
|
netinfo = data.get('network_info_path', "/VirtualBox/GuestInfo/Net/0/V4/IP")
|
||||||
|
running = data.get('running_only', False)
|
||||||
|
|
||||||
|
# start getting data
|
||||||
|
cmd = [VBOX, 'list', '-l']
|
||||||
|
if running:
|
||||||
|
cmd.append('runningvms')
|
||||||
|
else:
|
||||||
|
cmd.append('vms')
|
||||||
|
|
||||||
|
if pwfile and os.path.exists(pwfile):
|
||||||
|
cmd.append('--settingspwfile')
|
||||||
|
cmd.append(pwfile)
|
||||||
|
|
||||||
|
try:
|
||||||
|
p = Popen(cmd, stdout=PIPE)
|
||||||
|
except Exception as e:
|
||||||
|
AnsibleParserError(e)
|
||||||
|
|
||||||
|
hostvars = {}
|
||||||
|
prevkey = pref_k = ''
|
||||||
|
current_host = None
|
||||||
|
|
||||||
|
source_data = p.stdout.readlines()
|
||||||
|
inventory.cache[cache_key] = source_data
|
||||||
|
|
||||||
|
for line in source_data:
|
||||||
|
|
||||||
|
try:
|
||||||
|
k, v = line.split(':', 1)
|
||||||
|
except:
|
||||||
|
# skip non splitable
|
||||||
|
continue
|
||||||
|
|
||||||
|
if k.strip() == '':
|
||||||
|
# skip empty
|
||||||
|
continue
|
||||||
|
|
||||||
|
v = v.strip()
|
||||||
|
# found host
|
||||||
|
if k.startswith('Name') and ',' not in v: # some setting strings appear in Name
|
||||||
|
current_host = v
|
||||||
|
if current_host not in hostvars:
|
||||||
|
hostvars[current_host] = {}
|
||||||
|
self.inventory.add_host(current_host)
|
||||||
|
# try to get network info
|
||||||
|
try:
|
||||||
|
cmd = [VBOX, 'guestproperty', 'get', current_host, netinfo]
|
||||||
|
if args:
|
||||||
|
cmd.append(args)
|
||||||
|
x = Popen(cmd, stdout=PIPE)
|
||||||
|
ipinfo = x.stdout.read()
|
||||||
|
if 'Value' in ipinfo:
|
||||||
|
a, ip = ipinfo.split(':', 1)
|
||||||
|
self.inventory.set_variable(current_host, 'ansible_host', ip.strip())
|
||||||
|
except:
|
||||||
|
pass
|
||||||
|
|
||||||
|
# found groups
|
||||||
|
elif k == 'Groups':
|
||||||
|
for group in v.split('/'):
|
||||||
|
if group:
|
||||||
|
self.inventory.add_group(group)
|
||||||
|
self.inventory.add_child(group, current_host)
|
||||||
|
continue
|
||||||
|
|
||||||
|
else:
|
||||||
|
# found vars, accumulate in hostvars for clean inventory set
|
||||||
|
pref_k = 'vbox_' + k.strip().replace(' ', '_')
|
||||||
|
if k.startswith(' '):
|
||||||
|
if prevkey not in hostvars[current_host]:
|
||||||
|
hostvars[current_host][prevkey] = {}
|
||||||
|
hostvars[current_host][prevkey][pref_k] = v
|
||||||
|
else:
|
||||||
|
if v != '':
|
||||||
|
hostvars[current_host][pref_k] = v
|
||||||
|
|
||||||
|
prevkey = pref_k
|
||||||
|
|
||||||
|
# set vars in inventory from hostvars
|
||||||
|
for host in hostvars:
|
||||||
|
|
||||||
|
# create composite vars
|
||||||
|
if data.get('compose') and isinstance(data['compose'], dict):
|
||||||
|
for varname in data['compose']:
|
||||||
|
hostvars[host][varname] = self._compose(data['compose'][varname], hostvars[host])
|
||||||
|
|
||||||
|
# actually update inventory
|
||||||
|
for key in hostvars[host]:
|
||||||
|
self.inventory.set_variable(host, key, hostvars[host][key])
|
||||||
@ -0,0 +1,181 @@
|
|||||||
|
# Copyright 2017 RedHat, inc
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
#############################################
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
inventory: yaml
|
||||||
|
version_added: "2.4"
|
||||||
|
short_description: Uses a specifically YAML file as inventory source.
|
||||||
|
description:
|
||||||
|
- YAML based inventory, starts with the 'all' group and has hosts/vars/children entries.
|
||||||
|
- Host entries can have sub-entries defined, which will be treated as variables.
|
||||||
|
- Vars entries are normal group vars.
|
||||||
|
- Children are 'child groups', which can also have their own vars/hosts/children and so on.
|
||||||
|
- File MUST have a valid extension: yaml, yml, json.
|
||||||
|
notes:
|
||||||
|
- It takes the place of the previously hardcoded YAML inventory.
|
||||||
|
- To function it requires being whitelisted in configuration.
|
||||||
|
options:
|
||||||
|
_yaml_extensions:
|
||||||
|
description: list of 'valid' extensions for files containing YAML
|
||||||
|
EXAMPLES:
|
||||||
|
all: # keys must be unique, i.e. only one 'hosts' per group
|
||||||
|
hosts:
|
||||||
|
test1:
|
||||||
|
test2:
|
||||||
|
var1: value1
|
||||||
|
vars:
|
||||||
|
group_var1: value2
|
||||||
|
children: # key order does not matter, indentation does
|
||||||
|
other_group:
|
||||||
|
children:
|
||||||
|
group_x:
|
||||||
|
hosts:
|
||||||
|
test5
|
||||||
|
vars:
|
||||||
|
g2_var2: value3
|
||||||
|
hosts:
|
||||||
|
test4:
|
||||||
|
ansible_host: 127.0.0.1
|
||||||
|
last_group:
|
||||||
|
hosts:
|
||||||
|
test1 # same host as above, additional group membership
|
||||||
|
vars:
|
||||||
|
last_var: MYVALUE
|
||||||
|
'''
|
||||||
|
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import re
|
||||||
|
import os
|
||||||
|
|
||||||
|
from ansible import constants as C
|
||||||
|
from ansible.errors import AnsibleParserError
|
||||||
|
from ansible.module_utils.six import string_types
|
||||||
|
from ansible.module_utils._text import to_bytes, to_text
|
||||||
|
from ansible.parsing.utils.addresses import parse_address
|
||||||
|
from ansible.plugins.inventory import BaseFileInventoryPlugin, detect_range, expand_hostname_range
|
||||||
|
|
||||||
|
class InventoryModule(BaseFileInventoryPlugin):
|
||||||
|
|
||||||
|
NAME = 'yaml'
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
|
||||||
|
super(InventoryModule, self).__init__()
|
||||||
|
self.patterns = {}
|
||||||
|
|
||||||
|
self._compile_patterns()
|
||||||
|
|
||||||
|
def verify_file(self, path):
|
||||||
|
|
||||||
|
valid = False
|
||||||
|
b_path = to_bytes(path)
|
||||||
|
if super(InventoryModule, self).verify_file(b_path):
|
||||||
|
file_name, ext = os.path.splitext(b_path)
|
||||||
|
if ext and ext in C.YAML_FILENAME_EXTENSIONS:
|
||||||
|
valid = True
|
||||||
|
return valid
|
||||||
|
|
||||||
|
def parse(self, inventory, loader, path, cache=True):
|
||||||
|
''' parses the inventory file '''
|
||||||
|
|
||||||
|
super(InventoryModule, self).parse(inventory, loader, path)
|
||||||
|
|
||||||
|
try:
|
||||||
|
data = self.loader.load_from_file(path)
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError(e)
|
||||||
|
|
||||||
|
if not data:
|
||||||
|
return False
|
||||||
|
|
||||||
|
# We expect top level keys to correspond to groups, iterate over them
|
||||||
|
# to get host, vars and subgroups (which we iterate over recursivelly)
|
||||||
|
if isinstance(data, dict):
|
||||||
|
for group_name in data:
|
||||||
|
self._parse_group(group_name, data[group_name])
|
||||||
|
else:
|
||||||
|
raise AnsibleParserError("Invalid data from file, expected dictionary and got:\n\n%s" % data)
|
||||||
|
|
||||||
|
def _parse_group(self, group, group_data):
|
||||||
|
|
||||||
|
if self.patterns['groupname'].match(group):
|
||||||
|
|
||||||
|
self.inventory.add_group(group)
|
||||||
|
|
||||||
|
if isinstance(group_data, dict):
|
||||||
|
#make sure they are dicts
|
||||||
|
for section in ['vars', 'children', 'hosts']:
|
||||||
|
if section in group_data and isinstance(group_data[section], string_types):
|
||||||
|
group_data[section] = {group_data[section]: None}
|
||||||
|
|
||||||
|
if 'vars' in group_data:
|
||||||
|
for var in group_data['vars']:
|
||||||
|
self.inventory.set_variable(group, var, group_data['vars'][var])
|
||||||
|
|
||||||
|
if 'children' in group_data:
|
||||||
|
for subgroup in group_data['children']:
|
||||||
|
self._parse_group(subgroup, group_data['children'][subgroup])
|
||||||
|
self.inventory.add_child(group, subgroup)
|
||||||
|
|
||||||
|
if 'hosts' in group_data:
|
||||||
|
for host_pattern in group_data['hosts']:
|
||||||
|
hosts, port = self._parse_host(host_pattern)
|
||||||
|
self.populate_host_vars(hosts, group_data['hosts'][host_pattern], group, port)
|
||||||
|
else:
|
||||||
|
self.display.warning("Skipping '%s' as this is not a valid group name" % group)
|
||||||
|
|
||||||
|
def _parse_host(self, host_pattern):
|
||||||
|
'''
|
||||||
|
Each host key can be a pattern, try to process it and add variables as needed
|
||||||
|
'''
|
||||||
|
(hostnames, port) = self._expand_hostpattern(host_pattern)
|
||||||
|
|
||||||
|
return hostnames, port
|
||||||
|
|
||||||
|
def _expand_hostpattern(self, hostpattern):
|
||||||
|
'''
|
||||||
|
Takes a single host pattern and returns a list of hostnames and an
|
||||||
|
optional port number that applies to all of them.
|
||||||
|
'''
|
||||||
|
# Can the given hostpattern be parsed as a host with an optional port
|
||||||
|
# specification?
|
||||||
|
|
||||||
|
try:
|
||||||
|
(pattern, port) = parse_address(hostpattern, allow_ranges=True)
|
||||||
|
except:
|
||||||
|
# not a recognizable host pattern
|
||||||
|
pattern = hostpattern
|
||||||
|
port = None
|
||||||
|
|
||||||
|
# Once we have separated the pattern, we expand it into list of one or
|
||||||
|
# more hostnames, depending on whether it contains any [x:y] ranges.
|
||||||
|
|
||||||
|
if detect_range(pattern):
|
||||||
|
hostnames = expand_hostname_range(pattern)
|
||||||
|
else:
|
||||||
|
hostnames = [pattern]
|
||||||
|
|
||||||
|
return (hostnames, port)
|
||||||
|
|
||||||
|
def _compile_patterns(self):
|
||||||
|
'''
|
||||||
|
Compiles the regular expressions required to parse the inventory and stores them in self.patterns.
|
||||||
|
'''
|
||||||
|
self.patterns['groupname'] = re.compile( r'''^[A-Za-z_][A-Za-z0-9_]*$''')
|
||||||
@ -0,0 +1,107 @@
|
|||||||
|
# Copyright 2017 RedHat, inc
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
#############################################
|
||||||
|
'''
|
||||||
|
DOCUMENTATION:
|
||||||
|
vars: host_group_vars
|
||||||
|
version_added: "2.4"
|
||||||
|
short_description: In charge of loading group_vars and host_vars
|
||||||
|
description:
|
||||||
|
- Loads YAML vars into corresponding groups/hosts in group_vars/ and host_vars/ directories.
|
||||||
|
- Files are restricted by extension to one of .yaml, .json, .yml or no extension.
|
||||||
|
- Only applies to inventory sources that are existing paths.
|
||||||
|
notes:
|
||||||
|
- It takes the place of the previously hardcoded group_vars/host_vars loading.
|
||||||
|
'''
|
||||||
|
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
from ansible import constants as C
|
||||||
|
from ansible.errors import AnsibleParserError
|
||||||
|
from ansible.module_utils._text import to_bytes, to_text
|
||||||
|
from ansible.plugins.vars import BaseVarsPlugin
|
||||||
|
from ansible.utils.path import basedir
|
||||||
|
from ansible.inventory.host import Host
|
||||||
|
from ansible.inventory.group import Group
|
||||||
|
from ansible.utils.vars import combine_vars
|
||||||
|
|
||||||
|
|
||||||
|
class VarsModule(BaseVarsPlugin):
|
||||||
|
|
||||||
|
def get_vars(self, loader, path, entities):
|
||||||
|
''' parses the inventory file '''
|
||||||
|
|
||||||
|
if not isinstance(entities, list):
|
||||||
|
entities = [entities]
|
||||||
|
|
||||||
|
super(VarsModule, self).get_vars(loader, path, entities)
|
||||||
|
|
||||||
|
data = {}
|
||||||
|
for entity in entities:
|
||||||
|
if isinstance(entity, Host):
|
||||||
|
subdir = 'host_vars'
|
||||||
|
elif isinstance(entity, Group):
|
||||||
|
subdir = 'group_vars'
|
||||||
|
else:
|
||||||
|
raise AnsibleParserError("Supplied entity must be Host or Group, got %s instead" % (type(entity)))
|
||||||
|
|
||||||
|
try:
|
||||||
|
# load vars
|
||||||
|
opath = os.path.realpath(os.path.join(self._basedir, subdir))
|
||||||
|
b_opath = to_bytes(opath)
|
||||||
|
# no need to do much if path does not exist for basedir
|
||||||
|
if os.path.exists(b_opath):
|
||||||
|
if os.path.isdir(b_opath):
|
||||||
|
self._display.debug("\tprocessing dir %s" % opath)
|
||||||
|
for found in self._find_vars_files(opath, entity.name):
|
||||||
|
self._display.debug("READING %s" % found)
|
||||||
|
data = combine_vars(data, loader.load_from_file(found, cache=True, unsafe=True))
|
||||||
|
else:
|
||||||
|
self._display.warning("Found %s that is not a directory, skipping: %s" % (subdir, opath))
|
||||||
|
|
||||||
|
except Exception as e:
|
||||||
|
raise AnsibleParserError(to_text(e))
|
||||||
|
return data
|
||||||
|
|
||||||
|
def _find_vars_files(self, path, name):
|
||||||
|
""" Find {group,host}_vars files """
|
||||||
|
|
||||||
|
b_path = to_bytes(os.path.join(path, name))
|
||||||
|
found = []
|
||||||
|
for ext in C.YAML_FILENAME_EXTENSIONS + ['']:
|
||||||
|
|
||||||
|
if '.' in ext:
|
||||||
|
full_path = b_path + to_bytes(ext)
|
||||||
|
elif ext:
|
||||||
|
full_path = b'.'.join([b_path, to_bytes(ext)])
|
||||||
|
else:
|
||||||
|
full_path = b_path
|
||||||
|
|
||||||
|
if os.path.exists(full_path):
|
||||||
|
self._display.debug("\tfound %s" % to_text(full_path))
|
||||||
|
if os.path.isdir(full_path):
|
||||||
|
# matched dir name, so use all files included recursively
|
||||||
|
for spath in os.listdir(full_path):
|
||||||
|
if os.path.isdir(spath):
|
||||||
|
found.extend(self._find_vars_files(spath, name))
|
||||||
|
else:
|
||||||
|
found.append(spath)
|
||||||
|
else:
|
||||||
|
found.append(full_path)
|
||||||
|
return found
|
||||||
@ -1,715 +0,0 @@
|
|||||||
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
||||||
#
|
|
||||||
# This file is part of Ansible
|
|
||||||
#
|
|
||||||
# Ansible is free software: you can redistribute it and/or modify
|
|
||||||
# it under the terms of the GNU General Public License as published by
|
|
||||||
# the Free Software Foundation, either version 3 of the License, or
|
|
||||||
# (at your option) any later version.
|
|
||||||
#
|
|
||||||
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
# Make coding more python3-ish
|
|
||||||
from __future__ import (absolute_import, division, print_function)
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
|
|
||||||
from collections import defaultdict, MutableMapping
|
|
||||||
|
|
||||||
try:
|
|
||||||
from hashlib import sha1
|
|
||||||
except ImportError:
|
|
||||||
from sha import sha as sha1
|
|
||||||
|
|
||||||
from jinja2.exceptions import UndefinedError
|
|
||||||
|
|
||||||
from ansible import constants as C
|
|
||||||
from ansible.cli import CLI
|
|
||||||
from ansible.errors import AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleFileNotFound
|
|
||||||
from ansible.inventory.host import Host
|
|
||||||
from ansible.module_utils.six import iteritems, string_types, text_type
|
|
||||||
from ansible.plugins import lookup_loader
|
|
||||||
from ansible.plugins.cache import FactCache
|
|
||||||
from ansible.template import Templar
|
|
||||||
from ansible.utils.listify import listify_lookup_plugin_terms
|
|
||||||
from ansible.utils.vars import combine_vars
|
|
||||||
from ansible.utils.unsafe_proxy import wrap_var
|
|
||||||
from ansible.module_utils._text import to_native
|
|
||||||
|
|
||||||
try:
|
|
||||||
from __main__ import display
|
|
||||||
except ImportError:
|
|
||||||
from ansible.utils.display import Display
|
|
||||||
display = Display()
|
|
||||||
|
|
||||||
|
|
||||||
VARIABLE_CACHE = {}
|
|
||||||
HOSTVARS_CACHE = {}
|
|
||||||
|
|
||||||
|
|
||||||
class AnsibleInventoryVarsData(dict):
|
|
||||||
def __init__(self, *args, **kwargs):
|
|
||||||
super(AnsibleInventoryVarsData, self).__init__(*args, **kwargs)
|
|
||||||
self.path = None
|
|
||||||
|
|
||||||
|
|
||||||
def preprocess_vars(a):
|
|
||||||
'''
|
|
||||||
Ensures that vars contained in the parameter passed in are
|
|
||||||
returned as a list of dictionaries, to ensure for instance
|
|
||||||
that vars loaded from a file conform to an expected state.
|
|
||||||
'''
|
|
||||||
|
|
||||||
if a is None:
|
|
||||||
return None
|
|
||||||
elif not isinstance(a, list):
|
|
||||||
data = [a]
|
|
||||||
else:
|
|
||||||
data = a
|
|
||||||
|
|
||||||
for item in data:
|
|
||||||
if not isinstance(item, MutableMapping):
|
|
||||||
raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a)))
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
|
|
||||||
def strip_internal_keys(dirty):
|
|
||||||
'''
|
|
||||||
All keys stating with _ansible_ are internal, so create a copy of the 'dirty' dict
|
|
||||||
and remove them from the clean one before returning it
|
|
||||||
'''
|
|
||||||
clean = dirty.copy()
|
|
||||||
for k in dirty.keys():
|
|
||||||
if isinstance(k, string_types) and k.startswith('_ansible_'):
|
|
||||||
del clean[k]
|
|
||||||
elif isinstance(dirty[k], dict):
|
|
||||||
clean[k] = strip_internal_keys(dirty[k])
|
|
||||||
return clean
|
|
||||||
|
|
||||||
|
|
||||||
class VariableManager:
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
|
|
||||||
self._nonpersistent_fact_cache = defaultdict(dict)
|
|
||||||
self._vars_cache = defaultdict(dict)
|
|
||||||
self._extra_vars = defaultdict(dict)
|
|
||||||
self._host_vars_files = defaultdict(dict)
|
|
||||||
self._group_vars_files = defaultdict(dict)
|
|
||||||
self._inventory = None
|
|
||||||
self._hostvars = None
|
|
||||||
self._omit_token = '__omit_place_holder__%s' % sha1(os.urandom(64)).hexdigest()
|
|
||||||
self._options_vars = defaultdict(dict)
|
|
||||||
|
|
||||||
# bad cache plugin is not fatal error
|
|
||||||
try:
|
|
||||||
self._fact_cache = FactCache()
|
|
||||||
except AnsibleError as e:
|
|
||||||
display.warning(to_native(e))
|
|
||||||
# fallback to a dict as in memory cache
|
|
||||||
self._fact_cache = {}
|
|
||||||
|
|
||||||
def __getstate__(self):
|
|
||||||
data = dict(
|
|
||||||
fact_cache=self._fact_cache,
|
|
||||||
np_fact_cache=self._nonpersistent_fact_cache,
|
|
||||||
vars_cache=self._vars_cache,
|
|
||||||
extra_vars=self._extra_vars,
|
|
||||||
host_vars_files=self._host_vars_files,
|
|
||||||
group_vars_files=self._group_vars_files,
|
|
||||||
omit_token=self._omit_token,
|
|
||||||
options_vars=self._options_vars,
|
|
||||||
# inventory=self._inventory,
|
|
||||||
)
|
|
||||||
return data
|
|
||||||
|
|
||||||
def __setstate__(self, data):
|
|
||||||
self._fact_cache = data.get('fact_cache', defaultdict(dict))
|
|
||||||
self._nonpersistent_fact_cache = data.get('np_fact_cache', defaultdict(dict))
|
|
||||||
self._vars_cache = data.get('vars_cache', defaultdict(dict))
|
|
||||||
self._extra_vars = data.get('extra_vars', dict())
|
|
||||||
self._host_vars_files = data.get('host_vars_files', defaultdict(dict))
|
|
||||||
self._group_vars_files = data.get('group_vars_files', defaultdict(dict))
|
|
||||||
self._omit_token = data.get('omit_token', '__omit_place_holder__%s' % sha1(os.urandom(64)).hexdigest())
|
|
||||||
self._inventory = data.get('inventory', None)
|
|
||||||
self._options_vars = data.get('options_vars', dict())
|
|
||||||
|
|
||||||
def _get_cache_entry(self, play=None, host=None, task=None):
|
|
||||||
play_id = "NONE"
|
|
||||||
if play:
|
|
||||||
play_id = play._uuid
|
|
||||||
|
|
||||||
host_id = "NONE"
|
|
||||||
if host:
|
|
||||||
host_id = host.get_name()
|
|
||||||
|
|
||||||
task_id = "NONE"
|
|
||||||
if task:
|
|
||||||
task_id = task._uuid
|
|
||||||
|
|
||||||
return "PLAY:%s;HOST:%s;TASK:%s" % (play_id, host_id, task_id)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def extra_vars(self):
|
|
||||||
''' ensures a clean copy of the extra_vars are made '''
|
|
||||||
return self._extra_vars.copy()
|
|
||||||
|
|
||||||
@extra_vars.setter
|
|
||||||
def extra_vars(self, value):
|
|
||||||
''' ensures a clean copy of the extra_vars are used to set the value '''
|
|
||||||
assert isinstance(value, MutableMapping)
|
|
||||||
self._extra_vars = value.copy()
|
|
||||||
|
|
||||||
def set_inventory(self, inventory):
|
|
||||||
self._inventory = inventory
|
|
||||||
|
|
||||||
@property
|
|
||||||
def options_vars(self):
|
|
||||||
''' ensures a clean copy of the options_vars are made '''
|
|
||||||
return self._options_vars.copy()
|
|
||||||
|
|
||||||
@options_vars.setter
|
|
||||||
def options_vars(self, value):
|
|
||||||
''' ensures a clean copy of the options_vars are used to set the value '''
|
|
||||||
assert isinstance(value, dict)
|
|
||||||
self._options_vars = value.copy()
|
|
||||||
|
|
||||||
def _preprocess_vars(self, a):
|
|
||||||
'''
|
|
||||||
Ensures that vars contained in the parameter passed in are
|
|
||||||
returned as a list of dictionaries, to ensure for instance
|
|
||||||
that vars loaded from a file conform to an expected state.
|
|
||||||
'''
|
|
||||||
|
|
||||||
if a is None:
|
|
||||||
return None
|
|
||||||
elif not isinstance(a, list):
|
|
||||||
data = [a]
|
|
||||||
else:
|
|
||||||
data = a
|
|
||||||
|
|
||||||
for item in data:
|
|
||||||
if not isinstance(item, MutableMapping):
|
|
||||||
raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a)))
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
def get_vars(self, loader, play=None, host=None, task=None, include_hostvars=True, include_delegate_to=True, use_cache=True):
|
|
||||||
'''
|
|
||||||
Returns the variables, with optional "context" given via the parameters
|
|
||||||
for the play, host, and task (which could possibly result in different
|
|
||||||
sets of variables being returned due to the additional context).
|
|
||||||
|
|
||||||
The order of precedence is:
|
|
||||||
- play->roles->get_default_vars (if there is a play context)
|
|
||||||
- group_vars_files[host] (if there is a host context)
|
|
||||||
- host_vars_files[host] (if there is a host context)
|
|
||||||
- host->get_vars (if there is a host context)
|
|
||||||
- fact_cache[host] (if there is a host context)
|
|
||||||
- play vars (if there is a play context)
|
|
||||||
- play vars_files (if there's no host context, ignore
|
|
||||||
file names that cannot be templated)
|
|
||||||
- task->get_vars (if there is a task context)
|
|
||||||
- vars_cache[host] (if there is a host context)
|
|
||||||
- extra vars
|
|
||||||
'''
|
|
||||||
|
|
||||||
display.debug("in VariableManager get_vars()")
|
|
||||||
cache_entry = self._get_cache_entry(play=play, host=host, task=task)
|
|
||||||
if cache_entry in VARIABLE_CACHE and use_cache:
|
|
||||||
display.debug("vars are cached, returning them now")
|
|
||||||
return VARIABLE_CACHE[cache_entry]
|
|
||||||
|
|
||||||
all_vars = dict()
|
|
||||||
magic_variables = self._get_magic_variables(
|
|
||||||
loader=loader,
|
|
||||||
play=play,
|
|
||||||
host=host,
|
|
||||||
task=task,
|
|
||||||
include_hostvars=include_hostvars,
|
|
||||||
include_delegate_to=include_delegate_to,
|
|
||||||
)
|
|
||||||
|
|
||||||
if play:
|
|
||||||
# first we compile any vars specified in defaults/main.yml
|
|
||||||
# for all roles within the specified play
|
|
||||||
for role in play.get_roles():
|
|
||||||
all_vars = combine_vars(all_vars, role.get_default_vars())
|
|
||||||
|
|
||||||
# if we have a task in this context, and that task has a role, make
|
|
||||||
# sure it sees its defaults above any other roles, as we previously
|
|
||||||
# (v1) made sure each task had a copy of its roles default vars
|
|
||||||
if task and task._role is not None and (play or task.action == 'include_role'):
|
|
||||||
all_vars = combine_vars(all_vars, task._role.get_default_vars(dep_chain=task.get_dep_chain()))
|
|
||||||
|
|
||||||
if host:
|
|
||||||
# first we merge in vars from groups specified in the inventory (INI or script)
|
|
||||||
all_vars = combine_vars(all_vars, host.get_group_vars())
|
|
||||||
|
|
||||||
# these are PLAY host/group vars, inventory adjacent ones have already been processed
|
|
||||||
# next, we load any vars from group_vars files and then any vars from host_vars
|
|
||||||
# files which may apply to this host or the groups it belongs to. We merge in the
|
|
||||||
# special 'all' group_vars first, if they exist
|
|
||||||
if 'all' in self._group_vars_files:
|
|
||||||
data = preprocess_vars(self._group_vars_files['all'])
|
|
||||||
for item in data:
|
|
||||||
all_vars = combine_vars(all_vars, item)
|
|
||||||
|
|
||||||
for group in sorted(host.get_groups(), key=lambda g: (g.depth, g.priority, g.name)):
|
|
||||||
if group.name in self._group_vars_files and group.name != 'all':
|
|
||||||
for data in self._group_vars_files[group.name]:
|
|
||||||
data = preprocess_vars(data)
|
|
||||||
for item in data:
|
|
||||||
all_vars = combine_vars(all_vars, item)
|
|
||||||
|
|
||||||
# then we merge in vars from the host specified in the inventory (INI or script)
|
|
||||||
all_vars = combine_vars(all_vars, host.get_vars())
|
|
||||||
|
|
||||||
# then we merge in the host_vars/<hostname> file, if it exists
|
|
||||||
host_name = host.get_name()
|
|
||||||
if host_name in self._host_vars_files:
|
|
||||||
for data in self._host_vars_files[host_name]:
|
|
||||||
data = preprocess_vars(data)
|
|
||||||
for item in data:
|
|
||||||
all_vars = combine_vars(all_vars, item)
|
|
||||||
|
|
||||||
# finally, the facts caches for this host, if it exists
|
|
||||||
try:
|
|
||||||
host_facts = wrap_var(self._fact_cache.get(host.name, dict()))
|
|
||||||
if not C.NAMESPACE_FACTS:
|
|
||||||
# allow facts to polute main namespace
|
|
||||||
all_vars = combine_vars(all_vars, host_facts)
|
|
||||||
# always return namespaced facts
|
|
||||||
all_vars = combine_vars(all_vars, {'ansible_facts': host_facts})
|
|
||||||
except KeyError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
if play:
|
|
||||||
all_vars = combine_vars(all_vars, play.get_vars())
|
|
||||||
|
|
||||||
for vars_file_item in play.get_vars_files():
|
|
||||||
# create a set of temporary vars here, which incorporate the extra
|
|
||||||
# and magic vars so we can properly template the vars_files entries
|
|
||||||
temp_vars = combine_vars(all_vars, self._extra_vars)
|
|
||||||
temp_vars = combine_vars(temp_vars, magic_variables)
|
|
||||||
templar = Templar(loader=loader, variables=temp_vars)
|
|
||||||
|
|
||||||
# we assume each item in the list is itself a list, as we
|
|
||||||
# support "conditional includes" for vars_files, which mimics
|
|
||||||
# the with_first_found mechanism.
|
|
||||||
vars_file_list = vars_file_item
|
|
||||||
if not isinstance(vars_file_list, list):
|
|
||||||
vars_file_list = [vars_file_list]
|
|
||||||
|
|
||||||
# now we iterate through the (potential) files, and break out
|
|
||||||
# as soon as we read one from the list. If none are found, we
|
|
||||||
# raise an error, which is silently ignored at this point.
|
|
||||||
try:
|
|
||||||
for vars_file in vars_file_list:
|
|
||||||
vars_file = templar.template(vars_file)
|
|
||||||
try:
|
|
||||||
data = preprocess_vars(loader.load_from_file(vars_file))
|
|
||||||
if data is not None:
|
|
||||||
for item in data:
|
|
||||||
all_vars = combine_vars(all_vars, item)
|
|
||||||
break
|
|
||||||
except AnsibleFileNotFound:
|
|
||||||
# we continue on loader failures
|
|
||||||
continue
|
|
||||||
except AnsibleParserError:
|
|
||||||
raise
|
|
||||||
else:
|
|
||||||
# if include_delegate_to is set to False, we ignore the missing
|
|
||||||
# vars file here because we're working on a delegated host
|
|
||||||
if include_delegate_to:
|
|
||||||
raise AnsibleFileNotFound("vars file %s was not found" % vars_file_item)
|
|
||||||
except (UndefinedError, AnsibleUndefinedVariable):
|
|
||||||
if host is not None and self._fact_cache.get(host.name, dict()).get('module_setup') and task is not None:
|
|
||||||
raise AnsibleUndefinedVariable("an undefined variable was found when attempting to template the vars_files item '%s'" % vars_file_item,
|
|
||||||
obj=vars_file_item)
|
|
||||||
else:
|
|
||||||
# we do not have a full context here, and the missing variable could be
|
|
||||||
# because of that, so just show a warning and continue
|
|
||||||
display.vvv("skipping vars_file '%s' due to an undefined variable" % vars_file_item)
|
|
||||||
continue
|
|
||||||
|
|
||||||
# By default, we now merge in all vars from all roles in the play,
|
|
||||||
# unless the user has disabled this via a config option
|
|
||||||
if not C.DEFAULT_PRIVATE_ROLE_VARS:
|
|
||||||
for role in play.get_roles():
|
|
||||||
all_vars = combine_vars(all_vars, role.get_vars(include_params=False))
|
|
||||||
|
|
||||||
# next, we merge in the vars from the role, which will specifically
|
|
||||||
# follow the role dependency chain, and then we merge in the tasks
|
|
||||||
# vars (which will look at parent blocks/task includes)
|
|
||||||
if task:
|
|
||||||
if task._role:
|
|
||||||
all_vars = combine_vars(all_vars, task._role.get_vars(task.get_dep_chain(), include_params=False))
|
|
||||||
all_vars = combine_vars(all_vars, task.get_vars())
|
|
||||||
|
|
||||||
# next, we merge in the vars cache (include vars) and nonpersistent
|
|
||||||
# facts cache (set_fact/register), in that order
|
|
||||||
if host:
|
|
||||||
all_vars = combine_vars(all_vars, self._vars_cache.get(host.get_name(), dict()))
|
|
||||||
all_vars = combine_vars(all_vars, self._nonpersistent_fact_cache.get(host.name, dict()))
|
|
||||||
|
|
||||||
# next, we merge in role params and task include params
|
|
||||||
if task:
|
|
||||||
if task._role:
|
|
||||||
all_vars = combine_vars(all_vars, task._role.get_role_params(task.get_dep_chain()))
|
|
||||||
|
|
||||||
# special case for include tasks, where the include params
|
|
||||||
# may be specified in the vars field for the task, which should
|
|
||||||
# have higher precedence than the vars/np facts above
|
|
||||||
all_vars = combine_vars(all_vars, task.get_include_params())
|
|
||||||
|
|
||||||
# finally, we merge in extra vars and the magic variables
|
|
||||||
all_vars = combine_vars(all_vars, self._extra_vars)
|
|
||||||
all_vars = combine_vars(all_vars, magic_variables)
|
|
||||||
|
|
||||||
# special case for the 'environment' magic variable, as someone
|
|
||||||
# may have set it as a variable and we don't want to stomp on it
|
|
||||||
if task:
|
|
||||||
if 'environment' not in all_vars:
|
|
||||||
all_vars['environment'] = task.environment
|
|
||||||
else:
|
|
||||||
display.warning("The variable 'environment' appears to be used already, which is also used internally for environment variables set on the "
|
|
||||||
"task/block/play. You should use a different variable name to avoid conflicts with this internal variable")
|
|
||||||
|
|
||||||
# if we have a task and we're delegating to another host, figure out the
|
|
||||||
# variables for that host now so we don't have to rely on hostvars later
|
|
||||||
if task and task.delegate_to is not None and include_delegate_to:
|
|
||||||
all_vars['ansible_delegated_vars'] = self._get_delegated_vars(loader, play, task, all_vars)
|
|
||||||
|
|
||||||
# VARIABLE_CACHE[cache_entry] = all_vars
|
|
||||||
if task or play:
|
|
||||||
all_vars['vars'] = all_vars.copy()
|
|
||||||
|
|
||||||
display.debug("done with get_vars()")
|
|
||||||
return all_vars
|
|
||||||
|
|
||||||
def invalidate_hostvars_cache(self, play):
|
|
||||||
hostvars_cache_entry = self._get_cache_entry(play=play)
|
|
||||||
if hostvars_cache_entry in HOSTVARS_CACHE:
|
|
||||||
del HOSTVARS_CACHE[hostvars_cache_entry]
|
|
||||||
|
|
||||||
def _get_magic_variables(self, loader, play, host, task, include_hostvars, include_delegate_to):
|
|
||||||
'''
|
|
||||||
Returns a dictionary of so-called "magic" variables in Ansible,
|
|
||||||
which are special variables we set internally for use.
|
|
||||||
'''
|
|
||||||
|
|
||||||
variables = dict()
|
|
||||||
variables['playbook_dir'] = loader.get_basedir()
|
|
||||||
variables['ansible_playbook_python'] = sys.executable
|
|
||||||
|
|
||||||
if host:
|
|
||||||
# host already provides some magic vars via host.get_vars()
|
|
||||||
if self._inventory:
|
|
||||||
variables['groups'] = self._inventory.get_group_dict()
|
|
||||||
|
|
||||||
if play:
|
|
||||||
variables['role_names'] = [r._role_name for r in play.roles]
|
|
||||||
|
|
||||||
if task:
|
|
||||||
if task._role:
|
|
||||||
variables['role_name'] = task._role.get_name()
|
|
||||||
variables['role_path'] = task._role._role_path
|
|
||||||
variables['role_uuid'] = text_type(task._role._uuid)
|
|
||||||
|
|
||||||
if self._inventory is not None:
|
|
||||||
variables['inventory_dir'] = self._inventory.basedir()
|
|
||||||
variables['inventory_file'] = self._inventory.src()
|
|
||||||
if play:
|
|
||||||
templar = Templar(loader=loader)
|
|
||||||
if templar.is_template(play.hosts):
|
|
||||||
pattern = 'all'
|
|
||||||
else:
|
|
||||||
pattern = play.hosts or 'all'
|
|
||||||
# add the list of hosts in the play, as adjusted for limit/filters
|
|
||||||
variables['ansible_play_hosts_all'] = [x.name for x in self._inventory.get_hosts(pattern=pattern, ignore_restrictions=True)]
|
|
||||||
variables['ansible_play_hosts'] = [x for x in variables['ansible_play_hosts_all'] if x not in play._removed_hosts]
|
|
||||||
variables['ansible_play_batch'] = [x.name for x in self._inventory.get_hosts() if x.name not in play._removed_hosts]
|
|
||||||
|
|
||||||
# DEPRECATED: play_hosts should be deprecated in favor of ansible_play_batch,
|
|
||||||
# however this would take work in the templating engine, so for now we'll add both
|
|
||||||
variables['play_hosts'] = variables['ansible_play_batch']
|
|
||||||
|
|
||||||
# the 'omit' value alows params to be left out if the variable they are based on is undefined
|
|
||||||
variables['omit'] = self._omit_token
|
|
||||||
variables['ansible_version'] = CLI.version_info(gitinfo=False)
|
|
||||||
# Set options vars
|
|
||||||
for option, option_value in iteritems(self._options_vars):
|
|
||||||
variables[option] = option_value
|
|
||||||
|
|
||||||
if self._hostvars is not None and include_hostvars:
|
|
||||||
variables['hostvars'] = self._hostvars
|
|
||||||
|
|
||||||
return variables
|
|
||||||
|
|
||||||
def _get_delegated_vars(self, loader, play, task, existing_variables):
|
|
||||||
# we unfortunately need to template the delegate_to field here,
|
|
||||||
# as we're fetching vars before post_validate has been called on
|
|
||||||
# the task that has been passed in
|
|
||||||
vars_copy = existing_variables.copy()
|
|
||||||
templar = Templar(loader=loader, variables=vars_copy)
|
|
||||||
|
|
||||||
items = []
|
|
||||||
if task.loop is not None:
|
|
||||||
if task.loop in lookup_loader:
|
|
||||||
try:
|
|
||||||
loop_terms = listify_lookup_plugin_terms(terms=task.loop_args, templar=templar, loader=loader, fail_on_undefined=True, convert_bare=False)
|
|
||||||
items = lookup_loader.get(task.loop, loader=loader, templar=templar).run(terms=loop_terms, variables=vars_copy)
|
|
||||||
except AnsibleUndefinedVariable:
|
|
||||||
# This task will be skipped later due to this, so we just setup
|
|
||||||
# a dummy array for the later code so it doesn't fail
|
|
||||||
items = [None]
|
|
||||||
else:
|
|
||||||
raise AnsibleError("Unexpected failure in finding the lookup named '%s' in the available lookup plugins" % task.loop)
|
|
||||||
else:
|
|
||||||
items = [None]
|
|
||||||
|
|
||||||
delegated_host_vars = dict()
|
|
||||||
for item in items:
|
|
||||||
# update the variables with the item value for templating, in case we need it
|
|
||||||
if item is not None:
|
|
||||||
vars_copy['item'] = item
|
|
||||||
|
|
||||||
templar.set_available_variables(vars_copy)
|
|
||||||
delegated_host_name = templar.template(task.delegate_to, fail_on_undefined=False)
|
|
||||||
if delegated_host_name is None:
|
|
||||||
raise AnsibleError(message="Undefined delegate_to host for task:", obj=task._ds)
|
|
||||||
if delegated_host_name in delegated_host_vars:
|
|
||||||
# no need to repeat ourselves, as the delegate_to value
|
|
||||||
# does not appear to be tied to the loop item variable
|
|
||||||
continue
|
|
||||||
|
|
||||||
# a dictionary of variables to use if we have to create a new host below
|
|
||||||
# we set the default port based on the default transport here, to make sure
|
|
||||||
# we use the proper default for windows
|
|
||||||
new_port = C.DEFAULT_REMOTE_PORT
|
|
||||||
if C.DEFAULT_TRANSPORT == 'winrm':
|
|
||||||
new_port = 5986
|
|
||||||
|
|
||||||
new_delegated_host_vars = dict(
|
|
||||||
ansible_host=delegated_host_name,
|
|
||||||
ansible_port=new_port,
|
|
||||||
ansible_user=C.DEFAULT_REMOTE_USER,
|
|
||||||
ansible_connection=C.DEFAULT_TRANSPORT,
|
|
||||||
)
|
|
||||||
|
|
||||||
# now try to find the delegated-to host in inventory, or failing that,
|
|
||||||
# create a new host on the fly so we can fetch variables for it
|
|
||||||
delegated_host = None
|
|
||||||
if self._inventory is not None:
|
|
||||||
delegated_host = self._inventory.get_host(delegated_host_name)
|
|
||||||
# try looking it up based on the address field, and finally
|
|
||||||
# fall back to creating a host on the fly to use for the var lookup
|
|
||||||
if delegated_host is None:
|
|
||||||
if delegated_host_name in C.LOCALHOST:
|
|
||||||
delegated_host = self._inventory.localhost
|
|
||||||
else:
|
|
||||||
for h in self._inventory.get_hosts(ignore_limits=True, ignore_restrictions=True):
|
|
||||||
# check if the address matches, or if both the delegated_to host
|
|
||||||
# and the current host are in the list of localhost aliases
|
|
||||||
if h.address == delegated_host_name:
|
|
||||||
delegated_host = h
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
delegated_host = Host(name=delegated_host_name)
|
|
||||||
delegated_host.vars.update(new_delegated_host_vars)
|
|
||||||
else:
|
|
||||||
delegated_host = Host(name=delegated_host_name)
|
|
||||||
delegated_host.vars.update(new_delegated_host_vars)
|
|
||||||
|
|
||||||
# now we go fetch the vars for the delegated-to host and save them in our
|
|
||||||
# master dictionary of variables to be used later in the TaskExecutor/PlayContext
|
|
||||||
delegated_host_vars[delegated_host_name] = self.get_vars(
|
|
||||||
loader=loader,
|
|
||||||
play=play,
|
|
||||||
host=delegated_host,
|
|
||||||
task=task,
|
|
||||||
include_delegate_to=False,
|
|
||||||
include_hostvars=False,
|
|
||||||
)
|
|
||||||
|
|
||||||
return delegated_host_vars
|
|
||||||
|
|
||||||
def _get_inventory_basename(self, path):
|
|
||||||
'''
|
|
||||||
Returns the basename minus the extension of the given path, so the
|
|
||||||
bare filename can be matched against host/group names later
|
|
||||||
'''
|
|
||||||
|
|
||||||
(name, ext) = os.path.splitext(os.path.basename(path))
|
|
||||||
if ext not in ('.yml', '.yaml'):
|
|
||||||
return os.path.basename(path)
|
|
||||||
else:
|
|
||||||
return name
|
|
||||||
|
|
||||||
def _load_inventory_file(self, path, loader, filter_ext=False):
|
|
||||||
'''
|
|
||||||
helper function, which loads the file and gets the
|
|
||||||
basename of the file without the extension
|
|
||||||
'''
|
|
||||||
|
|
||||||
if loader.is_directory(path):
|
|
||||||
data = dict()
|
|
||||||
|
|
||||||
try:
|
|
||||||
names = loader.list_directory(path)
|
|
||||||
except os.error as err:
|
|
||||||
raise AnsibleError("This folder cannot be listed: %s: %s." % (path, err.strerror))
|
|
||||||
|
|
||||||
# evaluate files in a stable order rather than whatever
|
|
||||||
# order the filesystem lists them.
|
|
||||||
names.sort()
|
|
||||||
|
|
||||||
# do not parse hidden files or dirs, e.g. .svn/
|
|
||||||
paths = [os.path.join(path, name) for name in names if not (name.startswith('.') or name.endswith('~'))]
|
|
||||||
for p in paths:
|
|
||||||
results = self._load_inventory_file(path=p, loader=loader, filter_ext=True)
|
|
||||||
if results is not None:
|
|
||||||
data = combine_vars(data, results)
|
|
||||||
|
|
||||||
else:
|
|
||||||
file_name, ext = os.path.splitext(path)
|
|
||||||
data = None
|
|
||||||
if not filter_ext or ext in C.YAML_FILENAME_EXTENSIONS:
|
|
||||||
if loader.path_exists(path):
|
|
||||||
data = loader.load_from_file(path)
|
|
||||||
else:
|
|
||||||
# try appending yaml extenstion to find valid files
|
|
||||||
# avoid empty extensions otherwise all files would be tried
|
|
||||||
for test_ext in (ext for ext in C.YAML_FILENAME_EXTENSIONS if ext):
|
|
||||||
new_path = path + test_ext
|
|
||||||
if loader.path_exists(new_path):
|
|
||||||
data = loader.load_from_file(new_path)
|
|
||||||
break
|
|
||||||
|
|
||||||
rval = AnsibleInventoryVarsData()
|
|
||||||
rval.path = path
|
|
||||||
|
|
||||||
if data is not None:
|
|
||||||
if not isinstance(data, dict):
|
|
||||||
raise AnsibleError("Problem parsing file '%s': line %d, column %d" % data.ansible_pos)
|
|
||||||
else:
|
|
||||||
rval.update(data)
|
|
||||||
|
|
||||||
return rval
|
|
||||||
|
|
||||||
def add_host_vars_file(self, path, loader):
|
|
||||||
'''
|
|
||||||
Loads and caches a host_vars file in the _host_vars_files dict,
|
|
||||||
where the key to that dictionary is the basename of the file, minus
|
|
||||||
the extension, for matching against a given inventory host name
|
|
||||||
'''
|
|
||||||
|
|
||||||
name = self._get_inventory_basename(path)
|
|
||||||
if name not in self._host_vars_files:
|
|
||||||
self._host_vars_files[name] = []
|
|
||||||
|
|
||||||
for entry in self._host_vars_files[name]:
|
|
||||||
if entry.path == path:
|
|
||||||
data = entry
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
data = self._load_inventory_file(path, loader)
|
|
||||||
if data:
|
|
||||||
self._host_vars_files[name].append(data)
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
def add_group_vars_file(self, path, loader):
|
|
||||||
'''
|
|
||||||
Loads and caches a host_vars file in the _host_vars_files dict,
|
|
||||||
where the key to that dictionary is the basename of the file, minus
|
|
||||||
the extension, for matching against a given inventory host name
|
|
||||||
'''
|
|
||||||
|
|
||||||
name = self._get_inventory_basename(path)
|
|
||||||
if name not in self._group_vars_files:
|
|
||||||
self._group_vars_files[name] = []
|
|
||||||
|
|
||||||
for entry in self._group_vars_files[name]:
|
|
||||||
if entry.path == path:
|
|
||||||
data = entry
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
data = self._load_inventory_file(path, loader)
|
|
||||||
if data:
|
|
||||||
self._group_vars_files[name].append(data)
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
def clear_playbook_hostgroup_vars_files(self, path):
|
|
||||||
for f in self._host_vars_files.keys():
|
|
||||||
keepers = []
|
|
||||||
for entry in self._host_vars_files[f]:
|
|
||||||
if os.path.dirname(entry.path) != os.path.join(path, 'host_vars'):
|
|
||||||
keepers.append(entry)
|
|
||||||
self._host_vars_files[f] = keepers
|
|
||||||
for f in self._group_vars_files.keys():
|
|
||||||
keepers = []
|
|
||||||
for entry in self._group_vars_files[f]:
|
|
||||||
if os.path.dirname(entry.path) != os.path.join(path, 'group_vars'):
|
|
||||||
keepers.append(entry)
|
|
||||||
self._group_vars_files[f] = keepers
|
|
||||||
|
|
||||||
def clear_facts(self, hostname):
|
|
||||||
'''
|
|
||||||
Clears the facts for a host
|
|
||||||
'''
|
|
||||||
if hostname in self._fact_cache:
|
|
||||||
del self._fact_cache[hostname]
|
|
||||||
|
|
||||||
def set_host_facts(self, host, facts):
|
|
||||||
'''
|
|
||||||
Sets or updates the given facts for a host in the fact cache.
|
|
||||||
'''
|
|
||||||
|
|
||||||
assert isinstance(facts, dict)
|
|
||||||
|
|
||||||
if host.name not in self._fact_cache:
|
|
||||||
self._fact_cache[host.name] = facts
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
self._fact_cache.update(host.name, facts)
|
|
||||||
except KeyError:
|
|
||||||
self._fact_cache[host.name] = facts
|
|
||||||
|
|
||||||
def set_nonpersistent_facts(self, host, facts):
|
|
||||||
'''
|
|
||||||
Sets or updates the given facts for a host in the fact cache.
|
|
||||||
'''
|
|
||||||
|
|
||||||
assert isinstance(facts, dict)
|
|
||||||
|
|
||||||
if host.name not in self._nonpersistent_fact_cache:
|
|
||||||
self._nonpersistent_fact_cache[host.name] = facts
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
self._nonpersistent_fact_cache[host.name].update(facts)
|
|
||||||
except KeyError:
|
|
||||||
self._nonpersistent_fact_cache[host.name] = facts
|
|
||||||
|
|
||||||
def set_host_variable(self, host, varname, value):
|
|
||||||
'''
|
|
||||||
Sets a value in the vars_cache for a host.
|
|
||||||
'''
|
|
||||||
host_name = host.get_name()
|
|
||||||
if host_name not in self._vars_cache:
|
|
||||||
self._vars_cache[host_name] = dict()
|
|
||||||
if varname in self._vars_cache[host_name] and isinstance(self._vars_cache[host_name][varname], MutableMapping) and isinstance(value, MutableMapping):
|
|
||||||
self._vars_cache[host_name] = combine_vars(self._vars_cache[host_name], {varname: value})
|
|
||||||
else:
|
|
||||||
self._vars_cache[host_name][varname] = value
|
|
||||||
@ -0,0 +1,598 @@
|
|||||||
|
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
||||||
|
#
|
||||||
|
# This file is part of Ansible
|
||||||
|
#
|
||||||
|
# Ansible is free software: you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation, either version 3 of the License, or
|
||||||
|
# (at your option) any later version.
|
||||||
|
#
|
||||||
|
# Ansible 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 Ansible. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
# Make coding more python3-ish
|
||||||
|
from __future__ import (absolute_import, division, print_function)
|
||||||
|
__metaclass__ = type
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
from collections import defaultdict, MutableMapping
|
||||||
|
|
||||||
|
try:
|
||||||
|
from hashlib import sha1
|
||||||
|
except ImportError:
|
||||||
|
from sha import sha as sha1
|
||||||
|
|
||||||
|
from jinja2.exceptions import UndefinedError
|
||||||
|
|
||||||
|
from ansible import constants as C
|
||||||
|
from ansible.errors import AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleFileNotFound
|
||||||
|
from ansible.inventory.host import Host
|
||||||
|
from ansible.inventory.helpers import sort_groups, get_group_vars
|
||||||
|
from ansible.module_utils._text import to_native
|
||||||
|
from ansible.module_utils.six import iteritems, string_types, text_type
|
||||||
|
from ansible.plugins import lookup_loader, vars_loader
|
||||||
|
from ansible.plugins.cache import FactCache
|
||||||
|
from ansible.template import Templar
|
||||||
|
from ansible.utils.listify import listify_lookup_plugin_terms
|
||||||
|
from ansible.utils.vars import combine_vars
|
||||||
|
from ansible.utils.unsafe_proxy import wrap_var
|
||||||
|
|
||||||
|
try:
|
||||||
|
from __main__ import display
|
||||||
|
except ImportError:
|
||||||
|
from ansible.utils.display import Display
|
||||||
|
display = Display()
|
||||||
|
|
||||||
|
|
||||||
|
def preprocess_vars(a):
|
||||||
|
'''
|
||||||
|
Ensures that vars contained in the parameter passed in are
|
||||||
|
returned as a list of dictionaries, to ensure for instance
|
||||||
|
that vars loaded from a file conform to an expected state.
|
||||||
|
'''
|
||||||
|
|
||||||
|
if a is None:
|
||||||
|
return None
|
||||||
|
elif not isinstance(a, list):
|
||||||
|
data = [ a ]
|
||||||
|
else:
|
||||||
|
data = a
|
||||||
|
|
||||||
|
for item in data:
|
||||||
|
if not isinstance(item, MutableMapping):
|
||||||
|
raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a)))
|
||||||
|
|
||||||
|
return data
|
||||||
|
|
||||||
|
|
||||||
|
def strip_internal_keys(dirty):
|
||||||
|
'''
|
||||||
|
All keys stating with _ansible_ are internal, so create a copy of the 'dirty' dict
|
||||||
|
and remove them from the clean one before returning it
|
||||||
|
'''
|
||||||
|
clean = dirty.copy()
|
||||||
|
for k in dirty.keys():
|
||||||
|
if isinstance(k, string_types) and k.startswith('_ansible_'):
|
||||||
|
del clean[k]
|
||||||
|
elif isinstance(dirty[k], dict):
|
||||||
|
clean[k] = strip_internal_keys(dirty[k])
|
||||||
|
return clean
|
||||||
|
|
||||||
|
|
||||||
|
class VariableManager:
|
||||||
|
|
||||||
|
def __init__(self, loader=None, inventory=None):
|
||||||
|
|
||||||
|
self._nonpersistent_fact_cache = defaultdict(dict)
|
||||||
|
self._vars_cache = defaultdict(dict)
|
||||||
|
self._extra_vars = defaultdict(dict)
|
||||||
|
self._host_vars_files = defaultdict(dict)
|
||||||
|
self._group_vars_files = defaultdict(dict)
|
||||||
|
self._inventory = inventory
|
||||||
|
self._loader = loader
|
||||||
|
self._hostvars = None
|
||||||
|
self._omit_token = '__omit_place_holder__%s' % sha1(os.urandom(64)).hexdigest()
|
||||||
|
self._options_vars = defaultdict(dict)
|
||||||
|
|
||||||
|
# bad cache plugin is not fatal error
|
||||||
|
try:
|
||||||
|
self._fact_cache = FactCache()
|
||||||
|
except AnsibleError as e:
|
||||||
|
display.warning(to_native(e))
|
||||||
|
# fallback to a dict as in memory cache
|
||||||
|
self._fact_cache = {}
|
||||||
|
|
||||||
|
def __getstate__(self):
|
||||||
|
data = dict(
|
||||||
|
fact_cache = self._fact_cache,
|
||||||
|
np_fact_cache = self._nonpersistent_fact_cache,
|
||||||
|
vars_cache = self._vars_cache,
|
||||||
|
extra_vars = self._extra_vars,
|
||||||
|
host_vars_files = self._host_vars_files,
|
||||||
|
group_vars_files = self._group_vars_files,
|
||||||
|
omit_token = self._omit_token,
|
||||||
|
options_vars = self._options_vars,
|
||||||
|
inventory = self._inventory,
|
||||||
|
)
|
||||||
|
return data
|
||||||
|
|
||||||
|
def __setstate__(self, data):
|
||||||
|
self._fact_cache = data.get('fact_cache', defaultdict(dict))
|
||||||
|
self._nonpersistent_fact_cache = data.get('np_fact_cache', defaultdict(dict))
|
||||||
|
self._vars_cache = data.get('vars_cache', defaultdict(dict))
|
||||||
|
self._extra_vars = data.get('extra_vars', dict())
|
||||||
|
self._host_vars_files = data.get('host_vars_files', defaultdict(dict))
|
||||||
|
self._group_vars_files = data.get('group_vars_files', defaultdict(dict))
|
||||||
|
self._omit_token = data.get('omit_token', '__omit_place_holder__%s' % sha1(os.urandom(64)).hexdigest())
|
||||||
|
self._inventory = data.get('inventory', None)
|
||||||
|
self._options_vars = data.get('options_vars', dict())
|
||||||
|
|
||||||
|
@property
|
||||||
|
def extra_vars(self):
|
||||||
|
''' ensures a clean copy of the extra_vars are made '''
|
||||||
|
return self._extra_vars.copy()
|
||||||
|
|
||||||
|
@extra_vars.setter
|
||||||
|
def extra_vars(self, value):
|
||||||
|
''' ensures a clean copy of the extra_vars are used to set the value '''
|
||||||
|
assert isinstance(value, MutableMapping)
|
||||||
|
self._extra_vars = value.copy()
|
||||||
|
|
||||||
|
def set_inventory(self, inventory):
|
||||||
|
self._inventory = inventory
|
||||||
|
|
||||||
|
@property
|
||||||
|
def options_vars(self):
|
||||||
|
''' ensures a clean copy of the options_vars are made '''
|
||||||
|
return self._options_vars.copy()
|
||||||
|
|
||||||
|
@options_vars.setter
|
||||||
|
def options_vars(self, value):
|
||||||
|
''' ensures a clean copy of the options_vars are used to set the value '''
|
||||||
|
assert isinstance(value, dict)
|
||||||
|
self._options_vars = value.copy()
|
||||||
|
|
||||||
|
def _preprocess_vars(self, a):
|
||||||
|
'''
|
||||||
|
Ensures that vars contained in the parameter passed in are
|
||||||
|
returned as a list of dictionaries, to ensure for instance
|
||||||
|
that vars loaded from a file conform to an expected state.
|
||||||
|
'''
|
||||||
|
|
||||||
|
if a is None:
|
||||||
|
return None
|
||||||
|
elif not isinstance(a, list):
|
||||||
|
data = [ a ]
|
||||||
|
else:
|
||||||
|
data = a
|
||||||
|
|
||||||
|
for item in data:
|
||||||
|
if not isinstance(item, MutableMapping):
|
||||||
|
raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a)))
|
||||||
|
|
||||||
|
return data
|
||||||
|
|
||||||
|
def get_vars(self, play=None, host=None, task=None, include_hostvars=True, include_delegate_to=True, use_cache=True):
|
||||||
|
'''
|
||||||
|
Returns the variables, with optional "context" given via the parameters
|
||||||
|
for the play, host, and task (which could possibly result in different
|
||||||
|
sets of variables being returned due to the additional context).
|
||||||
|
|
||||||
|
The order of precedence is:
|
||||||
|
- play->roles->get_default_vars (if there is a play context)
|
||||||
|
- group_vars_files[host] (if there is a host context)
|
||||||
|
- host_vars_files[host] (if there is a host context)
|
||||||
|
- host->get_vars (if there is a host context)
|
||||||
|
- fact_cache[host] (if there is a host context)
|
||||||
|
- play vars (if there is a play context)
|
||||||
|
- play vars_files (if there's no host context, ignore
|
||||||
|
file names that cannot be templated)
|
||||||
|
- task->get_vars (if there is a task context)
|
||||||
|
- vars_cache[host] (if there is a host context)
|
||||||
|
- extra vars
|
||||||
|
'''
|
||||||
|
|
||||||
|
display.debug("in VariableManager get_vars()")
|
||||||
|
|
||||||
|
all_vars = dict()
|
||||||
|
magic_variables = self._get_magic_variables(
|
||||||
|
play=play,
|
||||||
|
host=host,
|
||||||
|
task=task,
|
||||||
|
include_hostvars=include_hostvars,
|
||||||
|
include_delegate_to=include_delegate_to,
|
||||||
|
)
|
||||||
|
|
||||||
|
if play:
|
||||||
|
# first we compile any vars specified in defaults/main.yml
|
||||||
|
# for all roles within the specified play
|
||||||
|
for role in play.get_roles():
|
||||||
|
all_vars = combine_vars(all_vars, role.get_default_vars())
|
||||||
|
|
||||||
|
# if we have a task in this context, and that task has a role, make
|
||||||
|
# sure it sees its defaults above any other roles, as we previously
|
||||||
|
# (v1) made sure each task had a copy of its roles default vars
|
||||||
|
if task and task._role is not None and (play or task.action == 'include_role'):
|
||||||
|
all_vars = combine_vars(all_vars, task._role.get_default_vars(dep_chain=task.get_dep_chain()))
|
||||||
|
|
||||||
|
if host:
|
||||||
|
### INIT WORK (use unsafe as we are going to copy/merge vars, no need to x2 copy)
|
||||||
|
# basedir, THE 'all' group and the rest of groups for a host, used below
|
||||||
|
basedir = self._loader.get_basedir()
|
||||||
|
all_group = self._inventory.groups.get('all')
|
||||||
|
host_groups = sort_groups([g for g in host.get_groups() if g.name not in ['all']])
|
||||||
|
|
||||||
|
### internal fuctions that actually do the work ###
|
||||||
|
def _plugins_inventory(entities):
|
||||||
|
''' merges all entities by inventory source '''
|
||||||
|
data = {}
|
||||||
|
for inventory_dir in self._inventory._sources:
|
||||||
|
if ',' in inventory_dir: # skip host lists
|
||||||
|
continue
|
||||||
|
elif not os.path.isdir(inventory_dir): # always pass 'inventory directory'
|
||||||
|
inventory_dir = os.path.dirname(inventory_dir)
|
||||||
|
|
||||||
|
for plugin in vars_loader.all():
|
||||||
|
data = combine_vars(data, plugin.get_vars(self._loader, inventory_dir, entities))
|
||||||
|
|
||||||
|
return data
|
||||||
|
|
||||||
|
def _plugins_play(entities):
|
||||||
|
''' merges all entities adjacent to play '''
|
||||||
|
data = {}
|
||||||
|
for plugin in vars_loader.all():
|
||||||
|
data = combine_vars(data, plugin.get_vars(self._loader, basedir, entities))
|
||||||
|
return data
|
||||||
|
|
||||||
|
### configurable functions that are sortable via config ###
|
||||||
|
def all_inventory():
|
||||||
|
return all_group.get_vars()
|
||||||
|
|
||||||
|
def all_plugins_inventory():
|
||||||
|
return _plugins_inventory([all_group])
|
||||||
|
|
||||||
|
def all_plugins_play():
|
||||||
|
return _plugins_play([all_group])
|
||||||
|
|
||||||
|
def groups_inventory():
|
||||||
|
''' gets group vars from inventory '''
|
||||||
|
return get_group_vars(host_groups)
|
||||||
|
|
||||||
|
def groups_plugins_inventory():
|
||||||
|
''' gets plugin sources from inventory for groups '''
|
||||||
|
return _plugins_inventory(host_groups)
|
||||||
|
|
||||||
|
def groups_plugins_play():
|
||||||
|
''' gets plugin sources from play for groups '''
|
||||||
|
return _plugins_play(host_groups)
|
||||||
|
|
||||||
|
def plugins_by_groups():
|
||||||
|
'''
|
||||||
|
merges all plugin sources by group,
|
||||||
|
This should be used instead, NOT in combination with the other groups_plugins* functions
|
||||||
|
'''
|
||||||
|
data = {}
|
||||||
|
for group in host_groups:
|
||||||
|
data[group] = combine_vars(data[group], _plugins_inventory(group))
|
||||||
|
data[group] = combine_vars(data[group], _plugins_play(group))
|
||||||
|
return data
|
||||||
|
|
||||||
|
# Merge as per precedence config
|
||||||
|
for entry in C.VARIABLE_PRECEDENCE:
|
||||||
|
# only allow to call the functions we want exposed
|
||||||
|
if entry.startswith('_') or '.' in entry:
|
||||||
|
continue
|
||||||
|
display.debug('Calling %s to load vars for %s' % (entry, host.name))
|
||||||
|
all_vars = combine_vars(all_vars, locals()[entry]())
|
||||||
|
|
||||||
|
# host vars, from inventory, inventory adjacent and play adjacent via plugins
|
||||||
|
all_vars = combine_vars(all_vars, host.get_vars())
|
||||||
|
all_vars = combine_vars(all_vars, _plugins_inventory([host]))
|
||||||
|
all_vars = combine_vars(all_vars, _plugins_play([host]))
|
||||||
|
|
||||||
|
# finally, the facts caches for this host, if it exists
|
||||||
|
try:
|
||||||
|
host_facts = wrap_var(self._fact_cache.get(host.name, dict()))
|
||||||
|
if not C.NAMESPACE_FACTS:
|
||||||
|
# allow facts to polute main namespace
|
||||||
|
all_vars = combine_vars(all_vars, host_facts)
|
||||||
|
# always return namespaced facts
|
||||||
|
all_vars = combine_vars(all_vars, {'ansible_facts': host_facts})
|
||||||
|
except KeyError:
|
||||||
|
pass
|
||||||
|
|
||||||
|
if play:
|
||||||
|
all_vars = combine_vars(all_vars, play.get_vars())
|
||||||
|
|
||||||
|
for vars_file_item in play.get_vars_files():
|
||||||
|
# create a set of temporary vars here, which incorporate the extra
|
||||||
|
# and magic vars so we can properly template the vars_files entries
|
||||||
|
temp_vars = combine_vars(all_vars, self._extra_vars)
|
||||||
|
temp_vars = combine_vars(temp_vars, magic_variables)
|
||||||
|
templar = Templar(loader=self._loader, variables=temp_vars)
|
||||||
|
|
||||||
|
# we assume each item in the list is itself a list, as we
|
||||||
|
# support "conditional includes" for vars_files, which mimics
|
||||||
|
# the with_first_found mechanism.
|
||||||
|
vars_file_list = vars_file_item
|
||||||
|
if not isinstance(vars_file_list, list):
|
||||||
|
vars_file_list = [vars_file_list]
|
||||||
|
|
||||||
|
# now we iterate through the (potential) files, and break out
|
||||||
|
# as soon as we read one from the list. If none are found, we
|
||||||
|
# raise an error, which is silently ignored at this point.
|
||||||
|
try:
|
||||||
|
for vars_file in vars_file_list:
|
||||||
|
vars_file = templar.template(vars_file)
|
||||||
|
try:
|
||||||
|
data = preprocess_vars(self._loader.load_from_file(vars_file, unsafe=True))
|
||||||
|
if data is not None:
|
||||||
|
for item in data:
|
||||||
|
all_vars = combine_vars(all_vars, item)
|
||||||
|
break
|
||||||
|
except AnsibleFileNotFound:
|
||||||
|
# we continue on loader failures
|
||||||
|
continue
|
||||||
|
except AnsibleParserError:
|
||||||
|
raise
|
||||||
|
else:
|
||||||
|
# if include_delegate_to is set to False, we ignore the missing
|
||||||
|
# vars file here because we're working on a delegated host
|
||||||
|
if include_delegate_to:
|
||||||
|
raise AnsibleFileNotFound("vars file %s was not found" % vars_file_item)
|
||||||
|
except (UndefinedError, AnsibleUndefinedVariable):
|
||||||
|
if host is not None and self._fact_cache.get(host.name, dict()).get('module_setup') and task is not None:
|
||||||
|
raise AnsibleUndefinedVariable("an undefined variable was found when attempting to template the vars_files item '%s'" % vars_file_item,
|
||||||
|
obj=vars_file_item)
|
||||||
|
else:
|
||||||
|
# we do not have a full context here, and the missing variable could be
|
||||||
|
# because of that, so just show a warning and continue
|
||||||
|
display.vvv("skipping vars_file '%s' due to an undefined variable" % vars_file_item)
|
||||||
|
continue
|
||||||
|
|
||||||
|
# By default, we now merge in all vars from all roles in the play,
|
||||||
|
# unless the user has disabled this via a config option
|
||||||
|
if not C.DEFAULT_PRIVATE_ROLE_VARS:
|
||||||
|
for role in play.get_roles():
|
||||||
|
all_vars = combine_vars(all_vars, role.get_vars(include_params=False))
|
||||||
|
|
||||||
|
# next, we merge in the vars from the role, which will specifically
|
||||||
|
# follow the role dependency chain, and then we merge in the tasks
|
||||||
|
# vars (which will look at parent blocks/task includes)
|
||||||
|
if task:
|
||||||
|
if task._role:
|
||||||
|
all_vars = combine_vars(all_vars, task._role.get_vars(task.get_dep_chain(), include_params=False))
|
||||||
|
all_vars = combine_vars(all_vars, task.get_vars())
|
||||||
|
|
||||||
|
# next, we merge in the vars cache (include vars) and nonpersistent
|
||||||
|
# facts cache (set_fact/register), in that order
|
||||||
|
if host:
|
||||||
|
all_vars = combine_vars(all_vars, self._vars_cache.get(host.get_name(), dict()))
|
||||||
|
all_vars = combine_vars(all_vars, self._nonpersistent_fact_cache.get(host.name, dict()))
|
||||||
|
|
||||||
|
# next, we merge in role params and task include params
|
||||||
|
if task:
|
||||||
|
if task._role:
|
||||||
|
all_vars = combine_vars(all_vars, task._role.get_role_params(task.get_dep_chain()))
|
||||||
|
|
||||||
|
# special case for include tasks, where the include params
|
||||||
|
# may be specified in the vars field for the task, which should
|
||||||
|
# have higher precedence than the vars/np facts above
|
||||||
|
all_vars = combine_vars(all_vars, task.get_include_params())
|
||||||
|
|
||||||
|
# extra vars
|
||||||
|
all_vars = combine_vars(all_vars, self._extra_vars)
|
||||||
|
|
||||||
|
# magic variables
|
||||||
|
all_vars = combine_vars(all_vars, magic_variables)
|
||||||
|
|
||||||
|
# special case for the 'environment' magic variable, as someone
|
||||||
|
# may have set it as a variable and we don't want to stomp on it
|
||||||
|
if task:
|
||||||
|
all_vars['environment'] = task.environment
|
||||||
|
|
||||||
|
# if we have a task and we're delegating to another host, figure out the
|
||||||
|
# variables for that host now so we don't have to rely on hostvars later
|
||||||
|
if task and task.delegate_to is not None and include_delegate_to:
|
||||||
|
all_vars['ansible_delegated_vars'] = self._get_delegated_vars(play, task, all_vars)
|
||||||
|
|
||||||
|
# 'vars' magic var
|
||||||
|
if task or play:
|
||||||
|
# has to be copy, otherwise recursive ref
|
||||||
|
all_vars['vars'] = all_vars.copy()
|
||||||
|
|
||||||
|
display.debug("done with get_vars()")
|
||||||
|
return all_vars
|
||||||
|
|
||||||
|
def _get_magic_variables(self, play, host, task, include_hostvars, include_delegate_to):
|
||||||
|
'''
|
||||||
|
Returns a dictionary of so-called "magic" variables in Ansible,
|
||||||
|
which are special variables we set internally for use.
|
||||||
|
'''
|
||||||
|
|
||||||
|
variables = {}
|
||||||
|
variables['playbook_dir'] = os.path.abspath(self._loader.get_basedir())
|
||||||
|
variables['ansible_playbook_python'] = sys.executable
|
||||||
|
|
||||||
|
if host:
|
||||||
|
# host already provides some magic vars via host.get_vars()
|
||||||
|
if self._inventory:
|
||||||
|
variables['groups'] = self._inventory.get_groups_dict()
|
||||||
|
if play:
|
||||||
|
variables['role_names'] = [r._role_name for r in play.roles]
|
||||||
|
|
||||||
|
if task:
|
||||||
|
if task._role:
|
||||||
|
variables['role_name'] = task._role.get_name()
|
||||||
|
variables['role_path'] = task._role._role_path
|
||||||
|
variables['role_uuid'] = text_type(task._role._uuid)
|
||||||
|
|
||||||
|
if self._inventory is not None:
|
||||||
|
if play:
|
||||||
|
templar = Templar(loader=self._loader)
|
||||||
|
if templar.is_template(play.hosts):
|
||||||
|
pattern = 'all'
|
||||||
|
else:
|
||||||
|
pattern = play.hosts or 'all'
|
||||||
|
# add the list of hosts in the play, as adjusted for limit/filters
|
||||||
|
variables['ansible_play_hosts_all'] = [x.name for x in self._inventory.get_hosts(pattern=pattern, ignore_restrictions=True)]
|
||||||
|
variables['ansible_play_hosts'] = [x for x in variables['ansible_play_hosts_all'] if x not in play._removed_hosts]
|
||||||
|
variables['ansible_play_batch'] = [x.name for x in self._inventory.get_hosts() if x.name not in play._removed_hosts]
|
||||||
|
|
||||||
|
# DEPRECATED: play_hosts should be deprecated in favor of ansible_play_batch,
|
||||||
|
# however this would take work in the templating engine, so for now we'll add both
|
||||||
|
variables['play_hosts'] = variables['ansible_play_batch']
|
||||||
|
|
||||||
|
# the 'omit' value alows params to be left out if the variable they are based on is undefined
|
||||||
|
variables['omit'] = self._omit_token
|
||||||
|
# Set options vars
|
||||||
|
for option, option_value in iteritems(self._options_vars):
|
||||||
|
variables[option] = option_value
|
||||||
|
|
||||||
|
if self._hostvars is not None and include_hostvars:
|
||||||
|
variables['hostvars'] = self._hostvars
|
||||||
|
|
||||||
|
return variables
|
||||||
|
|
||||||
|
def _get_delegated_vars(self, play, task, existing_variables):
|
||||||
|
# we unfortunately need to template the delegate_to field here,
|
||||||
|
# as we're fetching vars before post_validate has been called on
|
||||||
|
# the task that has been passed in
|
||||||
|
vars_copy = existing_variables.copy()
|
||||||
|
templar = Templar(loader=self._loader, variables=vars_copy)
|
||||||
|
|
||||||
|
items = []
|
||||||
|
if task.loop is not None:
|
||||||
|
if task.loop in lookup_loader:
|
||||||
|
try:
|
||||||
|
loop_terms = listify_lookup_plugin_terms(terms=task.loop_args, templar=templar,
|
||||||
|
loader=self._loader, fail_on_undefined=True, convert_bare=False)
|
||||||
|
items = lookup_loader.get(task.loop, loader=self._loader, templar=templar).run(terms=loop_terms, variables=vars_copy)
|
||||||
|
except AnsibleUndefinedVariable:
|
||||||
|
# This task will be skipped later due to this, so we just setup
|
||||||
|
# a dummy array for the later code so it doesn't fail
|
||||||
|
items = [None]
|
||||||
|
else:
|
||||||
|
raise AnsibleError("Unexpected failure in finding the lookup named '%s' in the available lookup plugins" % task.loop)
|
||||||
|
else:
|
||||||
|
items = [None]
|
||||||
|
|
||||||
|
delegated_host_vars = dict()
|
||||||
|
for item in items:
|
||||||
|
# update the variables with the item value for templating, in case we need it
|
||||||
|
if item is not None:
|
||||||
|
vars_copy['item'] = item
|
||||||
|
|
||||||
|
templar.set_available_variables(vars_copy)
|
||||||
|
delegated_host_name = templar.template(task.delegate_to, fail_on_undefined=False)
|
||||||
|
if delegated_host_name is None:
|
||||||
|
raise AnsibleError(message="Undefined delegate_to host for task:", obj=task._ds)
|
||||||
|
if delegated_host_name in delegated_host_vars:
|
||||||
|
# no need to repeat ourselves, as the delegate_to value
|
||||||
|
# does not appear to be tied to the loop item variable
|
||||||
|
continue
|
||||||
|
|
||||||
|
# a dictionary of variables to use if we have to create a new host below
|
||||||
|
# we set the default port based on the default transport here, to make sure
|
||||||
|
# we use the proper default for windows
|
||||||
|
new_port = C.DEFAULT_REMOTE_PORT
|
||||||
|
if C.DEFAULT_TRANSPORT == 'winrm':
|
||||||
|
new_port = 5986
|
||||||
|
|
||||||
|
new_delegated_host_vars = dict(
|
||||||
|
ansible_host=delegated_host_name,
|
||||||
|
ansible_port=new_port,
|
||||||
|
ansible_user=C.DEFAULT_REMOTE_USER,
|
||||||
|
ansible_connection=C.DEFAULT_TRANSPORT,
|
||||||
|
)
|
||||||
|
|
||||||
|
# now try to find the delegated-to host in inventory, or failing that,
|
||||||
|
# create a new host on the fly so we can fetch variables for it
|
||||||
|
delegated_host = None
|
||||||
|
if self._inventory is not None:
|
||||||
|
delegated_host = self._inventory.get_host(delegated_host_name)
|
||||||
|
# try looking it up based on the address field, and finally
|
||||||
|
# fall back to creating a host on the fly to use for the var lookup
|
||||||
|
if delegated_host is None:
|
||||||
|
if delegated_host_name in C.LOCALHOST:
|
||||||
|
delegated_host = self._inventory.localhost
|
||||||
|
else:
|
||||||
|
for h in self._inventory.get_hosts(ignore_limits=True, ignore_restrictions=True):
|
||||||
|
# check if the address matches, or if both the delegated_to host
|
||||||
|
# and the current host are in the list of localhost aliases
|
||||||
|
if h.address == delegated_host_name:
|
||||||
|
delegated_host = h
|
||||||
|
break
|
||||||
|
else:
|
||||||
|
delegated_host = Host(name=delegated_host_name)
|
||||||
|
delegated_host.vars = combine_vars(delegated_host.vars, new_delegated_host_vars)
|
||||||
|
else:
|
||||||
|
delegated_host = Host(name=delegated_host_name)
|
||||||
|
delegated_host.vars = combine_vars(delegated_host.vars, new_delegated_host_vars)
|
||||||
|
|
||||||
|
# now we go fetch the vars for the delegated-to host and save them in our
|
||||||
|
# master dictionary of variables to be used later in the TaskExecutor/PlayContext
|
||||||
|
delegated_host_vars[delegated_host_name] = self.get_vars(
|
||||||
|
play=play,
|
||||||
|
host=delegated_host,
|
||||||
|
task=task,
|
||||||
|
include_delegate_to=False,
|
||||||
|
include_hostvars=False,
|
||||||
|
)
|
||||||
|
return delegated_host_vars
|
||||||
|
|
||||||
|
def clear_facts(self, hostname):
|
||||||
|
'''
|
||||||
|
Clears the facts for a host
|
||||||
|
'''
|
||||||
|
if hostname in self._fact_cache:
|
||||||
|
del self._fact_cache[hostname]
|
||||||
|
|
||||||
|
def set_host_facts(self, host, facts):
|
||||||
|
'''
|
||||||
|
Sets or updates the given facts for a host in the fact cache.
|
||||||
|
'''
|
||||||
|
|
||||||
|
assert isinstance(facts, dict)
|
||||||
|
|
||||||
|
if host.name not in self._fact_cache:
|
||||||
|
self._fact_cache[host.name] = facts
|
||||||
|
else:
|
||||||
|
try:
|
||||||
|
self._fact_cache.update(host.name, facts)
|
||||||
|
except KeyError:
|
||||||
|
self._fact_cache[host.name] = facts
|
||||||
|
|
||||||
|
def set_nonpersistent_facts(self, host, facts):
|
||||||
|
'''
|
||||||
|
Sets or updates the given facts for a host in the fact cache.
|
||||||
|
'''
|
||||||
|
|
||||||
|
assert isinstance(facts, dict)
|
||||||
|
|
||||||
|
if host.name not in self._nonpersistent_fact_cache:
|
||||||
|
self._nonpersistent_fact_cache[host.name] = facts
|
||||||
|
else:
|
||||||
|
try:
|
||||||
|
self._nonpersistent_fact_cache[host.name].update(facts)
|
||||||
|
except KeyError:
|
||||||
|
self._nonpersistent_fact_cache[host.name] = facts
|
||||||
|
|
||||||
|
def set_host_variable(self, host, varname, value):
|
||||||
|
'''
|
||||||
|
Sets a value in the vars_cache for a host.
|
||||||
|
'''
|
||||||
|
host_name = host.get_name()
|
||||||
|
if host_name not in self._vars_cache:
|
||||||
|
self._vars_cache[host_name] = dict()
|
||||||
|
if varname in self._vars_cache[host_name] and isinstance(self._vars_cache[host_name][varname], MutableMapping) and isinstance(value, MutableMapping):
|
||||||
|
self._vars_cache[host_name] = combine_vars(self._vars_cache[host_name], {varname: value})
|
||||||
|
else:
|
||||||
|
self._vars_cache[host_name][varname] = value
|
||||||
Loading…
Reference in New Issue