With module.run these states allow individual execution module calls to be
made via states. To call a single module function use a module.run
state:
mine.send:
module.run:
- network.interfaces
Note that this example is probably unnecessary to use in practice, since the
mine_functions
and mine_interval
config parameters can be used to
schedule updates for the mine (see here for more info).
It is sometimes desirable to trigger a function call after a state is executed,
for this the module.wait
state can be used:
fetch_out_of_band:
module.run:
- git.fetch:
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
Another example:
mine.send:
module.run:
- network.ip_addrs:
- interface: eth0
And more complex example:
eventsviewer:
module.run:
- task.create_task:
- name: events-viewer
- user_name: System
- action_type: Execute
- cmd: 'c:\netops\scripts\events_viewer.bat'
- trigger_type: 'Daily'
- start_date: '2017-1-20'
- start_time: '11:59PM'
Please note, this is a new behaviour of module.run function.
With the previous module.run there are several differences:
The need of name keyword
The need of m_ prefix
No way to call more than one function at once
For example:
mine.send:
module.wait:
- name: network.interfaces
- watch:
- file: /etc/network/interfaces
All arguments that the module
state does not consume are passed through to
the execution module function being executed:
fetch_out_of_band:
module.run:
- name: git.fetch
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
Due to how the state system works, if a module function accepts an
argument called, name
, then m_name
must be used to specify that
argument, to avoid a collision with the name
argument.
Here is a list of keywords hidden by the state system, which must be prefixed
with m_
:
fun
name
names
state
saltenv
For example:
disable_nfs:
module.run:
- name: service.disable
- m_name: nfs
Note that some modules read all or some of the arguments from a list of keyword arguments. For example:
mine.send:
module.run:
- func: network.ip_addrs
- kwargs:
interface: eth0
cloud.create:
module.run:
- func: cloud.create
- provider: test-provider
- m_names:
- test-vlad
- kwargs: {
ssh_username: 'ubuntu',
image: 'ami-8d6d9daa',
securitygroup: 'default',
size: 'c3.large',
location: 'ap-northeast-1',
delvol_on_destroy: 'True'
}
Another example that creates a recurring task that runs a batch file on a Windows system:
eventsviewer:
module.run:
- name: task.create_task
- m_name: 'events-viewer'
- user_name: System
- kwargs: {
action_type: 'Execute',
cmd: 'c:\netops\scripts\events_viewer.bat',
trigger_type: 'Daily',
start_date: '2017-1-20',
start_time: '11:59PM'
}
Another option is to use the new version of module.run. With which you can call one (or more!) functions at once the following way:
call_something:
module.run:
- git.fetch:
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
By default this behaviour is not turned on. In order to do so, please add the following configuration to the minion:
use_superseded:
- module.run
salt.states.module.
run
(**kwargs)¶Run a single module function or a range of module functions in a batch.
Supersedes module.run
function, which requires m_
prefix to
function-specific parameters.
returner -- Specify a common returner for the whole batch to send the return data
kwargs -- Pass any arguments needed to execute the function(s)
some_id_of_state:
module.run:
- network.ip_addrs:
- interface: eth0
- cloud.create:
- names:
- test-isbm-1
- test-isbm-2
- ssh_username: sles
- image: sles12sp2
- securitygroup: default
- size: 'c3.large'
- location: ap-northeast-1
- delvol_on_destroy: True
salt.states.module.
wait
(name, **kwargs)¶Run a single module function only if the watch statement calls it
name
The module function to execute
**kwargs
Pass any arguments needed to execute the function
Note
Like the cmd.run
state, this state will
return True
but not actually execute, unless one of the following
two things happens:
The state has a watch requisite, and the state which it is watching changes.
Another state has a watch_in requisite which references this state, and the state
wth the watch_in
changes.