ansible/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2024-09-14 20:13:21 +02:00
Code Releases Activity

Fix for the way host variables were being swallowed, plus some overall simplification. Deciding what

Browse source 
dictionary to use for templating now happens in exactly one place (executor_internal) and the "inject"
dictionary is passed to what needs it.
This commit is contained in:
Michael DeHaan 2012-07-15 14:19:11 -04:00
parent 9ef7168a49
commit 5f69c557b9
4 changed files with 52 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
lib/ansible/playbook/__init__.py
View file

@ -281,6 +281,7 @@ class PlayBook(object):
# let runner template out future commands
setup_ok = setup_results.get('contacted', {})
for (host, result) in setup_ok.iteritems():
facts = result.get('ansible_facts', {})
self.SETUP_CACHE[host] = result.get('ansible_facts', {})
return setup_results

2
lib/ansible/playbook/play.py
View file

@ -45,7 +45,7 @@ class Play(object):
raise errors.AnsibleError('hosts declaration is required')
elif isinstance(hosts, list):
hosts = ';'.join(hosts)
hosts = utils.template(hosts, playbook.extra_vars, {})
hosts = utils.template(hosts, playbook.extra_vars)
self._ds = ds
self.playbook = playbook

88
lib/ansible/runner/__init__.py
View file

@ -237,25 +237,14 @@ class Runner(object):
# *****************************************************
def _execute_module(self, conn, tmp, remote_module_path, args,
async_jid=None, async_module=None, async_limit=None):
async_jid=None, async_module=None, async_limit=None, inject=None):
''' runs a module that has already been transferred '''
inject = self.setup_cache[conn.host].copy()
host_variables = self.inventory.get_variables(conn.host)
inject.update(host_variables)
inject.update(self.module_vars)
group_hosts = {}
for g in self.inventory.groups:
group_hosts[g.name] = map((lambda x: x.get_variables()),g.hosts)
inject['groups'] = group_hosts
if type(args) == dict:
args = utils.jsonify(args,format=True)
args = utils.template(args, inject, self.setup_cache)
args = utils.template(args, inject)
argsfile = self._transfer_str(conn, tmp, 'arguments', args)
if async_jid is None:
@ -283,7 +272,7 @@ class Runner(object):
# *****************************************************
def _execute_raw(self, conn, tmp):
def _execute_raw(self, conn, tmp, inject=None):
''' execute a non-module command for bootstrapping, or if there's no python on a device '''
return ReturnData(host=conn.host, result=dict(
stdout=self._low_level_exec_command(conn, self.module_args, tmp, sudoable = True)
@ -291,7 +280,7 @@ class Runner(object):
# ***************************************************
def _execute_normal_module(self, conn, tmp, module_name):
def _execute_normal_module(self, conn, tmp, module_name, inject=None):
''' transfer & execute a module that is not 'copy' or 'template' '''
# shell and command are the same module
@ -300,14 +289,14 @@ class Runner(object):
self.module_args += " #USE_SHELL"
module = self._transfer_module(conn, tmp, module_name)
exec_rc = self._execute_module(conn, tmp, module, self.module_args)
exec_rc = self._execute_module(conn, tmp, module, self.module_args, inject=inject)
if exec_rc.is_successful():
self._add_result_to_setup_cache(conn, exec_rc.result)
return exec_rc
# *****************************************************
def _execute_async_module(self, conn, tmp, module_name):
def _execute_async_module(self, conn, tmp, module_name, inject=None):
''' transfer the given module name, plus the async module, then run it '''
# shell and command module are the same
@ -322,12 +311,13 @@ class Runner(object):
return self._execute_module(conn, tmp, async, module_args,
async_module=module,
async_jid=self.generated_jid,
async_limit=self.background
async_limit=self.background,
inject=inject
)
# *****************************************************
def _execute_copy(self, conn, tmp):
def _execute_copy(self, conn, tmp, inject=None):
''' handler for file transfer operations '''
# load up options
@ -338,9 +328,6 @@ class Runner(object):
result=dict(failed=True, msg="src and dest are required")
return ReturnData(host=conn.host, result=result)
# apply templating to source argument
inject = self.setup_cache[conn.host]
# if we have first_available_file in our vars
# look up the files and use the first one we find as src
if 'first_available_file' in self.module_vars:
@ -380,20 +367,20 @@ class Runner(object):
# run the copy module
args = "src=%s dest=%s" % (tmp_src, dest)
exec_rc = self._execute_module(conn, tmp, module, args)
exec_rc = self._execute_module(conn, tmp, module, args, inject=inject)
else:
# no need to transfer the file, already correct md5
result = dict(changed=False, md5sum=remote_md5, transferred=False)
exec_rc = ReturnData(host=conn.host, result=result)
if exec_rc.is_successful():
return self._chain_file_module(conn, tmp, exec_rc, options)
return self._chain_file_module(conn, tmp, exec_rc, options, inject=inject)
else:
return exec_rc
# *****************************************************
def _execute_fetch(self, conn, tmp):
def _execute_fetch(self, conn, tmp, inject=None):
''' handler for fetch operations '''
# load up options
@ -405,13 +392,9 @@ class Runner(object):
return ReturnData(host=conn.host, result=results)
# apply templating to source argument
inject = self.setup_cache[conn.host]
if self.module_vars is not None:
inject.update(self.module_vars)
source = utils.template(source, inject, self.setup_cache)
source = utils.template(source, inject)
# apply templating to dest argument
dest = utils.template(dest, inject, self.setup_cache)
dest = utils.template(dest, inject)
# files are saved in dest dir, with a subdir for each host, then the filename
dest = "%s/%s/%s" % (utils.path_dwim(self.basedir, dest), conn.host, source)
@ -444,14 +427,14 @@ class Runner(object):
# *****************************************************
def _chain_file_module(self, conn, tmp, exec_rc, options):
def _chain_file_module(self, conn, tmp, exec_rc, options, inject=None):
''' handles changing file attribs after copy/template operations '''
old_changed = exec_rc.result.get('changed', False)
module = self._transfer_module(conn, tmp, 'file')
args = ' '.join([ "%s=%s" % (k,v) for (k,v) in options.items() ])
exec_rc2 = self._execute_module(conn, tmp, module, args)
exec_rc2 = self._execute_module(conn, tmp, module, args, inject=inject)
new_changed = False
if exec_rc2.is_successful():
@ -465,7 +448,7 @@ class Runner(object):
# *****************************************************
def _execute_template(self, conn, tmp):
def _execute_template(self, conn, tmp, inject=None):
''' handler for template operations '''
if not self.is_playbook:
@ -480,9 +463,6 @@ class Runner(object):
result = dict(failed=True, msg="src and dest are required")
return ReturnData(host=conn.host, comm_ok=False, result=result)
# apply templating to source argument so vars can be used in the path
inject = self.setup_cache[conn.host]
# if we have first_available_file in our vars
# look up the files and use the first one we find as src
if 'first_available_file' in self.module_vars:
@ -500,14 +480,14 @@ class Runner(object):
if self.module_vars is not None:
inject.update(self.module_vars)
source = utils.template(source, inject, self.setup_cache)
source = utils.template(source, inject)
# install the template module
copy_module = self._transfer_module(conn, tmp, 'copy')
# template the source data locally
try:
resultant = utils.template_from_file(self.basedir, source, inject, self.setup_cache)
resultant = utils.template_from_file(self.basedir, source, inject)
except Exception, e:
result = dict(failed=True, msg=str(e))
return ReturnData(host=conn.host, comm_ok=False, result=result)
@ -516,25 +496,25 @@ class Runner(object):
# run the COPY module
args = "src=%s dest=%s" % (xfered, dest)
exec_rc = self._execute_module(conn, tmp, copy_module, args)
exec_rc = self._execute_module(conn, tmp, copy_module, args, inject=inject)
# modify file attribs if needed
if exec_rc.comm_ok:
return self._chain_file_module(conn, tmp, exec_rc, options)
return self._chain_file_module(conn, tmp, exec_rc, options, inject=inject)
else:
return exec_rc
# *****************************************************
def _execute_assemble(self, conn, tmp):
def _execute_assemble(self, conn, tmp, inject=None):
''' handler for assemble operations '''
module_name = 'assemble'
options = utils.parse_kv(self.module_args)
module = self._transfer_module(conn, tmp, module_name)
exec_rc = self._execute_module(conn, tmp, module, self.module_args)
exec_rc = self._execute_module(conn, tmp, module, self.module_args, inject=inject)
if exec_rc.is_successful():
return self._chain_file_module(conn, tmp, exec_rc, options)
return self._chain_file_module(conn, tmp, exec_rc, options, inject=inject)
else:
return exec_rc
@ -608,7 +588,17 @@ class Runner(object):
inject.update(host_variables)
inject.update(self.module_vars)
conditional = utils.template(self.conditional, inject, self.setup_cache)
# special non-user/non-fact variables:
# 'groups' variable is a list of host name in each group
# 'hostvars' variable contains variables for each host name
# ... and is set elsewhere
# 'inventory_hostname' is also set elsewhere
group_hosts = {}
for g in self.inventory.groups:
group_hosts[g.name] = [ h.name for h in g.hosts ]
inject['groups'] = group_hosts
conditional = utils.template(self.conditional, inject)
if not eval(conditional):
result = utils.jsonify(dict(skipped=True))
self.callbacks.on_skipped(host)
@ -621,19 +611,19 @@ class Runner(object):
result = dict(failed=True, msg="FAILED: %s" % str(e))
return ReturnData(host=host, comm_ok=False, result=result)
module_name = utils.template(self.module_name, inject, self.setup_cache)
module_name = utils.template(self.module_name, inject)
tmp = self._make_tmp_path(conn)
result = None
handler = getattr(self, "_execute_%s" % self.module_name, None)
if handler:
result = handler(conn, tmp)
result = handler(conn, tmp, inject=inject)
else:
if self.background == 0:
result = self._execute_normal_module(conn, tmp, module_name)
result = self._execute_normal_module(conn, tmp, module_name, inject=inject)
else:
result = self._execute_async_module(conn, tmp, module_name)
result = self._execute_async_module(conn, tmp, module_name, inject=inject)
self._delete_remote_files(conn, tmp)
conn.close()

18
lib/ansible/utils.py
View file

@ -192,14 +192,17 @@ def varReplace(raw, vars):
return ''.join(done)
def _template(text, vars, setup_cache=None):
def _template(text, vars):
''' run a text buffer through the templating engine '''
if vars is None:
raise Exception('vars is none')
vars = vars.copy()
vars['hostvars'] = setup_cache
# FIXME: do this in runner code
vars['hostvars'] = vars.get('setup_cache', {})
return varReplace(unicode(text), vars)
def template(text, vars, setup_cache=None):
def template(text, vars):
''' run a text buffer through the templating engine until it no longer changes '''
prev_text = ''
@ -209,21 +212,22 @@ def template(text, vars, setup_cache=None):
if (depth > 20):
raise errors.AnsibleError("template recursion depth exceeded")
prev_text = text
text = _template(text, vars, setup_cache)
text = _template(text, vars)
return text
def template_from_file(basedir, path, vars, setup_cache):
def template_from_file(basedir, path, vars):
''' run a file through the templating engine '''
environment = jinja2.Environment(loader=jinja2.FileSystemLoader(basedir), trim_blocks=False)
data = codecs.open(path_dwim(basedir, path), encoding="utf8").read()
t = environment.from_string(data)
# FIXME: possibly a bit inefficient here, do this in runner code
vars = vars.copy()
vars['hostvars'] = setup_cache
vars['hostvars'] = vars.get('setup_cache',{})
res = t.render(vars)
if data.endswith('\n') and not res.endswith('\n'):
res = res + '\n'
return template(res, vars, setup_cache)
return template(res, vars)
def parse_yaml(data):
''' convert a yaml string to a data structure '''