SaltStack: Execute custom execution module on Master using runner

2020-03-16T08:37:22Z

---

Contents

• Introduction:
• Pre-Requisites
• Preparation
• Execution

---

Introduction:

Execution modules are meant to executed on minions(clients). Therefore only a handful of execution/state modules are visible to salt-master. But sometimes we may need to execute our custom execution module on Master itself (most likely via runner). In order to do this salt-minion must be installed on Salt-Master box. And configure it to accept the commands from salt-master. This will be configured as a normal salt-minion. Nothing special needs to be done. We will create

• A custom execution module that accepts two arguments
• A custom runner module that accepts two arguments

Pre-Requisites

• salt-master installed and configured on a machine. I used fedora-24 VM.
• salt-minion installed and configured to accept command from salt-master.

Preparation

/etc/salt/master file used:

log_level: debug

fileserver_backend:
  - roots

file_roots:
  base:
    - /srv/salt

runner_dirs:
  - /srv/salt/_runners

/etc/salt/minion file used:

master: salt

Note: In /etc/salt/master file, log_level is set to debug. Normally this will be info.

my_module.py will be our execution module

mkdir /srv/salt/_modules
touch /srv/salt/_modules/my_module.py
mkdir /srv/salt/_runners
touch /srv/salt/_runners/my_runner.py

Contents of /srv/salt/_modules/my_module.py are as follows:

#! /usr/bin/env python

# Below virtual name can be any string.
__virtualname__ = 'my_module'

def __virtual__():
    return __virtualname__

def my_module_function(arg1, arg2):
    modified_arg1 = '%s_%s' % (arg1, 'modified')
    modified_arg2 = '%s_%s' % (arg2, 'modified')
    return modified_arg1, modified_arg2

Contents of /srv/salt/_runners/my_runner.py are as follows:

#! /usr/bin/env python
import salt.client
import salt.loader
import salt.config


def my_runner_function(arg1, arg2):
    __opts__ = salt.config.minion_config('/etc/salt/master')
    mods = salt.loader.minion_mods(__opts__)
    ret1, ret2 = mods['my_module.my_module_function'](arg1, arg2)
    return ret1, ret2

Execution

Run following command to sync all modules with all minions:

root@salt-master# salt '*' saltutil.sync_all
fedora2.vagrant.box:
    ----------
    beacons:
    engines:
    grains:
    log_handlers:
    modules:
        - modules.custom_module
        - modules.my_module
    output:
    proxymodules:
    renderers:
    returners:
    sdb:
    states:
    utils:
fedora.vagrant.box:
    ----------
    beacons:
    engines:
    grains:
    log_handlers:
    modules:
        - modules.custom_module
        - modules.my_module
    output:
    proxymodules:
    renderers:
    returners:
    sdb:
    states:
    utils:

Above runner can be called from command line as follows:

root@salt-master# salt-run my_runner.my_runner_function 'a_string' 'b_string'
- a_string_modified
- b_string_modified
[INFO    ] Runner completed: 20170109185717568738

SaltStack: execute state modules on Master and minions from runner

2020-03-16T13:21:12Z

---

Contents

• Introduction:
• Pre-Requisites

---

Introduction:

We will be creating a SaltStack runner module. This runner module will

• call a state module on salt-master itself
• execute a state file (hence state module) on a client machine

Pre-Requisites

• salt-master installed and configured on a machine. I used fedora-24 VM.
• salt-minion installed and configured to accept command from salt-master.

/etc/salt/master file used:

log_level: debug

fileserver_backend:
  - roots

file_roots:
  base:
    - /srv/salt

runner_dirs:
  - /srv/salt/_runners

/etc/salt/minion file used:

master: salt

Note1: In /etc/salt/master file, log_level is set to debug. Normally this will be info.

Note2: we have to explicitly specify runners directory. In case of executions modules and state modules this is not required. we also need to restart salt-master if any entry is added to /etc/salt/master file.

mkdir /srv/salt/_runners
touch /srv/salt/_runners/custom_runner.py

Contents of /srv/salt/_runners/custom_runner.py are as follows:

import salt.client
import salt.loader
import salt.config
import pprint

client = salt.client.LocalClient()

def call_state_mod_on_saltmaster_from_runner():
    __opts__ = salt.config.minion_config('/etc/salt/master')
    __grains__ = salt.loader.grains(__opts__)
    __opts__['grains'] = __grains__
    __utils__ = salt.loader.utils(__opts__)
    __salt__ = salt.loader.minion_mods(__opts__, utils=__utils__)

    # state_mods is not being populated with all the state modules. Perhaps arguments need to be set.
    state_mods = salt.loader.states(__opts__, None, None, None)
    execution_mods = salt.loader.minion_mods(__opts__)

    # print all state modules available in this runner
    #for mod in state_mods.items():
    #    print(mod)

    # print all execution modules available in this runner
    #for mod in execution_mods.items():
    #    print(mod)

    # Note that salt.wait_for_event is a state module that is available. But pkg.installed state module is not available.
    ret = state_mods['salt.wait_for_event'](name='myevent/test', id_list=['fedora'], timeout=10)
    #pprint.pprint(ret)
    return ret

def execute_state_file_on_minion_from_runner():
    #ret = client.cmd('*', 'state.sls', ['first'])

    # Another Variation
    ret = client.cmd('*', 'state.sls', kwarg={'mods': 'first'})
    #pprint.pprint(ret)
    return ret


if __name__ == '__main__':
    #call_state_mod_from_runner()
    execute_state_mod_on_minion_from_runner()

Now we are ready to execute this runner.

Call a state module on salt-master itself via runner.

root@salt-master# salt-run custom_runner.call_state_mod_on_saltmaster_from_runner
changes:
    ----------
comment:
    Timeout value reached.
name:
    myevent/test
result:
    False
[INFO    ] Runner completed: 20170109175501129807

Note: Please note that wait_for_event is a state module available to salt-Master. There are only a handful of state modules available to salt-master. Most of the state modules are for clients. Read comments in custom_runner.py file for more information.

Execute a state file from runner onto minion (client):

root@salt-master# salt-run custom_runner.execute_state_file_on_minion_from_runner
fedora2.vagrant.box:
    ----------
    pkg_|-install tcpdump_|-tcpdump_|-installed:
        ----------
        __id__:
            install tcpdump
        __run_num__:
            0
        changes:
            ----------
        comment:
            Package tcpdump is already installed
        duration:
            355.026
        name:
            tcpdump
        result:
            True
        start_time:
            17:59:58.929729
[INFO    ] Runner completed: 20170109175953282083

Saltstack Custom Execution Module With Arguments

2020-03-16T13:41:26Z

---

Contents

• Introduction:
• Pre-Requisites

---

Introduction:

We will be creating a simple SaltStack execution module. And will see how can this module be called

• from a state file
• from command line

Pre-Requisites

• salt-master installed and configured on a machine. I used fedora-24 VM.
• salt-minion installed and configured to accept command from salt-master.

/etc/salt/master file used:

log_level: debug

fileserver_backend:
  - roots

file_roots:
  base:
    - /srv/salt

/etc/salt/minion file used:

master: salt

Note: In /etc/salt/master file, log_level is set to debug. Normally this will be info.

my_module.py will be our execution module

mkdir /srv/salt/_modules
touch /srv/salt/_modules/my_module.py

Contents of /srv/salt/_modules/my_module.py are as follows:

#! /usr/bin/env python

# Below virtual name can be any string.
__virtualname__ = 'my_module'

def __virtual__():
    return __virtualname__

def my_module_function(arg1, arg2):
    modified_arg1 = '%s_%s' % (arg1, 'modified')
    modified_arg2 = '%s_%s' % (arg2, 'modified')
    return modified_arg1, modified_arg2

Now we are ready to execute this module to our minion (client machine). Run following command to sync modules first to all minions.

root@salt-master# salt '*' saltutil.sync_all
fedora2.vagrant.box:
    ----------
    beacons:
    engines:
    grains:
    log_handlers:
    modules:
        - modules.my_module
    output:
    proxymodules:
    renderers:
    returners:
    sdb:
    states:
    utils:

Now we are ready to execute this module to our minion (client machine). Run following command to sync modules first to all minions.

root@salt-master# salt 'fedora2.vagrant.box' my_module.my_module_function 'a_string' 'b_string2'
fedora2.vagrant.box:
    - a_string_modified
    - b_string2_modified

Now run above execution module using a state file.

root@salt-master# touch /srv/salt/state_file_call_custom_exec_module.sls

Contents of /srv/salt/state_file_call_custom_exec_module.sls are as follows:

run_custom_module:
  module.run:
    - name: my_module.my_module_function
    - arg1: a_string
    - arg2: b_string

Run the following command to execute above state file on client machine:

root@salt-master# salt 'fedora2.vagrant.box' state.sls state_file_call_custom_exec_module
fedora2.vagrant.box:
----------
          ID: run_custom_module
    Function: module.run
        Name: my_module.my_module_function
      Result: True
     Comment: Module function my_module.my_module_function executed
     Started: 16:38:50.250250
    Duration: 1.085 ms
     Changes:
              ----------
              ret:
                  - a_string_modified
                  - b_string_modified

Summary for fedora2.vagrant.box
------------
Succeeded: 1 (changed=1)
Failed:    0
------------
Total states run:     1
Total run time:   1.085 ms