def render(template_file, env='', sls=''):
'''
Render the data passing the functions and grains into the rendering system
'''
if not os.path.isfile(template_file):
return {}
tmp_data = salt.utils.templates.wempy(
template_file,
True,
salt=__salt__,
grains=__grains__,
opts=__opts__,
pillar=__pillar__,
env=env,
sls=sls)
if not tmp_data.get('result', False):
raise SaltRenderError(tmp_data.get('data',
'Unknown render error in yaml_wempy renderer'))
yaml_data = tmp_data['data']
with warnings.catch_warnings(record=True) as warn_list:
data = load(yaml_data, Loader=CustomLoader)
if len(warn_list) > 0:
for item in warn_list:
log.warn("{warn} found in {file_}".format(
warn=item.message, file_=template_file))
return data
def __load_compose_definitions(path, definition):
'''
Will load the compose file located at path
Then determines the format/contents of the sent definition
err or results are only set if there were any
:param path:
:param definition:
:return tuple(compose_result, loaded_definition, err):
'''
compose_result, err = __load_docker_compose(path)
if err:
return None, None, err
if isinstance(definition, dict):
return compose_result, definition, None
elif definition.strip().startswith('{'):
try:
loaded_definition = json.deserialize(definition)
except json.DeserializationError as jerr:
msg = 'Could not parse {0} {1}'.format(definition, jerr)
return None, None, __standardize_result(False, msg,
None, None)
else:
try:
loaded_definition = yaml.load(definition)
except yaml.YAMLError as yerr:
msg = 'Could not parse {0} {1}'.format(definition, yerr)
return None, None, __standardize_result(False, msg,
None, None)
return compose_result, loaded_definition, None
def render(template_file, env='', sls=''):
'''
Render the data passing the functions and grains into the rendering system
'''
if not os.path.isfile(template_file):
return {}
tmp_data = salt.utils.templates.jinja(template_file,
True,
salt=__salt__,
grains=__grains__,
opts=__opts__,
pillar=__pillar__,
env=env,
sls=sls)
if not tmp_data.get('result', False):
raise SaltRenderError(
tmp_data.get('data',
'Unknown render error in yaml_jinja renderer'))
yaml_data = tmp_data['data']
with warnings.catch_warnings(record=True) as warn_list:
data = load(yaml_data, Loader=CustomLoader)
if len(warn_list) > 0:
for item in warn_list:
log.warn("{warn} found in {file_}".format(warn=item.message,
file_=template_file))
return data
def render(template, env='', sls=''):
'''
Render the data passing the functions and grains into the rendering system
'''
if not os.path.isfile(template):
return {}
passthrough = {}
passthrough['salt'] = __salt__
passthrough['grains'] = __grains__
passthrough['pillar'] = __pillar__
passthrough['env'] = env
passthrough['sls'] = sls
template = Template(open(template, 'r').read())
yaml_data = template.render(**passthrough)
yaml_data = template.render(**passthrough)
with warnings.catch_warnings(record=True) as warn_list:
data = load(yaml_data, Loader=CustomLoader)
if len(warn_list) > 0:
for item in warn_list:
log.warn("{warn} found in {file_}".format(
warn=item.message, file_=template_file))
return data
def __load_docker_compose(path):
'''
Read the compose file and load its' contents
:param path:
:return:
'''
file_path = __get_docker_file_path(path)
if file_path is None:
msg = 'Could not find docker-compose file at {0}'.format(path)
return None, __standardize_result(False, msg, None, None)
if not os.path.isfile(file_path):
return None, __standardize_result(
False, 'Path {} is not present'.format(file_path), None, None)
try:
with salt.utils.files.fopen(file_path, 'r') as fl:
loaded = yaml.load(fl)
except EnvironmentError:
return None, __standardize_result(
False, 'Could not read {0}'.format(file_path), None, None)
except yaml.YAMLError as yerr:
msg = 'Could not parse {0} {1}'.format(file_path, yerr)
return None, __standardize_result(False, msg, None, None)
if not loaded:
msg = 'Got empty compose file at {0}'.format(file_path)
return None, __standardize_result(False, msg, None, None)
if 'services' not in loaded:
loaded['services'] = {}
result = {
'compose_content': loaded,
'file_name': os.path.basename(file_path)
}
return result, None
def _run_pepper_cli(*args, **kwargs):
sys.argv = ['pepper', '-p',
kwargs.pop('profile', 'main')] + def_args + list(args)
exitcode = pepper.script.Pepper()()
try:
with open(output_file, 'r') as result:
try:
return yaml.load(result)
except yaml.parser.ParserError:
result.seek(0)
return [
yaml.load('{0}}}'.format(ret).strip('"'))
for ret in result.read().split('}"\n') if ret
]
except Exception as exc:
log.error('ExitCode %s: %s', exitcode, exc)
return exitcode
def render(yaml_data, env="", sls="", argline="", **kws):
"""
Accepts YAML as a string or as a file object and runs it through the YAML
parser.
:rtype: A Python data structure
"""
if not isinstance(yaml_data, basestring):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
data = load(yaml_data, Loader=get_yaml_loader(argline))
if len(warn_list) > 0:
for item in warn_list:
log.warn("{warn} found in salt://{sls} environment={env}".format(warn=item.message, sls=sls, env=env))
return data if data else {}
def render(yaml_data, env='', sls='', argline='', **kws):
'''
Accepts YAML as a string or as a file object and runs it through the YAML
parser.
:rtype: A Python data structure
'''
if not isinstance(yaml_data, basestring):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
data = load(yaml_data, Loader=get_yaml_loader(argline))
if len(warn_list) > 0:
for item in warn_list:
log.warn(
'{warn} found in salt://{sls} environment={env}'.format(
warn=item.message, sls=sls, env=env))
return data if data else {}
def __load_docker_compose(path):
"""
Read the compose file and load its' contents
:param path:
:return:
"""
file_path = __get_docker_file_path(path)
if file_path is None:
msg = "Could not find docker-compose file at {}".format(path)
return None, __standardize_result(False, msg, None, None)
if not os.path.isfile(file_path):
return (
None,
__standardize_result(False,
"Path {} is not present".format(file_path),
None, None),
)
try:
with salt.utils.files.fopen(file_path, "r") as fl:
loaded = yaml.load(fl)
except OSError:
return (
None,
__standardize_result(False, "Could not read {}".format(file_path),
None, None),
)
except yaml.YAMLError as yerr:
msg = "Could not parse {} {}".format(file_path, yerr)
return None, __standardize_result(False, msg, None, None)
if not loaded:
msg = "Got empty compose file at {}".format(file_path)
return None, __standardize_result(False, msg, None, None)
if "services" not in loaded:
loaded["services"] = {}
result = {
"compose_content": loaded,
"file_name": os.path.basename(file_path)
}
return result, None
def test_local_poll_timeout(pepper_cli, session_minion_id):
'''Test the returns poller for localclient'''
ret = pepper_cli('--run-uri', '--timeout=5', '--fail-if-incomplete', '*',
'test.sleep', '10')
assert yaml.load(ret) == {'Failed': [session_minion_id]}
