# salt.modules.cmdmod

A module for shelling out

Keep in mind that this module is insecure, in that it can give whomever has access to the master root execution access to all salt minions

`salt.modules.cmdmod.` `exec_code`(lang, code, cwd=None)

  Pass in two strings, the first naming the executable language, aka - python2, python3, ruby, perl, lua, etc. the second string containing the code you wish to execute. The stdout and stderr will be returned

  CLI Example:

      salt '*' cmd.exec_code ruby 'puts "cheese"'

`salt.modules.cmdmod.` `has_exec`(cmd)

  Returns true if the executable is available on the minion, false otherwise

  CLI Example:

      salt '*' cmd.has_exec cat

`salt.modules.cmdmod.` `retcode`(cmd, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), clean_env=False, template=None, umask=None, quiet=False, timeout=None, reset_system_locale=True, saltenv='base', **kwargs)

  Execute a shell command and return the command's return code.

  Note that `env` represents the environment variables for the command, and should be formatted as a dict, or a YAML string which resolves to a dict.

  CLI Example:

      salt '*' cmd.retcode "file /bin/bash"

  The template arg can be set to 'jinja' or another supported template engine to render the command arguments before execution. For example:

      salt '*' cmd.retcode template=jinja "file {{grains.pythonpath[0]}}/python"

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.retcode "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `run`(cmd, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), clean_env=False, template=None, rstrip=True, umask=None, quiet=False, timeout=None, reset_system_locale=True, saltenv='base', **kwargs)

  Execute the passed command and return the output as a string

  Note that `env` represents the environment variables for the command, and should be formatted as a dict, or a YAML string which resolves to a dict.

  CLI Example:

      salt '*' cmd.run "ls -l | awk '/foo/{print \$2}'"

  The template arg can be set to 'jinja' or another supported template engine to render the command arguments before execution. For example:

      salt '*' cmd.run template=jinja "ls -l /tmp/{{grains.id}} | awk '/foo/{print \$2}'"

  Specify an alternate shell with the shell parameter:

      salt '*' cmd.run "Get-ChildItem C:\ " shell='powershell'

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.run "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `run_all`(cmd, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), clean_env=False, template=None, rstrip=True, umask=None, quiet=False, timeout=None, reset_system_locale=True, saltenv='base', **kwargs)

  Execute the passed command and return a dict of return data

  Note that `env` represents the environment variables for the command, and should be formatted as a dict, or a YAML string which resolves to a dict.

  CLI Example:

      salt '*' cmd.run_all "ls -l | awk '/foo/{print \$2}'"

  The template arg can be set to 'jinja' or another supported template engine to render the command arguments before execution. For example:

      salt '*' cmd.run_all template=jinja "ls -l /tmp/{{grains.id}} | awk '/foo/{print \$2}'"

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.run_all "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `run_stderr`(cmd, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), clean_env=False, template=None, rstrip=True, umask=None, quiet=False, timeout=None, reset_system_locale=True, saltenv='base', **kwargs)

  Execute a command and only return the standard error

  Note that `env` represents the environment variables for the command, and should be formatted as a dict, or a YAML string which resolves to a dict.

  CLI Example:

      salt '*' cmd.run_stderr "ls -l | awk '/foo/{print \$2}'"

  The template arg can be set to 'jinja' or another supported template engine to render the command arguments before execution. For example:

      salt '*' cmd.run_stderr template=jinja "ls -l /tmp/{{grains.id}} | awk '/foo/{print \$2}'"

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.run_stderr "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `run_stdout`(cmd, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), clean_env=False, template=None, rstrip=True, umask=None, quiet=False, timeout=None, reset_system_locale=True, saltenv='base', **kwargs)

  Execute a command, and only return the standard out

  Note that `env` represents the environment variables for the command, and should be formatted as a dict, or a YAML string which resolves to a dict.

  CLI Example:

      salt '*' cmd.run_stdout "ls -l | awk '/foo/{print \$2}'"

  The template arg can be set to 'jinja' or another supported template engine to render the command arguments before execution. For example:

      salt '*' cmd.run_stdout template=jinja "ls -l /tmp/{{grains.id}} | awk '/foo/{print \$2}'"

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.run_stdout "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `script`(source, args=None, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), template='jinja', umask=None, timeout=None, reset_system_locale=True, __env__=None, saltenv='base', **kwargs)

  Download a script from a remote location and execute the script locally. The script can be located on the salt master file server or on an HTTP/FTP server.

  The script will be executed directly, so it can be written in any available programming language.

  The script can also be formated as a template, the default is jinja. Arguments for the script can be specified as well.

  CLI Example:

      salt '*' cmd.script salt://scripts/runme.sh
      salt '*' cmd.script salt://scripts/runme.sh 'arg1 arg2 "arg 3"'
      salt '*' cmd.script salt://scripts/windows_task.ps1 args=' -Input c:\tmp\infile.txt' shell='powershell'

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.script salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `script_retcode`(source, cwd=None, stdin=None, runas=None, shell='/bin/bash', python_shell=True, env=(), template='jinja', umask=None, timeout=None, reset_system_locale=True, __env__=None, saltenv='base', **kwargs)

  Download a script from a remote location and execute the script locally. The script can be located on the salt master file server or on an HTTP/FTP server.

  The script will be executed directly, so it can be written in any available programming language.

  The script can also be formated as a template, the default is jinja.

  Only evaluate the script return code and do not block for terminal output

  CLI Example:

      salt '*' cmd.script_retcode salt://scripts/runme.sh

  A string of standard input can be specified for the command to be run using the `stdin` parameter. This can be useful in cases where sensitive information must be read from standard input.:

      salt '*' cmd.script_retcode salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n'

`salt.modules.cmdmod.` `which`(cmd)

  Returns the path of an executable available on the minion, None otherwise

  CLI Example:

      salt '*' cmd.which cat

`salt.modules.cmdmod.` `which_bin`(cmds)

  Returns the first command found in a list of commands

  CLI Example:

      salt '*' cmd.which_bin '[pip2, pip, pip-python]'

Current Salt release: 0.17.1

#### Previous topic

salt.modules.chocolatey

#### Next topic

salt.modules.config

### Quick search

Enter search terms or a module, class or function name.

### Upcoming SaltStack Events

My conferences on Lanyrd