Execution of Salt modules from within states

With these states allow individual execution module calls to be made via states. To call a single module function use a state:

    - 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:

    - git.fetch:
      - cwd: /path/to/my/repo
      - user: myuser
      - opts: '--all'

Another example:

    - network.ip_addrs:
      - interface: eth0

And more complex example:

    - 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 function.

With the previous 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:

    - 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:

    - 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:

    - 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:

    - func: network.ip_addrs
    - kwargs:
        interface: eth0
    - 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:

    - 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 With which you can call one (or more!) functions at once the following way:

    - 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:


Run a single module function or a range of module functions in a batch. Supersedes 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)

    - 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


The module function to execute


Pass any arguments needed to execute the function


Like the state, this state will return True but not actually execute, unless one of the following two things happens:

  1. The state has a watch requisite, and the state which it is watching changes.

  2. Another state has a watch_in requisite which references this state, and the state wth the watch_in changes.