def yamlify_arg(arg):
'''
yaml.safe_load the arg
'''
if not isinstance(arg, six.string_types):
return arg
if arg.strip() == '':
# Because YAML loads empty strings as None, we return the original string
# >>> import yaml
# >>> yaml.load('') is None
# True
# >>> yaml.load(' ') is None
# True
return arg
elif '_' in arg and all([x in '0123456789_' for x in arg.strip()]):
return arg
try:
# Explicit late import to avoid circular import. DO NOT MOVE THIS.
import salt.utils.yamlloader as yamlloader
original_arg = arg
if '#' in arg:
# Only yamlify if it parses into a non-string type, to prevent
# loss of content due to # as comment character
parsed_arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(parsed_arg, six.string_types):
return arg
return parsed_arg
if arg == 'None':
arg = None
else:
arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(arg, dict):
# dicts must be wrapped in curly braces
if (isinstance(original_arg, six.string_types) and
not original_arg.startswith('{')):
return original_arg
else:
return arg
elif arg is None \
or isinstance(arg, (list, float, six.integer_types, six.string_types)):
# yaml.safe_load will load '|' as '', don't let it do that.
if arg == '' and original_arg in ('|',):
return original_arg
# yaml.safe_load will treat '#' as a comment, so a value of '#'
# will become None. Keep this value from being stomped as well.
elif arg is None and original_arg.strip().startswith('#'):
return original_arg
else:
return arg
else:
# we don't support this type
return original_arg
except Exception:
# In case anything goes wrong...
return original_arg
def yamlify_arg(arg):
'''
yaml.safe_load the arg
'''
if not isinstance(arg, six.string_types):
return arg
if arg.strip() == '':
# Because YAML loads empty strings as None, we return the original string
# >>> import yaml
# >>> yaml.load('') is None
# True
# >>> yaml.load(' ') is None
# True
return arg
elif '_' in arg and all([x in '0123456789_' for x in arg.strip()]):
return arg
try:
# Explicit late import to avoid circular import. DO NOT MOVE THIS.
import salt.utils.yamlloader as yamlloader
original_arg = arg
if '#' in arg:
# Only yamlify if it parses into a non-string type, to prevent
# loss of content due to # as comment character
parsed_arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(parsed_arg, six.string_types) or parsed_arg is None:
return arg
return parsed_arg
if arg == 'None':
arg = None
else:
arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(arg, dict):
# dicts must be wrapped in curly braces
if (isinstance(original_arg, six.string_types) and
not original_arg.startswith('{')):
return original_arg
else:
return arg
elif arg is None \
or isinstance(arg, (list, float, six.integer_types, six.string_types)):
# yaml.safe_load will load '|' as '', don't let it do that.
if arg == '' and original_arg in ('|',):
return original_arg
# yaml.safe_load will treat '#' as a comment, so a value of '#'
# will become None. Keep this value from being stomped as well.
elif arg is None and original_arg.strip().startswith('#'):
return original_arg
else:
return arg
else:
# we don't support this type
return original_arg
except Exception:
# In case anything goes wrong...
return original_arg
def render(yaml_data, saltenv='base', 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, string_types):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, exc.problem)
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except ConstructorError as exc:
raise SaltRenderError(exc)
if len(warn_list) > 0:
for item in warn_list:
log.warn(
'{warn} found in salt://{sls} environment={saltenv}'.format(
warn=item.message, sls=sls, saltenv=saltenv
)
)
if not data:
data = {}
else:
if 'config.get' in __salt__:
if __salt__['config.get']('yaml_utf8', False):
data = _yaml_result_unicode_to_utf8(data)
elif __opts__.get('yaml_utf8'):
data = _yaml_result_unicode_to_utf8(data)
log.debug('Results of YAML rendering: \n{0}'.format(data))
return data
def render(yaml_data, saltenv="base", 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, string_types):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, exc.problem)
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except ConstructorError as exc:
raise SaltRenderError(exc)
if len(warn_list) > 0:
for item in warn_list:
log.warn(
"{warn} found in {sls} environment={env}".format(
warn=item.message, sls=salt.utils.url.create(sls), env=saltenv
)
)
if not data:
data = {}
else:
if "config.get" in __salt__:
if __salt__["config.get"]("yaml_utf8", False):
data = _yaml_result_unicode_to_utf8(data)
elif __opts__.get("yaml_utf8"):
data = _yaml_result_unicode_to_utf8(data)
log.debug("Results of YAML rendering: \n{0}".format(data))
return data
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:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, 'Unknown yaml render error')
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except ConstructorError as exc:
raise SaltRenderError(exc)
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
)
)
if not data:
data = {}
log.debug('Results of YAML rendering: \n{0}'.format(data))
return data
def render(yaml_data, saltenv='base', 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, string_types):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, 'Unknown yaml render error')
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except ConstructorError as exc:
raise SaltRenderError(exc)
if len(warn_list) > 0:
for item in warn_list:
log.warn('{warn} found in salt://{sls} environment={saltenv}'.
format(warn=item.message, sls=sls, saltenv=saltenv))
if not data:
data = {}
else:
if isinstance(__salt__, dict):
if 'config.get' in __salt__:
if __salt__['config.get']('yaml_utf8', False):
data = _yaml_result_unicode_to_utf8(data)
elif __opts__.get('yaml_utf8'):
data = _yaml_result_unicode_to_utf8(data)
log.debug('Results of YAML rendering: \n{0}'.format(data))
return data
def yamlify_arg(arg):
"""
yaml.safe_load the arg
"""
if not isinstance(arg, string_types):
return arg
if arg.strip() == "":
# Because YAML loads empty strings as None, we return the original string
# >>> import yaml
# >>> yaml.load('') is None
# True
# >>> yaml.load(' ') is None
# True
return arg
elif "_" in arg and all([x in "0123456789_" for x in arg.strip()]):
return arg
try:
# Explicit late import to avoid circular import. DO NOT MOVE THIS.
import salt.utils.yamlloader as yamlloader
original_arg = arg
if "#" in arg:
# Don't yamlify this argument or the '#' and everything after
# it will be interpreted as a comment.
return arg
if arg == "None":
arg = None
else:
arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(arg, dict):
# dicts must be wrapped in curly braces
if isinstance(original_arg, string_types) and not original_arg.startswith("{"):
return original_arg
else:
return arg
elif arg is None or isinstance(arg, (list, float, integer_types, string_types)):
# yaml.safe_load will load '|' as '', don't let it do that.
if arg == "" and original_arg in ("|",):
return original_arg
# yaml.safe_load will treat '#' as a comment, so a value of '#'
# will become None. Keep this value from being stomped as well.
elif arg is None and original_arg.strip().startswith("#"):
return original_arg
else:
return arg
else:
# we don't support this type
return original_arg
except Exception:
# In case anything goes wrong...
return original_arg
def render(source, _saltenv, _sls, **kwargs):
"""
Processes YAML data in a string or file objects.
:rtype: A Python data structure
"""
if not isinstance(source, str):
source = source.read()
return load(source, Loader=get_yaml_loader(**kwargs))
def render(source, saltenv='base', sls='', argline='', **kwargs):
'''
Processes YAML data in a string or file objects.
:rtype: A Python data structure
'''
if not isinstance(source, string_types):
source = source.read()
return load(source, Loader=get_yaml_loader(**kwargs))
def yamlify_arg(arg):
'''
yaml.safe_load the arg
'''
if not isinstance(arg, string_types):
return arg
if arg.strip() == '':
# Because YAML loads empty strings as None, we return the original string
# >>> import yaml
# >>> yaml.load('') is None
# True
# >>> yaml.load(' ') is None
# True
return arg
try:
# Explicit late import to avoid circular import. DO NOT MOVE THIS.
import salt.utils.yamlloader as yamlloader
original_arg = arg
if '#' in arg:
# Don't yamlify this argument or the '#' and everything after
# it will be interpreted as a comment.
return arg
if arg == 'None':
arg = None
else:
arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(arg, dict):
# dicts must be wrapped in curly braces
if (isinstance(original_arg, string_types)
and not original_arg.startswith('{')):
return original_arg
else:
return arg
elif arg is None \
or isinstance(arg, (list, float, integer_types, string_types)):
# yaml.safe_load will load '|' as '', don't let it do that.
if arg == '' and original_arg in ('|', ):
return original_arg
# yaml.safe_load will treat '#' as a comment, so a value of '#'
# will become None. Keep this value from being stomped as well.
elif arg is None and original_arg.strip().startswith('#'):
return original_arg
else:
return arg
else:
# we don't support this type
return original_arg
except Exception:
# In case anything goes wrong...
return original_arg
def render(yaml_data, saltenv='base', 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, string_types):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, exc.problem)
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except (ParserError, ConstructorError) as exc:
raise SaltRenderError(exc)
if len(warn_list) > 0:
for item in warn_list:
log.warning(
'{warn} found in {sls} saltenv={env}'.format(
warn=item.message, sls=salt.utils.url.create(sls), env=saltenv
)
)
if not data:
data = {}
else:
if 'config.get' in __salt__:
if __salt__['config.get']('yaml_utf8', False):
data = _yaml_result_unicode_to_utf8(data)
elif __opts__.get('yaml_utf8'):
data = _yaml_result_unicode_to_utf8(data)
log.debug('Results of YAML rendering: \n{0}'.format(data))
def _validate_data(data):
'''
PyYAML will for some reason allow improper YAML to be formed into
an unhashable dict (that is, one with a dict as a key). This
function will recursively go through and check the keys to make
sure they're not dicts.
'''
if isinstance(data, dict):
for key, value in six.iteritems(data):
if isinstance(key, dict):
raise SaltRenderError(
'Invalid YAML, possible double curly-brace')
_validate_data(value)
elif isinstance(data, list):
for item in data:
_validate_data(item)
_validate_data(data)
return data
def render(yaml_data, saltenv='base', 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, string_types):
yaml_data = yaml_data.read()
with warnings.catch_warnings(record=True) as warn_list:
try:
data = load(yaml_data, Loader=get_yaml_loader(argline))
except ScannerError as exc:
err_type = _ERROR_MAP.get(exc.problem, exc.problem)
line_num = exc.problem_mark.line + 1
raise SaltRenderError(err_type, line_num, exc.problem_mark.buffer)
except (ParserError, ConstructorError) as exc:
raise SaltRenderError(exc)
if len(warn_list) > 0:
for item in warn_list:
log.warning('{warn} found in {sls} saltenv={env}'.format(
warn=item.message,
sls=salt.utils.url.create(sls),
env=saltenv))
if not data:
data = {}
else:
if 'config.get' in __salt__:
if __salt__['config.get']('yaml_utf8', False):
data = _yaml_result_unicode_to_utf8(data)
elif __opts__.get('yaml_utf8'):
data = _yaml_result_unicode_to_utf8(data)
log.debug('Results of YAML rendering: \n{0}'.format(data))
def _validate_data(data):
'''
PyYAML will for some reason allow improper YAML to be formed into
an unhashable dict (that is, one with a dict as a key). This
function will recursively go through and check the keys to make
sure they're not dicts.
'''
if isinstance(data, dict):
for key, value in six.iteritems(data):
if isinstance(key, dict):
raise SaltRenderError(
'Invalid YAML, possible double curly-brace')
_validate_data(value)
elif isinstance(data, list):
for item in data:
_validate_data(item)
_validate_data(data)
return data
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))
if not data:
data = {}
log.debug("Results of YAML rendering: \n{0}".format(data))
return data
def yamlify_arg(arg):
'''
yaml.safe_load the arg unless it has a newline in it.
'''
if not isinstance(arg, string_types):
return arg
try:
# Explicit late import to avoid circular import. DO NOT MOVE THIS.
import salt.utils.yamlloader as yamlloader
original_arg = arg
if '#' in arg:
# Don't yamlify this argument or the '#' and everything after
# it will be interpreted as a comment.
return arg
if arg == 'None':
arg = None
elif '\n' not in arg:
arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
if isinstance(arg, dict):
# dicts must be wrapped in curly braces
if (isinstance(original_arg, string_types) and
not original_arg.startswith('{')):
return original_arg
else:
return arg
elif arg is None \
or isinstance(arg, (list, float, integer_types, string_types)):
# yaml.safe_load will load '|' as '', don't let it do that.
if arg == '' and original_arg in ('|',):
return original_arg
# yaml.safe_load will treat '#' as a comment, so a value of '#'
# will become None. Keep this value from being stomped as well.
elif arg is None and original_arg.strip().startswith('#'):
return original_arg
else:
return arg
else:
# we don't support this type
return original_arg
except Exception:
# In case anything goes wrong...
return original_arg
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))
if not data:
data = {}
log.debug('Results of YAML rendering: \n{0}'.format(data))
return data
def managed(name, source=None, template='jinja',
user='******', group='nagios', mode='440',
context={},
makedirs=False,
show_diff=True,
backup=False,
dir_mode=755,
contents=None,
defaults=None, **kwargs):
"""
Make sure a monitoring check is present in the system
.. todo:: document this better
"""
ret = {'name': name,
'changes': {},
'result': True,
'comment': ''}
source_hash = ''
# Retrieve the source file from the server
name = "/etc/nagios/nrpe.d/{0}.cfg".format(name)
log.info('Managing %s content from source file %s', name, source)
try:
sfn, source_sum, comment_ = __salt__['file.get_managed'](
name,
template,
source,
source_hash,
user,
group,
mode,
__env__,
context,
defaults,
**kwargs
)
except Exception as exc:
ret['changes'] = {}
return _error(ret, 'Unable to manage file: {0}'.format(exc))
# generate nrpe config from rendered yaml file
log.debug("Parsing yaml file %s from %s", source, sfn)
with open(sfn) as f:
try:
loaded = yamlloader.load(f, Loader=yamlloader.SaltYamlSafeLoader)
except Exception, err:
f.seek(0)
yaml = f.read()
__salt__['file.remove'](sfn)
return _error(ret,
os.linesep.join((
"Content of failed YAML for %s(%s):" % (source,
sfn),
'-' * 8,
str(err),
'-' * 8,
yaml)))
else: