def test_load_minion_config_from_environ_var(self):
original_environ = os.environ.copy()
tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
try:
env_root_dir = os.path.join(tempdir, "foo", "env")
os.makedirs(env_root_dir)
env_fpath = os.path.join(env_root_dir, "config-env")
salt.utils.fopen(env_fpath, "w").write("root_dir: {0}\n" "log_file: {1}\n".format(env_root_dir, env_fpath))
os.environ["SALT_MINION_CONFIG"] = env_fpath
# Should load from env variable, not the default configuration file
config = sconfig.minion_config("/etc/salt/minion")
self.assertEqual(config["log_file"], env_fpath)
os.environ.clear()
os.environ.update(original_environ)
root_dir = os.path.join(tempdir, "foo", "bar")
os.makedirs(root_dir)
fpath = os.path.join(root_dir, "config")
salt.utils.fopen(fpath, "w").write("root_dir: {0}\n" "log_file: {1}\n".format(root_dir, fpath))
# Let's set the environment variable, yet, since the configuration
# file path is not the default one, ie, the user has passed an
# alternative configuration file form the CLI parser, the
# environment variable will be ignored.
os.environ["SALT_MINION_CONFIG"] = env_fpath
config = sconfig.minion_config(fpath)
self.assertEqual(config["log_file"], fpath)
os.environ.clear()
os.environ.update(original_environ)
finally:
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
def test_check_dns_deprecation_warning(self):
helium_version = SaltStackVersion.from_name('Helium')
if salt_version.__version_info__ >= helium_version:
raise AssertionError(
'Failing this test on purpose! Please delete this test case, '
'the \'check_dns\' keyword argument and the deprecation '
'warnings in `salt.config.minion_config` and '
'salt.config.apply_minion_config`'
)
# Let's force the warning to always be thrown
warnings.resetwarnings()
warnings.filterwarnings(
'always', '(.*)check_dns(.*)', DeprecationWarning, 'salt.config'
)
with warnings.catch_warnings(record=True) as w:
sconfig.minion_config(None, None, check_dns=True)
self.assertEqual(
'The functionality behind the \'check_dns\' keyword argument '
'is no longer required, as such, it became unnecessary and is '
'now deprecated. \'check_dns\' will be removed in Salt '
'{0}.'.format(helium_version.formatted_version),
str(w[-1].message)
)
with warnings.catch_warnings(record=True) as w:
sconfig.apply_minion_config(
overrides=None, defaults=None, check_dns=True
)
self.assertEqual(
'The functionality behind the \'check_dns\' keyword argument '
'is no longer required, as such, it became unnecessary and is '
'now deprecated. \'check_dns\' will be removed in Salt '
'{0}.'.format(helium_version.formatted_version),
str(w[-1].message)
)
with warnings.catch_warnings(record=True) as w:
sconfig.minion_config(None, None, check_dns=False)
self.assertEqual(
'The functionality behind the \'check_dns\' keyword argument '
'is no longer required, as such, it became unnecessary and is '
'now deprecated. \'check_dns\' will be removed in Salt '
'{0}.'.format(helium_version.formatted_version),
str(w[-1].message)
)
with warnings.catch_warnings(record=True) as w:
sconfig.apply_minion_config(
overrides=None, defaults=None, check_dns=False
)
self.assertEqual(
'The functionality behind the \'check_dns\' keyword argument '
'is no longer required, as such, it became unnecessary and is '
'now deprecated. \'check_dns\' will be removed in Salt '
'{0}.'.format(helium_version.formatted_version),
str(w[-1].message)
)
def test_check_dns_deprecation_warning(self):
if salt_version.__version_info__ >= (0, 19):
raise AssertionError(
"Failing this test on purpose! Please delete this test case, "
"the 'check_dns' keyword argument and the deprecation "
"warnings in `salt.config.minion_config` and "
"salt.config.apply_minion_config`"
)
# Let's force the warning to always be thrown
warnings.resetwarnings()
warnings.filterwarnings("always", "(.*)check_dns(.*)", DeprecationWarning, "salt.config")
with warnings.catch_warnings(record=True) as w:
sconfig.minion_config(None, None, check_dns=True)
self.assertEqual(
"The functionality behind the 'check_dns' keyword argument "
"is no longer required, as such, it became unnecessary and is "
"now deprecated. 'check_dns' will be removed in salt > "
"0.18.0",
str(w[-1].message),
)
with warnings.catch_warnings(record=True) as w:
sconfig.apply_minion_config(overrides=None, defaults=None, check_dns=True)
self.assertEqual(
"The functionality behind the 'check_dns' keyword argument "
"is no longer required, as such, it became unnecessary and is "
"now deprecated. 'check_dns' will be removed in salt > "
"0.18.0",
str(w[-1].message),
)
with warnings.catch_warnings(record=True) as w:
sconfig.minion_config(None, None, check_dns=False)
self.assertEqual(
"The functionality behind the 'check_dns' keyword argument "
"is no longer required, as such, it became unnecessary and is "
"now deprecated. 'check_dns' will be removed in salt > "
"0.18.0",
str(w[-1].message),
)
with warnings.catch_warnings(record=True) as w:
sconfig.apply_minion_config(overrides=None, defaults=None, check_dns=False)
self.assertEqual(
"The functionality behind the 'check_dns' keyword argument "
"is no longer required, as such, it became unnecessary and is "
"now deprecated. 'check_dns' will be removed in salt > "
"0.18.0",
str(w[-1].message),
)
def returner(ret):
'''
Send the return data to the Salt Master over the encrypted
0MQ bus with custom tag for 3rd party script filtering.
'''
# get opts from minion config file, supports minion.d drop dir!
opts = minion_config(os.path.join(syspaths.CONFIG_DIR, 'minion'))
# TODO: this needs to be customizable!
tag = 'third-party'
# add custom tag to return data for filtering
ret['tag'] = tag
# multi event example, supports a list of event ret objects.
# single event does not currently expand/filter properly on Master side.
package = {
#'id': opts['id'],
'events': [ ret ],
'tag': None,
'pretag': None,
'data': None
}
# opts must contain valid minion ID else it binds to invalid 0MQ socket.
event = salt.utils.event.SaltEvent('minion', **opts)
# Fire event payload with 'fire_master' tag which triggers the
# salt-minion daemon to forward payload to the master event bus!
event.fire_event(package, 'fire_master')
def test_issue_5970_minion_confd_inclusion(self):
try:
tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
minion_config = os.path.join(tempdir, 'minion')
minion_confd = os.path.join(tempdir, 'minion.d')
os.makedirs(minion_confd)
# Let's populate a minion configuration file with some basic
# settings
salt.utils.fopen(minion_config, 'w').write(
'blah: false\n'
'root_dir: {0}\n'
'log_file: {1}\n'.format(tempdir, minion_config)
)
# Now, let's populate an extra configuration file under minion.d
# Notice that above we've set blah as False and bellow as True.
# Since the minion.d files are loaded after the main configuration
# file so overrides can happen, the final value of blah should be
# True.
extra_config = os.path.join(minion_confd, 'extra.conf')
salt.utils.fopen(extra_config, 'w').write(
'blah: true\n'
)
# Let's load the configuration
config = sconfig.minion_config(minion_config)
self.assertEqual(config['log_file'], minion_config)
# As proven by the assertion below, blah is True
self.assertTrue(config['blah'])
finally:
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
def setUp(self):
self.opts = _config = minion_config(None)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
os.makedirs(self.module_dir)
self.lib_count = collections.defaultdict(int) # mapping of path -> count
# bootstrap libs
with open(os.path.join(self.module_dir, '__init__.py'), 'w') as fh:
# No .decode() needed here as deep_init_base is defined as str and
# not bytes.
fh.write(deep_init_base)
fh.flush()
os.fsync(fh.fileno()) # flush to disk
self.lib_paths = {}
dir_path = self.module_dir
for lib_name in self.libs:
dir_path = os.path.join(dir_path, lib_name)
self.lib_paths[lib_name] = dir_path
os.makedirs(dir_path)
self.update_lib(lib_name)
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.utils = utils(self.opts)
self.proxy = proxy(self.opts)
self.minion_mods = minion_mods(self.opts)
self.loader = LazyLoader(dirs,
self.opts,
tag='module',
pack={'__utils__': self.utils,
'__proxy__': self.proxy,
'__salt__': self.minion_mods}
)
def setUp(self):
self.opts = _config = minion_config(None)
self.opts['grains'] = grains(self.opts)
self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
self.opts,
tag='module',
virtual_enable=False)
def setUp(self):
self.opts = _config = minion_config(None)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
os.makedirs(self.module_dir)
self.lib_count = collections.defaultdict(int) # mapping of path -> count
# bootstrap libs
with open(os.path.join(self.module_dir, '__init__.py'), 'w') as fh:
fh.write(deep_init_base)
fh.flush()
os.fsync(fh.fileno()) # flush to disk
self.lib_paths = {}
dir_path = self.module_dir
for lib_name in self.libs:
dir_path = os.path.join(dir_path, lib_name)
self.lib_paths[lib_name] = dir_path
os.makedirs(dir_path)
self.update_lib(lib_name)
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.loader = LazyLoader(dirs,
self.opts,
tag='module')
def setup_config(self):
opts = config.master_config(self.get_config_file_path('master'))
user = opts.get('user', 'root')
opts['_minion_conf_file'] = opts['conf_file']
opts.update(config.minion_config(self.get_config_file_path('minion')))
# Over ride the user from the master config file
opts['user'] = user
if 'syndic_master' not in opts:
self.error(
"The syndic_master needs to be configured in the salt master "
"config, EXITING!"
)
from salt import utils
# Some of the opts need to be changed to match the needed opts
# in the minion class.
opts['master'] = opts['syndic_master']
opts['master_ip'] = utils.dns_check(opts['master'])
opts['master_uri'] = 'tcp://{0}:{1}'.format(
opts['master_ip'], str(opts['master_port'])
)
opts['_master_conf_file'] = opts['conf_file']
opts.pop('conf_file')
return opts
def setUp(self, *args, **kwargs):
super(RendererMixin, self).setUp(*args, **kwargs)
self.root_dir = tempfile.mkdtemp("pyobjects_test_root")
self.config = minion_config(None)
self.config.update({"file_client": "local", "file_roots": {"base": [self.root_dir]}})
def setUp(self):
self.opts = minion_config(None)
self.opts['disable_modules'] = ['pillar']
self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
self.opts,
tag='module')
def _init_env(self):
'''
Initialize some Salt environment.
'''
from salt.config import minion_config
from salt.grains import core as g_core
g_core.__opts__ = minion_config(self.DEFAULT_MINION_CONFIG_PATH)
self.grains_core = g_core
def _minion_opts(cfg='minion'):
if 'conf_file' in __opts__:
default_dir = os.path.dirname(__opts__['conf_file'])
else:
default_dir = salt.syspaths.CONFIG_DIR,
cfg = os.environ.get(
'SALT_MINION_CONFIG', os.path.join(default_dir, cfg))
opts = config.minion_config(cfg)
return opts
def _init_env(self):
"""
Initialize some Salt environment.
"""
from salt.config import minion_config
from salt.grains import core as g_core
g_core.__opts__ = minion_config(self.DEFAULT_MINION_CONFIG_PATH)
self.grains_core = g_core
def render(self, template, opts=None):
_config = minion_config(None)
_config['file_client'] = 'local'
if opts:
_config.update(opts)
_state = salt.state.State(_config)
return compile_template_str(template,
_state.rend,
_state.opts['renderer'])
def _minion_opts(cfg='minion'):
if 'conf_file' in __opts__:
default_dir = os.path.dirname(__opts__['conf_file'])
else:
default_dir = __opts__['config_dir'],
cfg = os.environ.get(
'SALT_MINION_CONFIG', os.path.join(default_dir, cfg))
opts = config.minion_config(cfg)
return opts
def setUp(self):
self.opts = _config = minion_config(None)
self.opts['grains'] = grains(self.opts)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
self.count = 0
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.loader = LazyLoader(dirs, self.opts, tag='module')
def setUp(self):
self.opts = _config = minion_config(None)
self.opts['grains'] = grains(self.opts)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.loader = LazyLoader(dirs,
self.opts,
tag='module')
def render(self, template, opts=None):
_config = minion_config(None)
_config['file_client'] = 'local'
if opts:
_config.update(opts)
_state = salt.state.State(_config)
return compile_template_str(template, _state.rend,
_state.opts['renderer'],
_state.opts['renderer_blacklist'],
_state.opts['renderer_whitelist'])
def test_sha256_is_default_for_minion(self):
fpath = tempfile.mktemp()
try:
salt.utils.fopen(fpath, 'w').write("root_dir: /\n"
"key_logfile: key\n")
config = sconfig.minion_config(fpath)
self.assertEqual(config['hash_type'], 'sha256')
finally:
if os.path.isfile(fpath):
os.unlink(fpath)
def test_load_minion_config_from_environ_var(self):
original_environ = os.environ.copy()
tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
try:
env_root_dir = os.path.join(tempdir, 'foo', 'env')
os.makedirs(env_root_dir)
env_fpath = os.path.join(env_root_dir, 'config-env')
with salt.utils.fopen(env_fpath, 'w') as fp_:
fp_.write(
'root_dir: {0}\n'
'log_file: {1}\n'.format(env_root_dir, env_fpath)
)
os.environ['SALT_MINION_CONFIG'] = env_fpath
# Should load from env variable, not the default configuration file
config = sconfig.minion_config('/etc/salt/minion')
self.assertEqual(config['log_file'], env_fpath)
os.environ.clear()
os.environ.update(original_environ)
root_dir = os.path.join(tempdir, 'foo', 'bar')
os.makedirs(root_dir)
fpath = os.path.join(root_dir, 'config')
with salt.utils.fopen(fpath, 'w') as fp_:
fp_.write(
'root_dir: {0}\n'
'log_file: {1}\n'.format(root_dir, fpath)
)
# Let's set the environment variable, yet, since the configuration
# file path is not the default one, i.e., the user has passed an
# alternative configuration file form the CLI parser, the
# environment variable will be ignored.
os.environ['SALT_MINION_CONFIG'] = env_fpath
config = sconfig.minion_config(fpath)
self.assertEqual(config['log_file'], fpath)
os.environ.clear()
os.environ.update(original_environ)
finally:
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
def test_load_minion_config_from_environ_var(self):
original_environ = os.environ.copy()
tempdir = tempfile.mkdtemp(dir=TMP)
try:
env_root_dir = os.path.join(tempdir, 'foo', 'env')
os.makedirs(env_root_dir)
env_fpath = os.path.join(env_root_dir, 'config-env')
with salt.utils.fopen(env_fpath, 'w') as fp_:
fp_.write(
'root_dir: {0}\n'
'log_file: {1}\n'.format(env_root_dir, env_fpath)
)
os.environ['SALT_MINION_CONFIG'] = env_fpath
# Should load from env variable, not the default configuration file
config = sconfig.minion_config('{0}/minion'.format(CONFIG_DIR))
self.assertEqual(config['log_file'], env_fpath)
os.environ.clear()
os.environ.update(original_environ)
root_dir = os.path.join(tempdir, 'foo', 'bar')
os.makedirs(root_dir)
fpath = os.path.join(root_dir, 'config')
with salt.utils.fopen(fpath, 'w') as fp_:
fp_.write(
'root_dir: {0}\n'
'log_file: {1}\n'.format(root_dir, fpath)
)
# Let's set the environment variable, yet, since the configuration
# file path is not the default one, i.e., the user has passed an
# alternative configuration file form the CLI parser, the
# environment variable will be ignored.
os.environ['SALT_MINION_CONFIG'] = env_fpath
config = sconfig.minion_config(fpath)
self.assertEqual(config['log_file'], fpath)
os.environ.clear()
os.environ.update(original_environ)
finally:
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
def setUp(self):
self.opts = _config = minion_config(None)
self.tmp_dir = tempfile.mkdtemp(dir=tests.integration.TMP)
os.makedirs(self.module_dir)
self.count = 0
self.lib_count = 0
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.loader = LazyLoader(dirs, self.opts, tag='module')
def test_get_opts(self):
'''
test.get_opts
'''
opts = config.minion_config(
self.get_config_file_path('minion')
)
self.assertEqual(
self.run_function('test.get_opts')['cachedir'],
opts['cachedir']
)
def test_get_opts(self):
'''
test.get_opts
'''
opts = config.minion_config(
self.get_config_file_path('minion')
)
self.assertEqual(
self.run_function('test.get_opts')['cachedir'],
opts['cachedir']
)
def setUp(self, *args, **kwargs):
super(RendererMixin, self).setUp(*args, **kwargs)
self.root_dir = tempfile.mkdtemp('pyobjects_test_root')
self.config = minion_config(None)
self.config.update({
'file_client': 'local',
'file_roots': {
'base': [self.root_dir]
}
})
def test_sha256_is_default_for_minion(self):
fpath = tempfile.mktemp()
try:
salt.utils.fopen(fpath, 'w').write(
"root_dir: /\n"
"key_logfile: key\n"
)
config = sconfig.minion_config(fpath)
self.assertEqual(config['hash_type'], 'sha256')
finally:
if os.path.isfile(fpath):
os.unlink(fpath)
def setUp(self):
self.opts = _config = minion_config(None)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
os.makedirs(self.module_dir)
self.count = 0
self.lib_count = 0
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.loader = LazyLoader(dirs,
self.opts,
tag='module')
def render(self, template, opts=None):
_config = minion_config(None)
_config["file_client"] = "local"
if opts:
_config.update(opts)
_state = salt.state.State(_config)
return compile_template_str(
template,
_state.rend,
_state.opts["renderer"],
_state.opts["renderer_blacklist"],
_state.opts["renderer_whitelist"],
)
def setUp(self):
self.opts = _config = minion_config(None)
self.opts['grains'] = grains(self.opts)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.utils = utils(self.opts)
self.proxy = proxy(self.opts)
self.minion_mods = minion_mods(self.opts)
self.loader = LazyLoader(dirs,
self.opts,
tag='module',
pack={'__utils__': self.utils,
'__proxy__': self.proxy,
'__salt__': self.minion_mods})
def setUp(self):
self.opts = minion_config(None)
self.opts['disable_modules'] = ['pillar']
self.opts['grains'] = grains(self.opts)
# Setup the module
self.module_dir = tempfile.mkdtemp(dir=integration.TMP)
self.module_file = os.path.join(self.module_dir,
'{0}.py'.format(self.module_name))
with open(self.module_file, 'w') as fh:
fh.write(loader_template.decode())
fh.flush()
os.fsync(fh.fileno())
# Invoke the loader
self.loader = LazyLoader([self.module_dir], self.opts, tag='module')
def setUp(self):
self.opts = minion_config(None)
self.opts['disable_modules'] = ['pillar']
self.opts['grains'] = grains(self.opts)
# Setup the module
self.module_dir = tempfile.mkdtemp(dir=integration.TMP)
self.module_file = os.path.join(self.module_dir,
'{0}.py'.format(self.module_name))
with open(self.module_file, 'w') as fh:
fh.write(loader_template)
fh.flush()
os.fsync(fh.fileno())
# Invoke the loader
self.loader = LazyLoader([self.module_dir], self.opts, tag='module')
def setup_config(self):
"""Configure file-based logging
This method is called by the base class to modify minion
configuration options. It is used here to configure a
log file from the minion config file.
"""
config_opts = config.minion_config(
self.get_config_file_path(),
cache_minion_id=True,
ignore_config_errors=False,
)
# Make file based logging work
if getattr(self.options, self._logfile_config_setting_name_,
"None") is None:
# Copy the default log file path into the config dict
if self._logfile_config_setting_name_ not in config_opts:
config_opts[
self.
_logfile_config_setting_name_] = self._default_logging_logfile_
# Prepend the root_dir setting to the log file path
config.prepend_root_dir(config_opts,
[self._logfile_config_setting_name_])
# Copy the altered path back to the options or it will revert to the default
setattr(
self.options,
self._logfile_config_setting_name_,
config_opts[self._logfile_config_setting_name_],
)
else:
# Copy the provided log file path into the config dict
if self._logfile_config_setting_name_ not in config_opts:
config_opts[self._logfile_config_setting_name_] = getattr(
self.options,
self._logfile_config_setting_name_,
self._default_logging_logfile_,
)
return config_opts
def setUp(self):
self.opts = _config = minion_config(None)
self.opts['grains'] = grains(self.opts)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
self.count = 0
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.utils = utils(self.opts)
self.proxy = proxy(self.opts)
self.minion_mods = minion_mods(self.opts)
self.loader = LazyLoader(dirs,
self.opts,
tag='module',
pack={'__utils__': self.utils,
'__proxy__': self.proxy,
'__salt__': self.minion_mods})
def setup_config(self):
opts = config.master_config(self.get_config_file_path("master"))
opts["_minion_conf_file"] = opts["conf_file"]
opts.update(config.minion_config(self.get_config_file_path("minion")))
if "syndic_master" not in opts:
self.error("The syndic_master needs to be configured in the salt master " "config, EXITING!")
from salt import utils
# Some of the opts need to be changed to match the needed opts
# in the minion class.
opts["master"] = opts["syndic_master"]
opts["master_ip"] = utils.dns_check(opts["master"])
opts["master_uri"] = "tcp://{0}:{1}".format(opts["master_ip"], str(opts["master_port"]))
opts["_master_conf_file"] = opts["conf_file"]
opts.pop("conf_file")
return opts
def setup_config(self):
opts = config.master_config(self.get_config_file_path('master'))
opts['_minion_conf_file'] = opts['conf_file']
opts.update(config.minion_config(self.get_config_file_path('minion')))
if 'syndic_master' not in opts:
self.error(
"The syndic_master needs to be configured in the salt master "
"config, EXITING!")
from salt import utils
# Some of the opts need to be changed to match the needed opts
# in the minion class.
opts['master'] = opts['syndic_master']
opts['master_ip'] = utils.dns_check(opts['master'])
opts['master_uri'] = 'tcp://{0}:{1}'.format(opts['master_ip'],
str(opts['master_port']))
opts['_master_conf_file'] = opts['conf_file']
opts.pop('conf_file')
return opts
def setUp(self):
self.opts = _config = minion_config(None)
self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
os.makedirs(self.module_dir)
self.lib_count = collections.defaultdict(
int) # mapping of path -> count
# bootstrap libs
with open(os.path.join(self.module_dir, '__init__.py'), 'w') as fh:
# No .decode() needed here as deep_init_base is defined as str and
# not bytes.
fh.write(deep_init_base)
fh.flush()
os.fsync(fh.fileno()) # flush to disk
self.lib_paths = {}
dir_path = self.module_dir
for lib_name in self.libs:
dir_path = os.path.join(dir_path, lib_name)
self.lib_paths[lib_name] = dir_path
os.makedirs(dir_path)
self.update_lib(lib_name)
dirs = _module_dirs(self.opts, 'modules', 'module')
dirs.append(self.tmp_dir)
self.utils = utils(self.opts)
self.proxy = proxy(self.opts)
self.minion_mods = minion_mods(self.opts)
self.loader = LazyLoader(dirs,
self.opts,
tag='module',
pack={
'__utils__': self.utils,
'__proxy__': self.proxy,
'__salt__': self.minion_mods
})
def setup_config(self):
opts = config.master_config(self.get_config_file_path())
user = opts.get('user', 'root')
opts['_minion_conf_file'] = opts['conf_file']
opts.update(config.minion_config(self.get_config_file_path('minion')))
# Override the user from the master config file
opts['user'] = user
# Override the name of the PID file.
opts['pidfile'] = '/var/run/salt-syndic.pid'
if not opts.get('syndic_master', None):
self.error(
'The syndic_master needs to be configured in the salt master '
'config, EXITING!'
)
# Some of the opts need to be changed to match the needed opts
# in the minion class.
opts['master'] = opts.get('syndic_master', opts['master'])
try:
opts['master_ip'] = utils.dns_check(
opts['master'],
ipv6=opts['ipv6']
)
except exceptions.SaltSystemExit as exc:
self.exit(
status=exc.code,
msg='{0}: {1}\n'.format(self.get_prog_name(), exc.message)
)
opts['master_uri'] = 'tcp://{0}:{1}'.format(
opts['master_ip'], str(opts['master_port'])
)
opts['_master_conf_file'] = opts['conf_file']
opts.pop('conf_file')
return opts
def setUp(self):
self.opts = _config = minion_config(None)
self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
self.opts,
tag='module',
whitelist=['test', 'pillar'])
def test_bad_name(self):
self.opts = minion_config(None)
testmod = salt.loader.raw_mod(self.opts, 'module_we_do_not_have', None)
self.assertEqual(testmod, {})
def test_basic(self):
self.opts = minion_config(None)
testmod = salt.loader.raw_mod(self.opts, 'test', None)
for k, v in six.iteritems(testmod):
self.assertEqual(k.split('.')[0], 'test')
def setUp(self):
self.opts = minion_config(None)
self.opts['grains_deep_merge'] = True
self.assertTrue(self.opts['grains_deep_merge'])
self.opts['disable_modules'] = ['pillar']
__grains__ = grains(self.opts)
def setUp(self):
self.opts = minion_config(None)
def test_basic(self):
self.opts = minion_config(None)
testmod = salt.loader.raw_mod(self.opts, 'test', None)
for k, v in six.iteritems(testmod):
self.assertEqual(k.split('.')[0], 'test')
def test_bad_name(self):
self.opts = minion_config(None)
testmod = salt.loader.raw_mod(self.opts, 'module_we_do_not_have', None)
self.assertEqual(testmod, {})
from salt.cli.caller import Caller
from salt.config import minion_config
defaults = {
'module_dirs': '',
'log_level': 'warning',
}
config = minion_config('/etc/salt/minion')
def run_module(name, *args):
opts = defaults.copy()
opts.update(config, fun=name, arg=args)
return Caller(opts).call()
def setUp(self):
self.opts = _config = minion_config(None)
self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
self.opts,
tag='module',
virtual_enable=False)
def _mixin_setup(self):
group = self.output_options_group = optparse.OptionGroup(
self, "Output Options", "Configure your preferred output format"
)
self.add_option_group(group)
group.add_option(
'--raw-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'raw python form, this is suitable for re-reading the '
'output into an executing python script with eval.'.format(
self.get_prog_name()
))
)
group.add_option(
'--yaml-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'yaml.'.format(self.get_prog_name()))
)
group.add_option(
'--json-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'json.'.format(self.get_prog_name()))
)
if self._include_text_out_:
group.add_option(
'--text-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command '
'in the same form the shell would.'.format(
self.get_prog_name()
))
)
outputters = loader.outputters(
config.minion_config(
'/etc/salt/minion', check_dns=False
)
)
group.add_option(
'--out', '--output',
dest='output',
choices=outputters.keys(),
help=(
'Print the output from the \'{0}\' command using the '
'specified outputter. One of {1}.'.format(
self.get_prog_name(),
', '.join([repr(k) for k in outputters])
)
)
)
group.add_option(
'--out-indent', '--output-indent',
dest='output_indent',
default=None,
type=int,
help=('Print the output indented by the provided value in spaces. '
'Negative values disables indentation. Only applicable in '
'outputters that support indentation.')
)
group.add_option(
'--no-color',
default=False,
action='store_true',
help='Disable all colored output'
)
for option in self.output_options_group.option_list:
def process(opt):
default = self.defaults.get(opt.dest)
if getattr(self.options, opt.dest, default) is False:
return
if opt.dest not in ('out', 'output_indent', 'no_color'):
msg = (
'The option {0} is deprecated. Please consider using '
'\'--out {1}\' instead.'.format(
opt.get_opt_string(),
opt.dest.split('_', 1)[0]
)
)
if version.__version_info__ >= (0, 10, 7):
# XXX: CLEAN THIS CODE WHEN 0.10.8 is about to come out
self.error(msg)
elif log.is_console_configured():
logging.getLogger(__name__).warning(msg)
else:
sys.stdout.write('WARNING: {0}\n'.format(msg))
self.selected_output_option = opt.dest
funcname = 'process_{0}'.format(option.dest)
if not hasattr(self, funcname):
setattr(self, funcname, partial(process, option))
def setup_config(self):
return config.minion_config(self.get_config_file_path(),
cache_minion_id=True,
ignore_config_errors=False)
def setUp(self):
self.opts = minion_config(None)
self.opts['disable_modules'] = ['pillar']
self.opts['grains'] = grains(self.opts)
def setup_config(self):
return config.minion_config(self.get_config_file_path('minion'),
check_dns=not self.options.local)
"""
The auto module builds state factories for all of the modules that the Salt
SMinion class reports as being available
TODO: This needs more testing and maybe a rewrite
"""
from nacl.state import StateFactory
from salt.config import minion_config
from salt.loader import states
from salt.minion import SMinion
_config = minion_config(None)
_config['file_client'] = 'local'
_minion = SMinion(_config)
_states = states(_config, _minion.functions)
# build our list of states and functions
_st_funcs = {}
for func in _states:
(mod, func) = func.split(".")
if mod not in _st_funcs:
_st_funcs[mod] = []
_st_funcs[mod].append(func)
# prepare for export
__all__ = []
for mod in _st_funcs:
_st_funcs[mod].sort()
mod_upper = mod.capitalize()
def _mixin_setup(self):
group = self.output_options_group = optparse.OptionGroup(
self, "Output Options", "Configure your preferred output format")
self.add_option_group(group)
group.add_option(
'--raw-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'raw python form, this is suitable for re-reading the '
'output into an executing python script with eval.'.format(
self.get_prog_name())))
group.add_option(
'--yaml-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'yaml.'.format(self.get_prog_name())))
group.add_option(
'--json-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command in '
'json.'.format(self.get_prog_name())))
if self._include_text_out_:
group.add_option(
'--text-out',
default=False,
action='store_true',
help=('DEPRECATED. Print the output from the \'{0}\' command '
'in the same form the shell would.'.format(
self.get_prog_name())))
outputters = loader.outputters(
config.minion_config(None, check_dns=False))
group.add_option(
'--out',
'--output',
dest='output',
choices=outputters.keys(),
help=('Print the output from the \'{0}\' command using the '
'specified outputter. One of {1}.'.format(
self.get_prog_name(),
', '.join([repr(k) for k in outputters]))))
group.add_option(
'--out-indent',
'--output-indent',
dest='output_indent',
default=None,
type=int,
help=('Print the output indented by the provided value in spaces. '
'Negative values disables indentation. Only applicable in '
'outputters that support indentation.'))
group.add_option('--no-color',
default=False,
action='store_true',
help='Disable all colored output')
for option in self.output_options_group.option_list:
def process(opt):
default = self.defaults.get(opt.dest)
if getattr(self.options, opt.dest, default) is False:
return
if opt.dest not in ('out', 'output_indent', 'no_color'):
if version.__version_info__ >= (0, 12):
# XXX: CLEAN THIS CODE WHEN 0.13 is about to come out
self.error('The option {0} was deprecated. Please use '
'\'--out {1}\' instead.'.format(
opt.get_opt_string(),
opt.dest.split('_', 1)[0]))
self.selected_output_option = opt.dest
funcname = 'process_{0}'.format(option.dest)
if not hasattr(self, funcname):
setattr(self, funcname, partial(process, option))
def setup_config(self):
return config.minion_config(self.get_config_file_path('minion'))
def setup_config(self):
return config.minion_config(
self.get_config_file_path('minion'),
check_dns=not self.options.local
)
def setUp(self):
self.opts = _config = minion_config(None)
self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
self.opts,
tag='module',
whitelist=['test', 'pillar'])
def setup_config(self):
return config.minion_config(self.get_config_file_path('minion'))
from salt.cli.caller import Caller
from salt.config import minion_config
defaults = {
'module_dirs': '',
'log_level': 'warning',
}
config = minion_config('/etc/salt/minion')
def run_module(name, *args):
opts = defaults.copy()
opts.update(config, fun=name, arg=args)
return Caller(opts).call()
