def test_topfile_order(self, Matcher, get_file_client):
opts = {
'renderer': 'yaml',
'state_top': '',
'pillar_roots': [],
'extension_modules': '',
'environment': 'base',
'file_roots': [],
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux'
}
# glob match takes precedence
self._setup_test_topfile_mocks(Matcher, get_file_client, 1, 2)
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion', 'base')
self.assertEqual(pillar.compile_pillar()['ssh'], 'bar')
# nodegroup match takes precedence
self._setup_test_topfile_mocks(Matcher, get_file_client, 2, 1)
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion', 'base')
self.assertEqual(pillar.compile_pillar()['ssh'], 'foo')
def test_pillar_multiple_matches(self, Matcher, get_file_client):
# Uses the ``recurse_list`` strategy.
opts = {
'renderer': 'yaml',
'state_top': '',
'pillar_roots': [],
'extension_modules': '',
'environment': 'base',
'file_roots': [],
'pillar_source_merging_strategy': 'recurse_list',
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux'
}
self._setup_test_topfile_mocks(Matcher, get_file_client, 1, 2)
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion', 'base')
# Pillars should be merged, but only once per pillar file.
self.assertDictEqual(pillar.compile_pillar()['generic'], {
'key1': ['value1', 'value2', 'value3'],
'key2': {
'sub_key1': [],
'sub_key2': [],
}
})
def data(key=None):
'''
Returns the pillar derived from the configured pillar source. The pillar
source is derived from the file_client option in the minion config
CLI Example::
salt '*' pillar.data
With the optional key argument, you can select a subtree of the
pillar data.::
salt '*' pillar.data key='roles'
'''
pillar = salt.pillar.get_pillar(
__opts__,
__grains__,
__opts__['id'],
__opts__['environment'])
ret = pillar.compile_pillar()
if key:
ret = ret.get(key, {})
return ret
def items(*args, **kwargs):
'''
Calls the master for a fresh pillar and generates the pillar data on the
fly
Contrast with :py:func:`raw` which returns the pillar data that is
currently loaded into the minion.
pillar : none
if specified, allows for a dictionary of pillar data to be made
available to pillar and ext_pillar rendering. these pillar variables
will also override any variables of the same name in pillar or
ext_pillar.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' pillar.items
'''
# Preserve backwards compatibility
if args:
return item(*args)
pillar = salt.pillar.get_pillar(
__opts__,
__grains__,
__opts__['id'],
__opts__['environment'],
pillar=kwargs.get('pillar'))
return pillar.compile_pillar()
def items(*args):
'''
Calls the master for a fresh pillar and generates the pillar data on the
fly
Contrast with :py:func:`raw` which returns the pillar data that is
currently loaded into the minion.
CLI Example:
.. code-block:: bash
salt '*' pillar.items
'''
# Preserve backwards compatibility
if args:
return item(*args)
pillar = salt.pillar.get_pillar(
__opts__,
__grains__,
__opts__['id'],
__opts__['environment'])
return pillar.compile_pillar()
def _pillar(self, load):
'''
Return the pillar data for the minion
'''
if any(key not in load for key in ('id', 'grains')):
return False
pillar = salt.pillar.Pillar(
self.opts,
load['grains'],
load['id'],
load.get('saltenv', load.get('env')),
load.get('ext'),
self.mminion.functions)
data = pillar.compile_pillar()
if self.opts.get('minion_data_cache', False):
cdir = os.path.join(self.opts['cachedir'], 'minions', load['id'])
if not os.path.isdir(cdir):
os.makedirs(cdir)
datap = os.path.join(cdir, 'data.p')
with salt.utils.fopen(datap, 'w+') as fp_:
fp_.write(
self.serial.dumps(
{'grains': load['grains'],
'pillar': data})
)
return data
def data(key=''):
'''
Returns the pillar derived from the configured pillar source. The pillar
source is derived from the file_client option in the minion config
CLI Example::
salt '*' pillar.data
With the optional key argument, you can select a subtree of the
pillar data.::
salt '*' pillar.data key='roles'
'''
pillar = salt.pillar.get_pillar(
__opts__,
__grains__,
__opts__['id'],
__opts__['environment'])
compiled_pillar = pillar.compile_pillar()
if key:
try:
ret = compiled_pillar[key]
except KeyError:
ret = {}
else:
ret = compiled_pillar
return ret
def show_pillar(minion='*', **kwargs):
'''
Returns the compiled pillar either of a specific minion
or just the global available pillars. I assume that no minion
is using the id ``*``.
CLI Example:
shows minion specific pillar:
.. code-block:: bash
salt-run pillar.show_pillar 'www.example.com'
shows global pillar:
.. code-block:: bash
salt-run pillar.show_pillar
shows global pillar for 'dev' pillar environment:
.. code-block:: bash
salt-run pillar.show_pillar 'saltenv=dev'
API Example:
.. code-block:: python
import salt.config
import salt.runner
opts = salt.config.master_config('/etc/salt/master')
runner = salt.runner.RunnerClient(opts)
pillar = runner.cmd('pillar.show_pillar', [])
print pillar¬
'''
saltenv = 'base'
id_, grains, _ = salt.utils.minions.get_minion_data(minion, __opts__)
if grains is None:
grains = {'fqdn': minion}
for key in kwargs:
if key == 'saltenv':
saltenv = kwargs[key]
else:
grains[key] = kwargs[key]
pillar = salt.pillar.Pillar(
__opts__,
grains,
id_,
saltenv)
compiled_pillar = pillar.compile_pillar()
salt.output.display_output(compiled_pillar, 'nested', __opts__)
return compiled_pillar
def data():
'''
Returns the pillar derived from the configured pillar source. The pillar
source is derived from the file_client option in the minion config
CLI Example::
salt '*' pillar.data
'''
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__['id'])
return pillar.compile_pillar()
def data():
"""
Returns the pillar derived from the configured pillar source. The pillar
source is derived from the file_client option in the minion config
CLI Example::
salt '*' pillar.data
"""
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__["id"], __opts__["environment"])
return pillar.compile_pillar()
def _pillar(self, load):
'''
Return the pillar data for the minion
'''
if 'id' not in load or 'grains' not in load or 'env' not in load:
return False
pillar = salt.pillar.Pillar(
self.opts,
load['grains'],
load['id'],
load['env'])
return pillar.compile_pillar()
def _get_live_minion_pillar(self, minion_id=None, minion_grains=None):
# Returns a dict of pillar data for one minion
if minion_id is None:
return {}
if not minion_grains:
log.warning(
'Cannot get pillar data for {0}: no grains supplied.'.format(
minion_id))
return {}
log.debug('Getting live pillar for {0}'.format(minion_id))
pillar = salt.pillar.Pillar(self.opts, minion_grains, minion_id,
self.saltenv, self.opts['ext_pillar'])
log.debug('Compiling pillar for {0}'.format(minion_id))
ret = pillar.compile_pillar()
return ret
def ext(external):
"""
Generate the pillar and apply an explicit external pillar
CLI Example::
salt '*' pillar.ext 'libvirt: _'
"""
if isinstance(external, basestring):
external = yaml.load(external)
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__["id"], __opts__["environment"], external)
ret = pillar.compile_pillar()
return ret
def test_include(self, tempdir):
opts = {
'optimization_order': [0, 1, 2],
'renderer': 'yaml',
'renderer_blacklist': [],
'renderer_whitelist': [],
'state_top': '',
'pillar_roots': [],
'extension_modules': '',
'saltenv': 'base',
'file_roots': [],
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux',
}
sls_files = self._setup_test_include_sls(tempdir)
fc_mock = MockFileclient(
cache_file=sls_files['top']['dest'],
get_state=sls_files,
list_states=[
'top',
'test.init',
'test.sub1',
'test.sub2',
'test.sub_wildcard_1',
'test.sub_with_init_dot',
'test.sub.with.slashes',
],
)
with patch.object(salt.fileclient, 'get_file_client',
MagicMock(return_value=fc_mock)):
pillar = salt.pillar.Pillar(opts, grains, 'minion', 'base')
# Make sure that confirm_top.confirm_top returns True
pillar.matchers['confirm_top.confirm_top'] = lambda *x, **y: True
compiled_pillar = pillar.compile_pillar()
self.assertEqual(compiled_pillar['foo_wildcard'], 'bar_wildcard')
self.assertEqual(compiled_pillar['foo1'], 'bar1')
self.assertEqual(compiled_pillar['foo2'], 'bar2')
self.assertEqual(compiled_pillar['sub_with_slashes'],
'sub_slashes_worked')
self.assertEqual(compiled_pillar['sub_init_dot'],
'sub_with_init_dot_worked')
def test_include(self, tempdir):
opts = {
"optimization_order": [0, 1, 2],
"renderer": "yaml",
"renderer_blacklist": [],
"renderer_whitelist": [],
"state_top": "",
"pillar_roots": [],
"extension_modules": "",
"saltenv": "base",
"file_roots": [],
}
grains = {
"os": "Ubuntu",
"os_family": "Debian",
"oscodename": "raring",
"osfullname": "Ubuntu",
"osrelease": "13.04",
"kernel": "Linux",
}
sls_files = self._setup_test_include_sls(tempdir)
fc_mock = MockFileclient(
cache_file=sls_files["top"]["dest"],
get_state=sls_files,
list_states=[
"top",
"test.init",
"test.sub1",
"test.sub2",
"test.sub_wildcard_1",
"test.sub_with_init_dot",
"test.sub.with.slashes",
],
)
with patch.object(salt.fileclient, "get_file_client",
MagicMock(return_value=fc_mock)):
pillar = salt.pillar.Pillar(opts, grains, "minion", "base")
# Make sure that confirm_top.confirm_top returns True
pillar.matchers["confirm_top.confirm_top"] = lambda *x, **y: True
compiled_pillar = pillar.compile_pillar()
self.assertEqual(compiled_pillar["foo_wildcard"], "bar_wildcard")
self.assertEqual(compiled_pillar["foo1"], "bar1")
self.assertEqual(compiled_pillar["foo2"], "bar2")
self.assertEqual(compiled_pillar["sub_with_slashes"],
"sub_slashes_worked")
self.assertEqual(compiled_pillar["sub_init_dot"],
"sub_with_init_dot_worked")
def _get_live_minion_pillar(self, minion_id=None, minion_grains=None):
# Returns a dict of pillar data for one minion
if minion_id == None:
return {}
if not minion_grains:
log.warn('Cannot get pillar data for {0}: no grains supplied.'.format(minion_id))
return {}
log.debug('Getting live pillar for {0}'.format(minion_id))
pillar = salt.pillar.Pillar(
self.opts,
minion_grains,
minion_id,
self.env,
self.opts['ext_pillar'])
log.debug('Compiling pillar for {0}'.format(minion_id))
ret = pillar.compile_pillar()
return ret
def test_ext_pillar_first(self):
'''
test when using ext_pillar and ext_pillar_first
'''
opts = {
'optimization_order': [0, 1, 2],
'renderer': 'yaml',
'renderer_blacklist': [],
'renderer_whitelist': [],
'state_top': '',
'pillar_roots': [],
'extension_modules': '',
'saltenv': 'base',
'file_roots': [],
'ext_pillar_first': True,
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux'
}
tempdir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP)
try:
sls_files = self._setup_test_topfile_sls_pillar_match(tempdir, )
fc_mock = MockFileclient(cache_file=sls_files['top']['dest'],
list_states=[
'top', 'ssh', 'ssh.minion', 'generic',
'generic.minion'
],
get_state=sls_files)
with patch.object(salt.fileclient, 'get_file_client',
MagicMock(return_value=fc_mock)), \
patch('salt.pillar.Pillar.ext_pillar',
MagicMock(return_value=({'id': 'minion',
'phase': 'alpha', 'role':
'database'}, []))):
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion',
'base')
self.assertEqual(pillar.compile_pillar()['generic']['key1'],
'value1')
finally:
shutil.rmtree(tempdir, ignore_errors=True)
def ext(external):
"""
Generate the pillar and apply an explicit external pillar
CLI Example:
.. code-block:: bash
salt '*' pillar.ext '{libvirt: _}'
"""
if isinstance(external, string_types):
external = yaml.safe_load(external)
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__["id"], __opts__["environment"], external)
ret = pillar.compile_pillar()
return ret
def items(*args):
"""
This function calls the master for a fresh pillar and generates the pillar
data on the fly, unlike pillar.raw which returns the pillar data which
is currently loaded into the minion.
CLI Example::
salt '*' pillar.items
"""
# Preserve backwards compatibility
if args:
return item(*args)
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__["id"], __opts__["environment"])
return pillar.compile_pillar()
def ext(external):
'''
Generate the pillar and apply an explicit external pillar
CLI Example:
.. code-block:: bash
salt '*' pillar.ext 'libvirt: _'
'''
if isinstance(external, basestring):
external = yaml.safe_load(external)
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__['id'],
__opts__['environment'], external)
ret = pillar.compile_pillar()
return ret
def items(*args, **kwargs):
'''
Calls the master for a fresh pillar and generates the pillar data on the
fly
Contrast with :py:func:`raw` which returns the pillar data that is
currently loaded into the minion.
pillar
if specified, allows for a dictionary of pillar data to be made
available to pillar and ext_pillar rendering. these pillar variables
will also override any variables of the same name in pillar or
ext_pillar.
.. versionadded:: 2015.5.0
pillarenv
Pass a specific pillar environment from which to compile pillar data.
If not specified, then the minion's :conf_minion:`pillarenv` option is
not used, and if that also is not specified then all configured pillar
environments will be merged into a single pillar dictionary and
returned.
.. versionadded:: 2016.11.2
CLI Example:
.. code-block:: bash
salt '*' pillar.items
'''
# Preserve backwards compatibility
if args:
return item(*args)
pillar = salt.pillar.get_pillar(__opts__,
__grains__,
__opts__['id'],
pillar=kwargs.get('pillar'),
pillarenv=kwargs.get('pillarenv')
or __opts__['pillarenv'])
return pillar.compile_pillar()
def get_pillar(__opts__, minion='*', **kwargs):
saltenv = 'base'
id_, grains, _ = salt.utils.minions.get_minion_data(minion, __opts__)
if grains is None:
grains = {'fqdn': minion}
for key in kwargs:
if key == 'saltenv':
saltenv = kwargs[key]
else:
grains[key] = kwargs[key]
pillar = salt.pillar.Pillar(
__opts__,
grains,
id_,
saltenv)
compiled_pillar = pillar.compile_pillar()
return compiled_pillar
def _run_test(nodegroup_order, glob_order, expected):
tempdir = tempfile.mkdtemp(dir=RUNTIME_VARS.TMP)
try:
sls_files = self._setup_test_topfile_sls(
tempdir,
nodegroup_order,
glob_order)
fc_mock = MockFileclient(
cache_file=sls_files['top']['dest'],
list_states=['top', 'ssh', 'ssh.minion',
'generic', 'generic.minion'],
get_state=sls_files)
with patch.object(salt.fileclient, 'get_file_client',
MagicMock(return_value=fc_mock)):
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion', 'base')
# Make sure that confirm_top.confirm_top returns True
pillar.matchers['confirm_top.confirm_top'] = lambda *x, **y: True
self.assertEqual(pillar.compile_pillar()['ssh'], expected)
finally:
shutil.rmtree(tempdir, ignore_errors=True)
def items(*args):
'''
This function calls the master for a fresh pillar and generates the pillar
data on the fly, unlike pillar.raw which returns the pillar data which
is currently loaded into the minion.
CLI Example:
.. code-block:: bash
salt '*' pillar.items
'''
# Preserve backwards compatibility
if args:
return item(*args)
pillar = salt.pillar.get_pillar(__opts__, __grains__, __opts__['id'],
__opts__['environment'])
return pillar.compile_pillar()
def _pillar(self, load):
'''
Return the pillar data for the minion
'''
if 'id' not in load or 'grains' not in load or 'env' not in load:
return False
pillar = salt.pillar.Pillar(self.opts, load['grains'], load['id'],
load['env'])
data = pillar.compile_pillar()
if self.opts.get('minion_data_cache', False):
cdir = os.path.join(self.opts['cachedir'], 'minions', load['id'])
if not os.path.isdir(cdir):
os.makedirs(cdir)
datap = os.path.join(cdir, 'data.p')
with open(datap, 'w+') as fp_:
fp_.write(
self.serial.dumps({
'grains': load['grains'],
'pillar': data
}))
return data
def ext(external):
'''
Generate the pillar and apply an explicit external pillar
CLI Example:
.. code-block:: bash
salt '*' pillar.ext '{libvirt: _}'
'''
if isinstance(external, basestring):
external = yaml.safe_load(external)
pillar = salt.pillar.get_pillar(
__opts__,
__grains__,
__opts__['id'],
__opts__['environment'],
external)
ret = pillar.compile_pillar()
return ret
def test_pillar_send_extra_minion_data_from_config(self):
opts = {
"renderer": "json",
"pillarenv": "fake_pillar_env",
"path_to_add": "fake_data",
"path_to_add2": {
"fake_data5": "fake_data6",
"fake_data2": ["fake_data3", "fake_data4"],
},
"pass_to_ext_pillars": ["path_to_add"],
}
mock_channel = MagicMock(crypted_transfer_decode_dictentry=MagicMock(
return_value={}))
with patch(
"salt.transport.client.ReqChannel.factory",
MagicMock(return_value=mock_channel),
):
pillar = salt.pillar.RemotePillar(opts, self.grains,
"mocked_minion", "fake_env")
ret = pillar.compile_pillar()
self.assertEqual(pillar.channel, mock_channel)
mock_channel.crypted_transfer_decode_dictentry.assert_called_once_with(
{
"cmd": "_pillar",
"ver": "2",
"id": "mocked_minion",
"grains": {},
"saltenv": "fake_env",
"pillarenv": "fake_pillar_env",
"pillar_override": {},
"extra_minion_data": {
"path_to_add": "fake_data"
},
},
dictkey="pillar",
)
def _pillar(self, load):
'''
Return the pillar data for the minion
'''
if 'id' not in load or 'grains' not in load or 'env' not in load:
return False
pillar = salt.pillar.Pillar(
self.opts,
load['grains'],
load['id'],
load['env'])
data = pillar.compile_pillar()
if self.opts.get('minion_data_cache', False):
cdir = os.path.join(self.opts['cachedir'], 'minions', load['id'])
if not os.path.isdir(cdir):
os.makedirs(cdir)
datap = os.path.join(cdir, 'data.p')
with open(datap, 'w+') as fp_:
fp_.write(
self.serial.dumps(
{'grains': load['grains'],
'pillar': data})
)
return data
def items(*args, **kwargs):
'''
Calls the master for a fresh pillar and generates the pillar data on the
fly
Contrast with :py:func:`raw` which returns the pillar data that is
currently loaded into the minion.
pillar
If specified, allows for a dictionary of pillar data to be made
available to pillar and ext_pillar rendering. these pillar variables
will also override any variables of the same name in pillar or
ext_pillar.
.. versionadded:: 2015.5.0
pillar_enc
If specified, the data passed in the ``pillar`` argument will be passed
through this renderer to decrypt it.
.. note::
This will decrypt on the minion side, so the specified renderer
must be set up on the minion for this to work. Alternatively,
pillar data can be decrypted master-side. For more information, see
the :ref:`Pillar Encryption <pillar-encryption>` documentation.
Pillar data that is decrypted master-side, is not decrypted until
the end of pillar compilation though, so minion-side decryption
will be necessary if the encrypted pillar data must be made
available in an decrypted state pillar/ext_pillar rendering.
.. versionadded:: 2017.7.0
pillarenv
Pass a specific pillar environment from which to compile pillar data.
If not specified, then the minion's :conf_minion:`pillarenv` option is
not used, and if that also is not specified then all configured pillar
environments will be merged into a single pillar dictionary and
returned.
.. versionadded:: 2016.11.2
saltenv
Included only for compatibility with
:conf_minion:`pillarenv_from_saltenv`, and is otherwise ignored.
CLI Example:
.. code-block:: bash
salt '*' pillar.items
'''
# Preserve backwards compatibility
if args:
return item(*args)
pillarenv = kwargs.get('pillarenv')
if pillarenv is None:
if __opts__.get('pillarenv_from_saltenv', False):
pillarenv = kwargs.get('saltenv') or __opts__['environment']
else:
pillarenv = __opts__['pillarenv']
pillar_override = kwargs.get('pillar')
pillar_enc = kwargs.get('pillar_enc')
if pillar_override and pillar_enc:
try:
pillar_override = salt.utils.crypt.decrypt(
pillar_override,
pillar_enc,
translate_newlines=True,
opts=__opts__,
valid_rend=__opts__['decrypt_pillar_renderers'])
except Exception as exc:
raise CommandExecutionError(
'Failed to decrypt pillar override: {0}'.format(exc))
pillar = salt.pillar.get_pillar(__opts__,
__grains__,
__opts__['id'],
pillar=pillar_override,
pillarenv=pillarenv)
return pillar.compile_pillar()
def show_pillar(minion='*', **kwargs):
'''
Returns the compiled pillar either of a specific minion
or just the global available pillars. This function assumes
that no minion has the id ``*``.
Function also accepts pillarenv as attribute in order to limit to a specific pillar branch of git
CLI Example:
shows minion specific pillar:
.. code-block:: bash
salt-run pillar.show_pillar 'www.example.com'
shows global pillar:
.. code-block:: bash
salt-run pillar.show_pillar
shows global pillar for 'dev' pillar environment:
(note that not specifying pillarenv will merge all pillar environments
using the master config option pillar_source_merging_strategy.)
.. code-block:: bash
salt-run pillar.show_pillar 'pillarenv=dev'
shows global pillar for 'dev' pillar environment and specific pillarenv = dev:
.. code-block:: bash
salt-run pillar.show_pillar 'saltenv=dev' 'pillarenv=dev'
API Example:
.. code-block:: python
import salt.config
import salt.runner
opts = salt.config.master_config('/etc/salt/master')
runner = salt.runner.RunnerClient(opts)
pillar = runner.cmd('pillar.show_pillar', [])
print(pillar)
'''
pillarenv = None
saltenv = 'base'
id_, grains, _ = salt.utils.minions.get_minion_data(minion, __opts__)
if grains is None:
grains = {'fqdn': minion}
for key in kwargs:
if key == 'saltenv':
saltenv = kwargs[key]
elif key == 'pillarenv':
# pillarenv overridden on CLI
pillarenv = kwargs[key]
else:
grains[key] = kwargs[key]
pillar = salt.pillar.Pillar(
__opts__,
grains,
id_,
saltenv,
pillarenv=pillarenv)
compiled_pillar = pillar.compile_pillar()
# needed because pillar compilation clobbers grains etc via lazyLoader
# this resets the masterminion back to known state
__salt__['salt.cmd']('sys.reload_modules')
return compiled_pillar
def show_pillar(minion="*", **kwargs):
"""
Returns the compiled pillar either of a specific minion
or just the global available pillars. This function assumes
that no minion has the id ``*``.
Function also accepts pillarenv as attribute in order to limit to a specific pillar branch of git
CLI Example:
shows minion specific pillar:
.. code-block:: bash
salt-run pillar.show_pillar 'www.example.com'
shows global pillar:
.. code-block:: bash
salt-run pillar.show_pillar
shows global pillar for 'dev' pillar environment:
(note that not specifying pillarenv will merge all pillar environments
using the master config option pillar_source_merging_strategy.)
.. code-block:: bash
salt-run pillar.show_pillar 'pillarenv=dev'
shows global pillar for 'dev' pillar environment and specific pillarenv = dev:
.. code-block:: bash
salt-run pillar.show_pillar 'saltenv=dev' 'pillarenv=dev'
API Example:
.. code-block:: python
import salt.config
import salt.runner
opts = salt.config.master_config('/etc/salt/master')
runner = salt.runner.RunnerClient(opts)
pillar = runner.cmd('pillar.show_pillar', [])
print(pillar)
"""
pillarenv = None
saltenv = "base"
id_, grains, _ = salt.utils.minions.get_minion_data(minion, __opts__)
if grains is None:
grains = {"fqdn": minion}
for key in kwargs:
if key == "saltenv":
saltenv = kwargs[key]
elif key == "pillarenv":
# pillarenv overridden on CLI
pillarenv = kwargs[key]
else:
grains[key] = kwargs[key]
pillar = salt.pillar.Pillar(__opts__,
grains,
id_,
saltenv,
pillarenv=pillarenv)
compiled_pillar = pillar.compile_pillar()
return compiled_pillar
def test_referencing_preceding_pillars(self):
'''
Pillars, that come first in the top file can be referenced from
the subsequent pillars.
'''
opts = {
'renderer': 'py',
'renderer_blacklist': [],
'renderer_whitelist': [],
'state_top': '',
'pillar_roots': [],
'file_roots': {},
'extension_modules': ''
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux'
}
pillar = salt.pillar.Pillar(opts, grains, 'mocked-minion', 'base')
top = tempfile.NamedTemporaryFile()
top.write(b'''#!yaml
base:
'*':
- foo
- bar
''')
top.flush()
foo = tempfile.NamedTemporaryFile()
foo.write(b'''#!py
def run():
return {'foo': {'spam': 'eggs'}}
''')
foo.flush()
bar = tempfile.NamedTemporaryFile()
bar.write(b'''#!py
def run():
return {
'bar': {
'bacon': __pillar__.get('foo', {}).get('spam', 'cheddar'),
'sausage': __salt__['pillar.get']('foo:spam', 'cheddar')
}
}
''')
bar.flush()
def get_state(sls, env):
return {
'foo': {
'path': '',
'dest': foo.name
},
'bar': {
'path': '',
'dest': bar.name
}
}[sls]
pillar.client = MagicMock(
**{
'get_state.side_effect': get_state,
'cache_file.return_value': top.name
})
pillar.matcher = MagicMock()
pillar.matcher.confirm_top.return_value = True
actual_pillar_data = pillar.compile_pillar()
expected_pillar_data = {
'foo': {
'spam': 'eggs'
},
'bar': {
'bacon': 'eggs',
'sausage': 'eggs'
}
}
self.assertEqual(actual_pillar_data, expected_pillar_data)
def test_relative_include(self, tempdir):
join = os.path.join
with fopen(join(tempdir, 'top.sls'), 'w') as f:
print(
textwrap.dedent('''
base:
'*':
- includer
- simple_includer
- includes.with.more.depth
'''),
file=f,
)
includer_dir = join(tempdir, 'includer')
os.makedirs(includer_dir)
with fopen(join(includer_dir, 'init.sls'), 'w') as f:
print(
textwrap.dedent('''
include:
- .this
- includer.that
'''),
file=f,
)
with fopen(join(includer_dir, 'this.sls'), 'w') as f:
print(
textwrap.dedent('''
this:
is all good
'''),
file=f,
)
with fopen(join(includer_dir, 'that.sls'), 'w') as f:
print(
textwrap.dedent('''
that:
is also all good
'''),
file=f,
)
with fopen(join(tempdir, 'simple_includer.sls'),
'w') as simpleincluder:
print(
textwrap.dedent('''
include:
- .simple
- super_simple
'''),
file=simpleincluder,
)
with fopen(join(tempdir, 'simple.sls'), 'w') as f:
print(
textwrap.dedent('''
simple:
simon
'''),
file=f,
)
with fopen(join(tempdir, 'super_simple.sls'), 'w') as f:
print(
textwrap.dedent('''
super simple:
a caveman
'''),
file=f,
)
depth_dir = join(tempdir, 'includes', 'with', 'more')
os.makedirs(depth_dir)
with fopen(join(depth_dir, 'depth.sls'), 'w') as f:
print(
textwrap.dedent('''
include:
- .ramble
- includes.with.more.doors
mordor:
has dark depths
'''),
file=f,
)
with fopen(join(depth_dir, 'ramble.sls'), 'w') as f:
print(
textwrap.dedent('''
found:
my precious
'''),
file=f,
)
with fopen(join(depth_dir, 'doors.sls'), 'w') as f:
print(
textwrap.dedent('''
mojo:
bad risin'
'''),
file=f,
)
opts = {
'optimization_order': [0, 1, 2],
'renderer': 'yaml',
'renderer_blacklist': [],
'renderer_whitelist': [],
'state_top': 'top.sls',
'pillar_roots': {
'base': [tempdir]
},
'extension_modules': '',
'saltenv': 'base',
'file_roots': [],
'file_ignore_regex': None,
'file_ignore_glob': None,
}
grains = {
'os': 'Ubuntu',
'os_family': 'Debian',
'oscodename': 'raring',
'osfullname': 'Ubuntu',
'osrelease': '13.04',
'kernel': 'Linux',
}
pillar = salt.pillar.Pillar(opts, grains, 'minion', 'base')
# Make sure that confirm_top.confirm_top returns True
pillar.matchers['confirm_top.confirm_top'] = lambda *x, **y: True
# Act
compiled_pillar = pillar.compile_pillar()
# Assert
self.assertEqual(compiled_pillar['this'], 'is all good')
self.assertEqual(compiled_pillar['that'], 'is also all good')
self.assertEqual(compiled_pillar['simple'], 'simon')
self.assertEqual(compiled_pillar['super simple'], 'a caveman')
self.assertEqual(compiled_pillar['mordor'], 'has dark depths')
self.assertEqual(compiled_pillar['found'], 'my precious')
self.assertEqual(compiled_pillar['mojo'], "bad risin'")
# Enable logging
log = logging.getLogger(__name__)
BASE_DIR = os.getcwd()
# Set salt pillar, grains and opts settings so they can be applied to modules
__opts__ = salt.config.minion_config('/etc/salt/minion')
__opts__['grains'] = salt.loader.grains(__opts__)
pillar = salt.pillar.get_pillar(
__opts__,
__opts__['grains'],
__opts__['id'],
__opts__['environment'],
)
__opts__['pillar'] = pillar.compile_pillar()
__salt__ = salt.loader.minion_mods(__opts__)
__grains__ = __opts__['grains']
__pillar__ = __opts__['pillar']
__context__ = {}
salt.modules.saltutil.__opts__ = __opts__
salt.modules.saltutil.__grains__ = __grains__
salt.modules.saltutil.__pillar__ = __pillar__
salt.modules.saltutil.__salt__ = __salt__
salt.modules.saltutil.__context__ = __context__
from salt.scripts import salt_call
def _bind(form, saltenv=None, umount=False):
'''
def show_pillar(minion='*', **kwargs):
'''
Returns the compiled pillar either of a specific minion
or just the global available pillars. This function assumes
that no minion has the id ``*``.
CLI Example:
shows minion specific pillar:
.. code-block:: bash
salt-run pillar.show_pillar 'www.example.com'
shows global pillar:
.. code-block:: bash
salt-run pillar.show_pillar
shows global pillar for 'dev' pillar environment:
(note that not specifying pillarenv will merge all pillar environments
using the master config option pillar_source_merging_strategy.)
.. code-block:: bash
salt-run pillar.show_pillar 'pillarenv=dev'
API Example:
.. code-block:: python
import salt.config
import salt.runner
opts = salt.config.master_config('/etc/salt/master')
runner = salt.runner.RunnerClient(opts)
pillar = runner.cmd('pillar.show_pillar', [])
print(pillar)
'''
saltenv = 'base'
pillarenv = __opts__['pillarenv'] if 'pillarenv' in __opts__ else None
id_, grains, _ = salt.utils.minions.get_minion_data(minion, __opts__)
if grains is None:
grains = {'fqdn': minion}
for key in kwargs:
if key == 'saltenv':
saltenv = kwargs[key]
elif key == 'pillarenv':
pillarenv = kwargs[key]
else:
grains[key] = kwargs[key]
pillar = salt.pillar.Pillar(
__opts__,
grains,
id_,
saltenv,
pillarenv=pillarenv)
compiled_pillar = pillar.compile_pillar()
return compiled_pillar
