/
py.py
153 lines (120 loc) · 4.35 KB
/
py.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# -*- coding: utf-8 -*-
'''
Pure python state renderer
==========================
To use this renderer, the SLS file should contain a function called ``run``
which returns highstate data.
The highstate data is a dictionary containing identifiers as keys, and execution
dictionaries as values. For example the following state declaration in YAML:
.. code-block:: yaml
common_packages:
pkg.installed:
- pkgs:
- curl
- vim
translates to:
.. code-block:: python
{'common_packages': {'pkg.installed': [{'pkgs': ['curl', 'vim']}]}}
In this module, a few objects are defined for you, giving access to Salt's
execution functions, grains, pillar, etc. They are:
- ``__salt__`` - :ref:`Execution functions <all-salt.modules>` (i.e.
``__salt__['test.echo']('foo')``)
- ``__grains__`` - :ref:`Grains <targeting-grains>` (i.e. ``__grains__['os']``)
- ``__pillar__`` - :ref:`Pillar data <pillar>` (i.e. ``__pillar__['foo']``)
- ``__opts__`` - Minion configuration options
- ``__env__`` - The effective salt fileserver environment (i.e. ``base``). Also
referred to as a "saltenv". ``__env__`` should not be modified in a pure
python SLS file. To use a different environment, the environment should be
set when executing the state. This can be done in a couple different ways:
- Using the ``saltenv`` argument on the salt CLI (i.e. ``salt '*' state.sls
foo.bar.baz saltenv=env_name``).
- By adding a ``saltenv`` argument to an individual state within the SLS
file. In other words, adding a line like this to the state's data
structure: ``{'saltenv': 'env_name'}``
- ``__sls__`` - The SLS path of the file. For example, if the root of the base
environment is ``/srv/salt``, and the SLS file is
``/srv/salt/foo/bar/baz.sls``, then ``__sls__`` in that file will be
``foo.bar.baz``.
When writing a reactor SLS file the global context ``data`` (same as context ``{{ data }}``
for states written with Jinja + YAML) is available. The following YAML + Jinja state declaration:
.. code-block:: jinja
{% if data['id'] == 'mysql1' %}
highstate_run:
local.state.apply:
- tgt: mysql1
{% endif %}
translates to:
.. code-block:: python
if data['id'] == 'mysql1':
return {'highstate_run': {'local.state.apply': [{'tgt': 'mysql1'}]}}
Full Example
------------
.. code-block:: python
:linenos:
#!py
def run():
config = {}
if __grains__['os'] == 'Ubuntu':
user = 'ubuntu'
group = 'ubuntu'
home = '/home/{0}'.format(user)
else:
user = 'root'
group = 'root'
home = '/root/'
config['s3cmd'] = {
'pkg': [
'installed',
{'name': 's3cmd'},
],
}
config[home + '/.s3cfg'] = {
'file.managed': [
{'source': 'salt://s3cfg/templates/s3cfg'},
{'template': 'jinja'},
{'user': user},
{'group': group},
{'mode': 600},
{'context': {
'aws_key': __pillar__['AWS_ACCESS_KEY_ID'],
'aws_secret_key': __pillar__['AWS_SECRET_ACCESS_KEY'],
},
},
],
}
return config
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
from salt.exceptions import SaltRenderError
import salt.utils.templates
def render(template, saltenv='base', sls='', tmplpath=None, **kws):
'''
Render the python module's components
:rtype: string
'''
template = tmplpath
if not os.path.isfile(template):
raise SaltRenderError('Template {0} is not a file!'.format(template))
tmp_data = salt.utils.templates.py(
template,
True,
__salt__=__salt__,
salt=__salt__,
__grains__=__grains__,
grains=__grains__,
__opts__=__opts__,
opts=__opts__,
__pillar__=__pillar__,
pillar=__pillar__,
__env__=saltenv,
saltenv=saltenv,
__sls__=sls,
sls=sls,
**kws)
if not tmp_data.get('result', False):
raise SaltRenderError(tmp_data.get('data',
'Unknown render error in py renderer'))
return tmp_data['data']