def identical_signature_wrapper(original_function, wrapped_function):
'''
Return a function with identical signature as ``original_function``'s which
will call the ``wrapped_function``.
'''
context = {'__wrapped__': wrapped_function}
function_def = compile(
'def {0}({1}):\n'
' return __wrapped__({2})'.format(
# Keep the original function name
original_function.__name__,
# The function signature including defaults, i.e., 'timeout=1'
inspect.formatargspec(
*inspect.getargspec(original_function)
)[1:-1],
# The function signature without the defaults
inspect.formatargspec(
formatvalue=lambda val: '',
*inspect.getargspec(original_function)
)[1:-1]
),
'<string>',
'exec'
)
six.exec_(function_def, context)
return wraps(original_function)(context[original_function.__name__])
def render(template, saltenv='base', sls='', tmplpath=None, rendered_sls=None, **kws):
mod = imp.new_module(sls)
# Note: mod object is transient. It's existence only lasts as long as
# the lowstate data structure that the highstate in the sls file
# is compiled to.
mod.__name__ = sls
# to workaround state.py's use of copy.deepcopy(chunk)
mod.__deepcopy__ = lambda x: mod
dsl_sls = pydsl.Sls(sls, saltenv, rendered_sls)
mod.__dict__.update(
__pydsl__=dsl_sls,
include=_wrap_sls(dsl_sls.include),
extend=_wrap_sls(dsl_sls.extend),
state=_wrap_sls(dsl_sls.state),
__salt__=__salt__,
__grains__=__grains__,
__opts__=__opts__,
__pillar__=__pillar__,
__env__=saltenv,
__sls__=sls,
__file__=tmplpath,
**kws)
dsl_sls.get_render_stack().append(dsl_sls)
exec_(template.read(), mod.__dict__)
highstate = dsl_sls.to_highstate(mod)
dsl_sls.get_render_stack().pop()
return highstate
def process_template(template):
template_data = []
# Do not pass our globals to the modules we are including and keep the root _globals untouched
template_globals = dict(_globals)
for line in template.readlines():
line = line.rstrip('\r\n')
matched = False
for RE in (IMPORT_RE, FROM_RE):
matches = RE.match(line)
if not matches:
continue
import_file = matches.group(1).strip()
try:
imports = matches.group(2).split(',')
except IndexError:
# if we don't have a third group in the matches object it means
# that we're importing everything
imports = None
state_file = client.cache_file(import_file, saltenv)
if not state_file:
raise ImportError(
'Could not find the file \'{0}\''.format(import_file))
with salt.utils.files.fopen(state_file) as state_fh:
state_contents, state_globals = process_template(state_fh)
six.exec_(state_contents, state_globals)
# if no imports have been specified then we are being imported as: import salt://foo.sls
# so we want to stick all of the locals from our state file into the template globals
# under the name of the module -> i.e. foo.MapClass
if imports is None:
import_name = os.path.splitext(
os.path.basename(state_file))[0]
template_globals[import_name] = PyobjectsModule(
import_name, state_globals)
else:
for name in imports:
name = alias = name.strip()
matches = FROM_AS_RE.match(name)
if matches is not None:
name = matches.group(1).strip()
alias = matches.group(2).strip()
if name not in state_globals:
raise ImportError(
'\'{0}\' was not found in \'{1}\''.format(
name, import_file))
template_globals[alias] = state_globals[name]
matched = True
break
if not matched:
template_data.append(line)
return "\n".join(template_data), template_globals
def __patch_path(self):
import imp
modules = list(self.BUILTIN_MODULES[:])
modules.pop(modules.index('posix'))
modules.append('nt')
code = """'''Salt unittest loaded NT module'''"""
module = imp.new_module('nt')
six.exec_(code, module.__dict__)
sys.modules['nt'] = module
sys.builtin_module_names = modules
platform.system = lambda: "windows"
for module in (ntpath, os, os.path, tempfile):
reload(module)
def __patch_path(self):
import imp
modules = list(self.BUILTIN_MODULES[:])
modules.pop(modules.index('posix'))
modules.append('nt')
code = """'''Salt unittest loaded NT module'''"""
module = imp.new_module('nt')
six.exec_(code, module.__dict__)
sys.modules['nt'] = module
sys.builtin_module_names = modules
platform.system = lambda: "windows"
for module in (ntpath, os, os.path, tempfile):
reload(module)
def identical_signature_wrapper(original_function, wrapped_function):
'''
Return a function with identical signature as ``original_function``'s which
will call the ``wrapped_function``.
'''
context = {'__wrapped__': wrapped_function}
function_def = compile(
'def {0}({1}):\n'
' return __wrapped__({2})'.format(
# Keep the original function name
original_function.__name__,
# The function signature including defaults, i.e., 'timeout=1'
inspect.formatargspec(*inspect.getargspec(original_function))
[1:-1],
# The function signature without the defaults
inspect.formatargspec(formatvalue=lambda val: '',
*inspect.getargspec(original_function))
[1:-1]),
'<string>',
'exec')
six.exec_(function_def, context)
return wraps(original_function)(context[original_function.__name__])
def render(template,
saltenv='base',
sls='',
tmplpath=None,
rendered_sls=None,
**kws):
sls = salt.utils.stringutils.to_str(sls)
mod = types.ModuleType(sls)
# Note: mod object is transient. It's existence only lasts as long as
# the lowstate data structure that the highstate in the sls file
# is compiled to.
# __name__ can't be assigned a unicode
mod.__name__ = str(sls) # future lint: disable=blacklisted-function
# to workaround state.py's use of copy.deepcopy(chunk)
mod.__deepcopy__ = lambda x: mod
dsl_sls = pydsl.Sls(sls, saltenv, rendered_sls)
mod.__dict__.update(__pydsl__=dsl_sls,
include=_wrap_sls(dsl_sls.include),
extend=_wrap_sls(dsl_sls.extend),
state=_wrap_sls(dsl_sls.state),
__salt__=__salt__,
__grains__=__grains__,
__opts__=__opts__,
__pillar__=__pillar__,
__env__=saltenv,
__sls__=sls,
__file__=tmplpath,
**kws)
dsl_sls.get_render_stack().append(dsl_sls)
exec_(template.read(), mod.__dict__)
highstate = dsl_sls.to_highstate(mod)
dsl_sls.get_render_stack().pop()
return highstate
def render(template, saltenv='base', sls='', salt_data=True, **kwargs):
if 'pyobjects_states' not in __context__:
load_states()
# these hold the scope that our sls file will be executed with
_globals = {}
# create our StateFactory objects
mod_globals = {'StateFactory': StateFactory}
for mod in __context__['pyobjects_states']:
mod_locals = {}
mod_camel = ''.join([part.capitalize() for part in mod.split('_')])
valid_funcs = "','".join(__context__['pyobjects_states'][mod])
mod_cmd = "{0} = StateFactory('{1!s}', valid_funcs=['{2}'])".format(
mod_camel, mod, valid_funcs)
exec_(mod_cmd, mod_globals, mod_locals)
_globals[mod_camel] = mod_locals[mod_camel]
# add our include and extend functions
_globals['include'] = Registry.include
_globals['extend'] = Registry.make_extend
# add our map class
Map.__salt__ = __salt__
_globals['Map'] = Map
# add some convenience methods to the global scope as well as the "dunder"
# format of all of the salt objects
try:
_globals.update({
# salt, pillar & grains all provide shortcuts or object interfaces
'salt': SaltObject(__salt__),
'pillar': __salt__['pillar.get'],
'grains': __salt__['grains.get'],
'mine': __salt__['mine.get'],
'config': __salt__['config.get'],
# the "dunder" formats are still available for direct use
'__salt__': __salt__,
'__pillar__': __pillar__,
'__grains__': __grains__
})
except NameError:
pass
# if salt_data is not True then we just return the global scope we've
# built instead of returning salt data from the registry
if not salt_data:
return _globals
# this will be used to fetch any import files
client = get_file_client(__opts__)
# process our sls imports
#
# we allow pyobjects users to use a special form of the import statement
# so that they may bring in objects from other files. while we do this we
# disable the registry since all we're looking for here is python objects,
# not salt state data
template_data = []
Registry.enabled = False
for line in template.readlines():
line = line.rstrip('\r\n')
matched = False
for RE in (IMPORT_RE, FROM_RE):
matches = RE.match(line)
if not matches:
continue
import_file = matches.group(1).strip()
try:
imports = matches.group(2).split(',')
except IndexError:
# if we don't have a third group in the matches object it means
# that we're importing everything
imports = None
state_file = client.cache_file(import_file, saltenv)
if not state_file:
raise ImportError(
"Could not find the file {0!r}".format(import_file))
with salt.utils.fopen(state_file) as f:
state_contents = f.read()
state_locals = {}
exec_(state_contents, _globals, state_locals)
if imports is None:
imports = list(state_locals)
for name in imports:
name = alias = name.strip()
matches = FROM_AS_RE.match(name)
if matches is not None:
name = matches.group(1).strip()
alias = matches.group(2).strip()
if name not in state_locals:
raise ImportError("{0!r} was not found in {1!r}".format(
name, import_file))
_globals[alias] = state_locals[name]
matched = True
break
if not matched:
template_data.append(line)
final_template = "\n".join(template_data)
# re-enable the registry
Registry.enabled = True
# now exec our template using our created scopes
exec_(final_template, _globals)
return Registry.salt_data()
def render(template, saltenv='base', sls='', salt_data=True, **kwargs):
if 'pyobjects_states' not in __context__:
load_states()
# these hold the scope that our sls file will be executed with
_globals = {}
# create our StateFactory objects
mod_globals = {'StateFactory': StateFactory}
for mod in __context__['pyobjects_states']:
mod_locals = {}
mod_camel = ''.join([
part.capitalize()
for part in mod.split('_')
])
valid_funcs = "','".join(
__context__['pyobjects_states'][mod]
)
mod_cmd = "{0} = StateFactory('{1!s}', valid_funcs=['{2}'])".format(
mod_camel,
mod,
valid_funcs
)
exec_(mod_cmd, mod_globals, mod_locals)
_globals[mod_camel] = mod_locals[mod_camel]
# add our include and extend functions
_globals['include'] = Registry.include
_globals['extend'] = Registry.make_extend
# add our map class
Map.__salt__ = __salt__
_globals['Map'] = Map
# add some convenience methods to the global scope as well as the "dunder"
# format of all of the salt objects
try:
_globals.update({
# salt, pillar & grains all provide shortcuts or object interfaces
'salt': SaltObject(__salt__),
'pillar': __salt__['pillar.get'],
'grains': __salt__['grains.get'],
'mine': __salt__['mine.get'],
'config': __salt__['config.get'],
# the "dunder" formats are still available for direct use
'__salt__': __salt__,
'__pillar__': __pillar__,
'__grains__': __grains__
})
except NameError:
pass
# if salt_data is not True then we just return the global scope we've
# built instead of returning salt data from the registry
if not salt_data:
return _globals
# this will be used to fetch any import files
client = get_file_client(__opts__)
# process our sls imports
#
# we allow pyobjects users to use a special form of the import statement
# so that they may bring in objects from other files. while we do this we
# disable the registry since all we're looking for here is python objects,
# not salt state data
template_data = []
Registry.enabled = False
for line in template.readlines():
line = line.rstrip('\r\n')
matched = False
for RE in (IMPORT_RE, FROM_RE):
matches = RE.match(line)
if not matches:
continue
import_file = matches.group(1).strip()
try:
imports = matches.group(2).split(',')
except IndexError:
# if we don't have a third group in the matches object it means
# that we're importing everything
imports = None
state_file = client.cache_file(import_file, saltenv)
if not state_file:
raise ImportError("Could not find the file {0!r}".format(import_file))
with salt.utils.fopen(state_file) as f:
state_contents = f.read()
state_locals = {}
exec_(state_contents, _globals, state_locals)
if imports is None:
imports = list(state_locals)
for name in imports:
name = alias = name.strip()
matches = FROM_AS_RE.match(name)
if matches is not None:
name = matches.group(1).strip()
alias = matches.group(2).strip()
if name not in state_locals:
raise ImportError("{0!r} was not found in {1!r}".format(
name,
import_file
))
_globals[alias] = state_locals[name]
matched = True
break
if not matched:
template_data.append(line)
final_template = "\n".join(template_data)
# re-enable the registry
Registry.enabled = True
# now exec our template using our created scopes
exec_(final_template, _globals)
return Registry.salt_data()
def process_template(template, template_globals):
template_data = []
state_globals = {}
for line in template.readlines():
line = line.rstrip('\r\n')
matched = False
for RE in (IMPORT_RE, FROM_RE):
matches = RE.match(line)
if not matches:
continue
import_file = matches.group(1).strip()
try:
imports = matches.group(2).split(',')
except IndexError:
# if we don't have a third group in the matches object it means
# that we're importing everything
imports = None
state_file = client.cache_file(import_file, saltenv)
if not state_file:
raise ImportError(
'Could not find the file \'{0}\''.format(import_file)
)
state_locals = {}
with salt.utils.fopen(state_file) as state_fh:
state_contents, state_locals = process_template(state_fh, template_globals)
exec_(state_contents, template_globals, state_locals)
# if no imports have been specified then we are being imported as: import salt://foo.sls
# so we want to stick all of the locals from our state file into the template globals
# under the name of the module -> i.e. foo.MapClass
if imports is None:
import_name = os.path.splitext(os.path.basename(state_file))[0]
state_globals[import_name] = PyobjectsModule(import_name, state_locals)
else:
for name in imports:
name = alias = name.strip()
matches = FROM_AS_RE.match(name)
if matches is not None:
name = matches.group(1).strip()
alias = matches.group(2).strip()
if name not in state_locals:
raise ImportError(
'\'{0}\' was not found in \'{1}\''.format(
name,
import_file
)
)
state_globals[alias] = state_locals[name]
matched = True
break
if not matched:
template_data.append(line)
return "\n".join(template_data), state_globals
def render(template, saltenv="base", sls="", salt_data=True, **kwargs):
if "pyobjects_states" not in __context__:
load_states()
# these hold the scope that our sls file will be executed with
_globals = {}
# create our StateFactory objects
mod_globals = {"StateFactory": StateFactory}
for mod in __context__["pyobjects_states"]:
mod_locals = {}
mod_camel = "".join([part.capitalize() for part in mod.split("_")])
valid_funcs = "','".join(__context__["pyobjects_states"][mod])
mod_cmd = "{0} = StateFactory('{1!s}', valid_funcs=['{2}'])".format(
mod_camel, mod, valid_funcs)
six.exec_(mod_cmd, mod_globals, mod_locals)
_globals[mod_camel] = mod_locals[mod_camel]
# add our include and extend functions
_globals["include"] = Registry.include
_globals["extend"] = Registry.make_extend
# add our map class
Map.__salt__ = __salt__
_globals["Map"] = Map
# add some convenience methods to the global scope as well as the "dunder"
# format of all of the salt objects
try:
_globals.update({
# salt, pillar & grains all provide shortcuts or object interfaces
"salt": SaltObject(__salt__),
"pillar": __salt__["pillar.get"],
"grains": __salt__["grains.get"],
"mine": __salt__["mine.get"],
"config": __salt__["config.get"],
# the "dunder" formats are still available for direct use
"__salt__": __salt__,
"__pillar__": __pillar__,
"__grains__": __grains__,
})
except NameError:
pass
# if salt_data is not True then we just return the global scope we've
# built instead of returning salt data from the registry
if not salt_data:
return _globals
# this will be used to fetch any import files
client = get_file_client(__opts__)
# process our sls imports
#
# we allow pyobjects users to use a special form of the import statement
# so that they may bring in objects from other files. while we do this we
# disable the registry since all we're looking for here is python objects,
# not salt state data
Registry.enabled = False
def process_template(template):
template_data = []
# Do not pass our globals to the modules we are including and keep the root _globals untouched
template_globals = dict(_globals)
for line in template.readlines():
line = line.rstrip("\r\n")
matched = False
for RE in (IMPORT_RE, FROM_RE):
matches = RE.match(line)
if not matches:
continue
import_file = matches.group(1).strip()
try:
imports = matches.group(2).split(",")
except IndexError:
# if we don't have a third group in the matches object it means
# that we're importing everything
imports = None
state_file = client.cache_file(import_file, saltenv)
if not state_file:
raise ImportError(
"Could not find the file '{0}'".format(import_file))
with salt.utils.files.fopen(state_file) as state_fh:
state_contents, state_globals = process_template(state_fh)
six.exec_(state_contents, state_globals)
# if no imports have been specified then we are being imported as: import salt://foo.sls
# so we want to stick all of the locals from our state file into the template globals
# under the name of the module -> i.e. foo.MapClass
if imports is None:
import_name = os.path.splitext(
os.path.basename(state_file))[0]
template_globals[import_name] = PyobjectsModule(
import_name, state_globals)
else:
for name in imports:
name = alias = name.strip()
matches = FROM_AS_RE.match(name)
if matches is not None:
name = matches.group(1).strip()
alias = matches.group(2).strip()
if name not in state_globals:
raise ImportError(
"'{0}' was not found in '{1}'".format(
name, import_file))
template_globals[alias] = state_globals[name]
matched = True
break
if not matched:
template_data.append(line)
return "\n".join(template_data), template_globals
# process the template that triggered the render
final_template, final_globals = process_template(template)
_globals.update(final_globals)
# re-enable the registry
Registry.enabled = True
# now exec our template using our created scopes
six.exec_(final_template, _globals)
return Registry.salt_data()