Инструменты пользователя

Инструменты сайта


salt

saltstack

salt '*' sys.doc
acl.delfacl:
 
    Remove specific FACL from the specified file(s)
 
    CLI Examples:
 
        salt '*' acl.delfacl user myuser /tmp/house/kitchen
        salt '*' acl.delfacl default:group mygroup /tmp/house/kitchen
        salt '*' acl.delfacl d:u myuser /tmp/house/kitchen
        salt '*' acl.delfacl g myuser /tmp/house/kitchen /tmp/house/livingroom
        salt '*' acl.delfacl user myuser /tmp/house/kitchen recursive=True
 
 
acl.getfacl:
 
    Return (extremely verbose) map of FACLs on specified file(s)
 
    CLI Examples:
 
        salt '*' acl.getfacl /tmp/house/kitchen
        salt '*' acl.getfacl /tmp/house/kitchen /tmp/house/livingroom
        salt '*' acl.getfacl /tmp/house/kitchen /tmp/house/livingroom recursive=True
 
 
acl.modfacl:
 
    Add or modify a FACL for the specified file(s)
 
    CLI Examples:
 
        salt '*' acl.modfacl user myuser rwx /tmp/house/kitchen
        salt '*' acl.modfacl default:group mygroup rx /tmp/house/kitchen
        salt '*' acl.modfacl d:u myuser 7 /tmp/house/kitchen
        salt '*' acl.modfacl g mygroup 0 /tmp/house/kitchen /tmp/house/livingroom
        salt '*' acl.modfacl user myuser rwx /tmp/house/kitchen recursive=True
 
 
acl.version:
 
    Return facl version from getfacl --version
 
    CLI Example:
 
        salt '*' acl.version
 
 
acl.wipefacls:
 
    Remove all FACLs from the specified file(s)
 
    CLI Examples:
 
        salt '*' acl.wipefacls /tmp/house/kitchen
        salt '*' acl.wipefacls /tmp/house/kitchen /tmp/house/livingroom
        salt '*' acl.wipefacls /tmp/house/kitchen /tmp/house/livingroom recursive=True
 
 
aliases.get_target:
 
    Return the target associated with an alias
 
    CLI Example:
 
        salt '*' aliases.get_target alias
 
 
aliases.has_target:
 
    Return true if the alias/target is set
 
    CLI Example:
 
        salt '*' aliases.has_target alias target
 
 
aliases.list_aliases:
 
    Return the aliases found in the aliases file in this format::
 
        {'alias': 'target'}
 
    CLI Example:
 
        salt '*' aliases.list_aliases
 
 
aliases.rm_alias:
 
    Remove an entry from the aliases file
 
    CLI Example:
 
        salt '*' aliases.rm_alias alias
 
 
aliases.set_target:
 
    Set the entry in the aliases file for the given alias, this will overwrite
    any previous entry for the given alias or create a new one if it does not
    exist.
 
    CLI Example:
 
        salt '*' aliases.set_target alias target
 
 
alternatives.auto:
 
    Trigger alternatives to set the path for <name> as
    specified by priority.
 
    CLI Example:
 
        salt '*' alternatives.auto name
 
 
alternatives.check_exists:
 
    Check if the given path is an alternative for a name.
 
    New in version 2015.8.4
 
    CLI Example:
 
        salt '*' alternatives.check_exists name path
 
 
alternatives.check_installed:
 
    Check if the current highest-priority match for a given alternatives link
    is set to the desired path
 
    CLI Example:
 
        salt '*' alternatives.check_installed name path
 
 
alternatives.display:
 
    Display alternatives settings for defined command name
 
    CLI Example:
 
        salt '*' alternatives.display editor
 
 
alternatives.install:
 
    Install symbolic links determining default commands
 
    CLI Example:
 
        salt '*' alternatives.install editor /usr/bin/editor /usr/bin/emacs23 50
 
 
alternatives.remove:
 
    Remove symbolic links determining the default commands.
 
    CLI Example:
 
        salt '*' alternatives.remove name path
 
 
alternatives.set:
 
    Manually set the alternative <path> for <name>.
 
    CLI Example:
 
        salt '*' alternatives.set name path
 
 
alternatives.show_current:
 
    Display the current highest-priority alternative for a given alternatives
    link
 
    CLI Example:
 
        salt '*' alternatives.show_current editor
 
 
archive.cmd_unzip:
 
    New in version 2015.5.0
        In versions 2014.7.x and earlier, this function was known as
        ``archive.unzip``.
 
    Uses the ``unzip`` command to unpack zip files. This command is part of the
    `Info-ZIP`_ suite of tools, and is typically packaged as simply ``unzip``.
 
    .. _`Info-ZIP`: http://www.info-zip.org/
 
    zip_file
        Path of zip file to be unpacked
 
    dest
        The destination directory into which the file should be unpacked
 
    excludes : None
        Comma-separated list of files not to unpack. Can also be passed in a
        Python list.
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.cmd_unzip template=jinja /tmp/zipfile.zip /tmp/{{grains.id}}/ excludes=file_1,file_2
 
    options : None
        Additional command-line options to pass to the ``unzip`` binary.
 
        Changed in version 2015.8.0
 
            The mandatory `-` prefixing has been removed.  An options string
            beginning with a `--long-option`, would have uncharacteristically
            needed its first `-` removed under the former scheme.
 
    runas : None
        Unpack the zip file as the specified user. Defaults to the user under
        which the minion is running.
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' archive.cmd_unzip /tmp/zipfile.zip /home/strongbad/ excludes=file_1,file_2
 
 
archive.cmd_zip:
 
    New in version 2015.5.0
        In versions 2014.7.x and earlier, this function was known as
        ``archive.zip``.
 
    Uses the ``zip`` command to create zip files. This command is part of the
    `Info-ZIP`_ suite of tools, and is typically packaged as simply ``zip``.
 
    .. _`Info-ZIP`: http://www.info-zip.org/
 
    zip_file
        Path of zip file to be created
 
    sources
        Comma-separated list of sources to include in the zip file. Sources can
        also be passed in a Python list.
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.cmd_zip template=jinja /tmp/zipfile.zip /tmp/sourcefile1,/tmp/{{grains.id}}.txt
 
    cwd : None
        Use this argument along with relative paths in ``sources`` to create
        zip files which do not contain the leading directories. If not
        specified, the zip file will be created as if the cwd was ``/``, and
        creating a zip file of ``/foo/bar/baz.txt`` will contain the parent
        directories ``foo`` and ``bar``. To create a zip file containing just
        ``baz.txt``, the following command would be used:
 
            salt '*' archive.cmd_zip /tmp/baz.zip baz.txt cwd=/foo/bar
 
        New in version 2014.7.1
 
    runas : None
        Create the zip file as the specified user. Defaults to the user under
        which the minion is running.
 
        New in version 2015.5.0
 
 
    CLI Example:
 
        salt '*' archive.cmd_zip /tmp/zipfile.zip /tmp/sourcefile1,/tmp/sourcefile2
 
 
archive.gunzip:
 
    Uses the gunzip command to unpack gzip files
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.gunzip template=jinja /tmp/{{grains.id}}.txt.gz
 
    CLI Example:
 
        # Create /tmp/sourcefile.txt
        salt '*' archive.gunzip /tmp/sourcefile.txt.gz
 
 
archive.gzip:
 
    Uses the gzip command to create gzip files
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.gzip template=jinja /tmp/{{grains.id}}.txt
 
    CLI Example:
 
        # Create /tmp/sourcefile.txt.gz
        salt '*' archive.gzip /tmp/sourcefile.txt
 
 
archive.rar:
 
    Uses `rar for Linux`_ to create rar files
 
    .. _`rar for Linux`: http://www.rarlab.com/
 
    rarfile
        Path of rar file to be created
 
    sources
        Comma-separated list of sources to include in the rar file. Sources can
        also be passed in a Python list.
 
    cwd : None
        Run the rar command from the specified directory. Use this argument
        along with relative file paths to create rar files which do not
        contain the leading directories. If not specified, this will default
        to the home directory of the user under which the salt minion process
        is running.
 
        New in version 2014.7.1
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.rar template=jinja /tmp/rarfile.rar '/tmp/sourcefile1,/tmp/{{grains.id}}.txt'
 
    CLI Example:
 
        salt '*' archive.rar /tmp/rarfile.rar /tmp/sourcefile1,/tmp/sourcefile2
 
 
archive.tar:
 
    Note:
 
        This function has changed for version 0.17.0. In prior versions, the
        ``cwd`` and ``template`` arguments must be specified, with the source
        directories/files coming as a space-separated list at the end of the
        command. Beginning with 0.17.0, ``sources`` must be a comma-separated
        list, and the ``cwd`` and ``template`` arguments are optional.
 
    Uses the tar command to pack, unpack, etc. tar files
 
 
    options
        Options to pass to the tar command
 
        Changed in version 2015.8.0
 
            The mandatory `-` prefixing has been removed.  An options string
            beginning with a `--long-option`, would have uncharacteristically
            needed its first `-` removed under the former scheme.
 
            Also, tar will parse its options differently if short options are
            used with or without a preceding `-`, so it is better to not
            confuse the user into thinking they're using the non-`-` format,
            when really they are using the with-`-` format.
 
    tarfile
        The filename of the tar archive to pack/unpack
 
    sources
        Comma delimited list of files to **pack** into the tarfile. Can also be
        passed as a Python list.
 
    dest
        The destination directory into which to **unpack** the tarfile
 
    cwd : None
        The directory in which the tar command should be executed. If not
        specified, will default to the home directory of the user under which
        the salt minion process is running.
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.tar -cjvf /tmp/salt.tar.bz2 {{grains.saltpath}} template=jinja
 
    CLI Examples:
 
        # Create a tarfile
        salt '*' archive.tar -cjvf /tmp/tarfile.tar.bz2 /tmp/file_1,/tmp/file_2
        # Unpack a tarfile
        salt '*' archive.tar xf foo.tar dest=/target/directory
 
 
archive.unrar:
 
    Uses `rar for Linux`_ to unpack rar files
 
    .. _`rar for Linux`: http://www.rarlab.com/
 
    rarfile
        Name of rar file to be unpacked
 
    dest
        The destination directory into which to **unpack** the rar file
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.unrar template=jinja /tmp/rarfile.rar /tmp/{{grains.id}}/ excludes=file_1,file_2
 
    CLI Example:
 
        salt '*' archive.unrar /tmp/rarfile.rar /home/strongbad/ excludes=file_1,file_2
 
 
 
archive.unzip:
 
    New in version 2015.5.0
        In versions 2014.7.x and earlier, this function was known as
        ``archive.unzip``.
 
    Uses the ``unzip`` command to unpack zip files. This command is part of the
    `Info-ZIP`_ suite of tools, and is typically packaged as simply ``unzip``.
 
    .. _`Info-ZIP`: http://www.info-zip.org/
 
    zip_file
        Path of zip file to be unpacked
 
    dest
        The destination directory into which the file should be unpacked
 
    excludes : None
        Comma-separated list of files not to unpack. Can also be passed in a
        Python list.
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.cmd_unzip template=jinja /tmp/zipfile.zip /tmp/{{grains.id}}/ excludes=file_1,file_2
 
    options : None
        Additional command-line options to pass to the ``unzip`` binary.
 
        Changed in version 2015.8.0
 
            The mandatory `-` prefixing has been removed.  An options string
            beginning with a `--long-option`, would have uncharacteristically
            needed its first `-` removed under the former scheme.
 
    runas : None
        Unpack the zip file as the specified user. Defaults to the user under
        which the minion is running.
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' archive.cmd_unzip /tmp/zipfile.zip /home/strongbad/ excludes=file_1,file_2
 
 
archive.zip:
 
    New in version 2015.5.0
        In versions 2014.7.x and earlier, this function was known as
        ``archive.zip``.
 
    Uses the ``zip`` command to create zip files. This command is part of the
    `Info-ZIP`_ suite of tools, and is typically packaged as simply ``zip``.
 
    .. _`Info-ZIP`: http://www.info-zip.org/
 
    zip_file
        Path of zip file to be created
 
    sources
        Comma-separated list of sources to include in the zip file. Sources can
        also be passed in a Python list.
 
    template : None
        Can be set to 'jinja' or another supported template engine to render
        the command arguments before execution:
 
            salt '*' archive.cmd_zip template=jinja /tmp/zipfile.zip /tmp/sourcefile1,/tmp/{{grains.id}}.txt
 
    cwd : None
        Use this argument along with relative paths in ``sources`` to create
        zip files which do not contain the leading directories. If not
        specified, the zip file will be created as if the cwd was ``/``, and
        creating a zip file of ``/foo/bar/baz.txt`` will contain the parent
        directories ``foo`` and ``bar``. To create a zip file containing just
        ``baz.txt``, the following command would be used:
 
            salt '*' archive.cmd_zip /tmp/baz.zip baz.txt cwd=/foo/bar
 
        New in version 2014.7.1
 
    runas : None
        Create the zip file as the specified user. Defaults to the user under
        which the minion is running.
 
        New in version 2015.5.0
 
 
    CLI Example:
 
        salt '*' archive.cmd_zip /tmp/zipfile.zip /tmp/sourcefile1,/tmp/sourcefile2
 
 
artifactory.get_latest_snapshot:
 
       Gets latest snapshot of the given artifact
 
       artifactory_url
           URL of artifactory instance
       repository
           Snapshot repository in artifactory to retrieve artifact from, for example: libs-snapshots
       group_id
           Group Id of the artifact
       artifact_id
           Artifact Id of the artifact
       packaging
           Packaging type (jar,war,ear,etc)
       target_dir
           Target directory to download artifact to (default: /tmp)
       target_file
           Target file to download artifact to (by default it is target_dir/artifact_id-snapshot_version.packaging)
       classifier
           Artifact classifier name (ex: sources,javadoc,etc). Optional parameter.
       username
           Artifactory username. Optional parameter.
       password
           Artifactory password. Optional parameter.
 
 
artifactory.get_release:
 
       Gets the specified release of the artifact
 
       artifactory_url
           URL of artifactory instance
       repository
           Release repository in artifactory to retrieve artifact from, for example: libs-releases
       group_id
           Group Id of the artifact
       artifact_id
           Artifact Id of the artifact
       packaging
           Packaging type (jar,war,ear,etc)
       version
           Version of the artifact
       target_dir
           Target directory to download artifact to (default: /tmp)
       target_file
           Target file to download artifact to (by default it is target_dir/artifact_id-version.packaging)
       classifier
           Artifact classifier name (ex: sources,javadoc,etc). Optional parameter.
       username
           Artifactory username. Optional parameter.
       password
           Artifactory password. Optional parameter.
 
 
artifactory.get_snapshot:
 
       Gets snapshot of the desired version of the artifact
 
       artifactory_url
           URL of artifactory instance
       repository
           Snapshot repository in artifactory to retrieve artifact from, for example: libs-snapshots
       group_id
           Group Id of the artifact
       artifact_id
           Artifact Id of the artifact
       packaging
           Packaging type (jar,war,ear,etc)
       version
           Version of the artifact
       target_dir
           Target directory to download artifact to (default: /tmp)
       target_file
           Target file to download artifact to (by default it is target_dir/artifact_id-snapshot_version.packaging)
       classifier
           Artifact classifier name (ex: sources,javadoc,etc). Optional parameter.
       username
           Artifactory username. Optional parameter.
       password
           Artifactory password. Optional parameter.
 
 
beacons.add:
 
    Add a beacon on the minion
 
    :param name:            Name of the beacon to configure
    :param beacon_data:     Dictionary or list containing configuration for beacon.
    :return:                Boolean and status message on success or failure of add.
 
    CLI Example:
 
        salt '*' beacons.add ps "{'salt-master': 'stopped', 'apache2': 'stopped'}"
 
 
 
beacons.delete:
 
    Delete a beacon item
 
    :param name:            Name of the beacon to delete
    :return:                Boolean and status message on success or failure of delete.
 
    CLI Example:
 
        salt '*' beacons.delete ps
 
        salt '*' beacons.delete load
 
 
 
beacons.disable:
 
    Disable all beaconsd jobs on the minion
 
    :return:                Boolean and status message on success or failure of disable.
 
    CLI Example:
 
        salt '*' beacons.disable
 
 
beacons.disable_beacon:
 
    Disable beacon on the minion
 
    :name:                  Name of the beacon to disable.
    :return:                Boolean and status message on success or failure of disable.
 
    CLI Example:
 
        salt '*' beacons.disable_beacon ps
 
 
beacons.enable:
 
    Enable all beacons on the minion
 
    :return:                Boolean and status message on success or failure of enable.
 
    CLI Example:
 
        salt '*' beacons.enable
 
 
beacons.enable_beacon:
 
    Enable beacon on the minion
 
    :name:                  Name of the beacon to enable.
    :return:                Boolean and status message on success or failure of enable.
 
    CLI Example:
 
        salt '*' beacons.enable_beacon ps
 
 
beacons.list:
 
    List the beacons currently configured on the minion
 
    :param return_yaml:     Whether to return YAML formatted output, default True
    :return:                List of currently configured Beacons.
 
    CLI Example:
 
        salt '*' beacons.list
 
 
 
beacons.modify:
 
    Modify an existing beacon
 
    :param name:            Name of the beacon to configure
    :param beacon_data:     Dictionary or list containing updated configuration for beacon.
    :return:                Boolean and status message on success or failure of modify.
 
    CLI Example:
 
        salt '*' beacon.modify ps "{'salt-master': 'stopped', 'apache2': 'stopped'}"
 
 
beacons.save:
 
    Save all beacons on the minion
 
    :return:                Boolean and status message on success or failure of save.
 
    CLI Example:
 
        salt '*' beacons.save
 
 
bigip.add_pool_member:
 
    A function to connect to a bigip device and add a new member to an existing pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to modify
    member
        The name of the member to add
        i.e. 10.1.1.2:80
 
    CLI Example:
 
        salt '*' bigip.add_pool_members bigip admin admin my-pool 10.2.2.1:80
 
 
bigip.commit_transaction:
 
    A function to connect to a bigip device and commit an existing transaction.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    label
        the label of this transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.commit_transaction bigip admin admin my_transaction
 
 
bigip.create_monitor:
 
    A function to connect to a bigip device and create a monitor.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    monitor_type
        The type of monitor to create
    name
        The name of the monitor to create
    kwargs
        Consult F5 BIGIP user guide for specific options for each monitor type.
        Typically, tmsh arg names are used.
 
    CLI Example::
 
        salt '*' bigip.create_monitor bigip admin admin http my-http-monitor timeout=10 interval=5
 
 
bigip.create_node:
 
    A function to connect to a bigip device and create a node.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the node
    address
        The address of the node
    trans_label
        The label of the transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.create_node bigip admin admin 10.1.1.2
 
 
bigip.create_pool:
 
    A function to connect to a bigip device and create a pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to create.
    members
        List of comma delimited pool members to add to the pool.
        i.e. 10.1.1.1:80,10.1.1.2:80,10.1.1.3:80
    allow_nat
        [yes | no]
    allow_snat
        [yes | no]
    description
        [string]
    gateway_failsafe_device
        [string]
    ignore_persisted_weight
        [enabled | disabled]
    ip_tos_to_client
        [pass-through | [integer]]
    ip_tos_to_server
        [pass-through | [integer]]
    link_qos_to_client
        [pass-through | [integer]]
    link_qos_to_server
        [pass-through | [integer]]
    load_balancing_mode
        [dynamic-ratio-member | dynamic-ratio-node |
        fastest-app-response | fastest-node |
        least-connections-members |
        least-connections-node |
        least-sessions |
        observed-member | observed-node |
        predictive-member | predictive-node |
        ratio-least-connections-member |
        ratio-least-connections-node |
        ratio-member | ratio-node | ratio-session |
        round-robin | weighted-least-connections-member |
        weighted-least-connections-node]
    min_active_members
        [integer]
    min_up_members
        [integer]
    min_up_members_action
        [failover | reboot | restart-all]
    min_up_members_checking
        [enabled | disabled]
    monitor
        [name]
    profiles
        [none | profile_name]
    queue_depth_limit
        [integer]
    queue_on_connection_limit
        [enabled | disabled]
    queue_time_limit
        [integer]
    reselect_tries
        [integer]
    service_down_action
        [drop | none | reselect | reset]
    slow_ramp_time
        [integer]
 
    CLI Example::
 
        salt '*' bigip.create_pool bigip admin admin my-pool 10.1.1.1:80,10.1.1.2:80,10.1.1.3:80 monitor=http
 
 
bigip.create_profile:
 
    A function to connect to a bigip device and create a profile.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    profile_type
        The type of profile to create
    name
        The name of the profile to create
    kwargs
        ``[ arg=val ] ... [arg=key1:val1,key2:val2] ...``
 
        Consult F5 BIGIP user guide for specific options for each monitor type.
        Typically, tmsh arg names are used.
 
    Creating Complex Args
        Profiles can get pretty complicated in terms of the amount of possible
        config options. Use the following shorthand to create complex arguments such
        as lists, dictionaries, and lists of dictionaries. An option is also
        provided to pass raw json as well.
 
        lists ``[i,i,i]``:
            ``param='item1,item2,item3'``
 
        Dictionary ``[k:v,k:v,k,v]``:
            ``param='key-1:val-1,key-2:val2,key-3:va-3'``
 
        List of Dictionaries ``[k:v,k:v|k:v,k:v|k:v,k:v]``:
           ``param='key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2'``
 
        JSON: ``'j{ ... }j'``:
           ``cert-key-chain='j{ "default": { "cert": "default.crt", "chain": "default.crt", "key": "default.key" } }j'``
 
        Escaping Delimiters:
            Use ``\,`` or ``\:`` or ``\|`` to escape characters which shouldn't
            be treated as delimiters i.e. ``ciphers='DEFAULT\:!SSLv3'``
 
    CLI Examples::
 
        salt '*' bigip.create_profile bigip admin admin http my-http-profile defaultsFrom='/Common/http'
        salt '*' bigip.create_profile bigip admin admin http my-http-profile defaultsFrom='/Common/http' \
            enforcement=maxHeaderCount:3200,maxRequests:10
 
 
 
bigip.create_virtual:
 
    A function to connect to a bigip device and create a virtual server.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the virtual to create
    destination
        [ [virtual_address_name:port] | [ipv4:port] | [ipv6.port] ]
    pool
        [ [pool_name] | none]
    address_status
        [yes | no]
    auto_lasthop
        [default | enabled | disabled ]
    bwc_policy
        [none] | string]
    cmp_enabled
        [yes | no]
    dhcp_relay
        [yes | no]
    connection_limit
        [integer]
    description
        [string]
    state
        [disabled | enabled]
    fallback_persistence
        [none | [profile name] ]
    flow_eviction_policy
        [none | [eviction policy name] ]
    gtm_score
        [integer]
    ip_forward
        [yes | no]
    ip_protocol
        [any | protocol]
    internal
        [yes | no]
    twelve_forward
        (12-forward)
        [yes | no]
    last_hop-pool
        [ [pool_name] | none]
    mask
        { [ipv4] | [ipv6] }
    mirror
        { [disabled | enabled | none] }
    nat64
        [enabled | disabled]
    persist
        [none | profile1,profile2,profile3 ... ]
    profiles
        [none | default | profile1,profile2,profile3 ... ]
    policies
        [none | default | policy1,policy2,policy3 ... ]
    rate_class
        [name]
    rate_limit
        [integer]
    rate_limit_mode
        [destination | object | object-destination |
        object-source | object-source-destination |
        source | source-destination]
    rate_limit_dst
        [integer]
    rate_limitçsrc
        [integer]
    rules
        [none | [rule_one,rule_two ...] ]
    related_rules
        [none | [rule_one,rule_two ...] ]
    reject
        [yes | no]
    source
        { [ipv4[/prefixlen]] | [ipv6[/prefixlen]] }
    source_address_translation
        [none | snat:pool_name | lsn | automap ]
    source_port
        [change | preserve | preserve-strict]
    state
        [enabled | disabled]
    traffic_classes
        [none | default | class_one,class_two ... ]
    translate_address
        [enabled | disabled]
    translate_port
        [enabled | disabled]
    vlans
        [none | default | [enabled|disabled]:vlan1,vlan2,vlan3 ... ]
 
    CLI Examples::
 
        salt '*' bigip.create_virtual bigip admin admin my-virtual-3 26.2.2.5:80 \
            pool=my-http-pool-http profiles=http,tcp
 
        salt '*' bigip.create_virtual bigip admin admin my-virtual-3 43.2.2.5:80 \
            pool=test-http-pool-http profiles=http,websecurity persist=cookie,hash \
            policies=asm_auto_l7_policy__http-virtual \
            rules=_sys_APM_ExchangeSupport_helper,_sys_https_redirect \
            related_rules=_sys_APM_activesync,_sys_APM_ExchangeSupport_helper \
            source_address_translation=snat:my-snat-pool \
            translate_address=enabled translate_port=enabled \
            traffic_classes=my-class,other-class \
            vlans=enabled:external,internal
 
 
 
bigip.delete_monitor:
 
    A function to connect to a bigip device and delete an existing monitor.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    monitor_type
        The type of monitor to delete
    name
        The name of the monitor to delete
 
    CLI Example::
 
        salt '*' bigip.delete_monitor bigip admin admin http my-http-monitor
 
 
 
bigip.delete_node:
 
    A function to connect to a bigip device and delete a specific node.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the node which will be deleted.
    trans_label
        The label of the transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.delete_node bigip admin admin my-node
 
 
bigip.delete_pool:
 
    A function to connect to a bigip device and delete a specific pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool which will be deleted
 
    CLI Example::
 
        salt '*' bigip.delete_node bigip admin admin my-pool
 
 
bigip.delete_pool_member:
 
    A function to connect to a bigip device and delete a specific pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to modify
    member
        The name of the pool member to delete
 
    CLI Example::
 
        salt '*' bigip.delete_node bigip admin admin my-pool 10.2.2.2:80
 
 
bigip.delete_profile:
 
    A function to connect to a bigip device and delete an existing profile.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    profile_type
        The type of profile to delete
    name
        The name of the profile to delete
 
    CLI Example::
 
        salt '*' bigip.delete_profile bigip admin admin http my-http-profile
 
 
 
bigip.delete_transaction:
 
    A function to connect to a bigip device and delete an existing transaction.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    label
        The label of this transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.delete_transaction bigip admin admin my_transaction
 
 
bigip.delete_virtual:
 
    A function to connect to a bigip device and delete a specific virtual.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the virtual to delete
 
    CLI Example::
 
        salt '*' bigip.delete_virtual bigip admin admin my-virtual
 
 
bigip.list_monitor:
 
    A function to connect to a bigip device and list an existing monitor.  If no name is provided than all
    monitors of the specified type will be listed.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    monitor_type
        The type of monitor(s) to list
    name
        The name of the monitor to list
 
    CLI Example::
 
        salt '*' bigip.list_monitor bigip admin admin http my-http-monitor
 
 
 
bigip.list_node:
 
    A function to connect to a bigip device and list all nodes or a specific node.
 
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the node to list. If no name is specified than all nodes
        will be listed.
    trans_label
        The label of the transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.list_node bigip admin admin my-node
 
 
bigip.list_pool:
 
    A function to connect to a bigip device and list all pools or a specific pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to list. If no name is specified then all pools
        will be listed.
 
    CLI Example::
 
        salt '*' bigip.list_pool bigip admin admin my-pool
 
 
bigip.list_profile:
 
    A function to connect to a bigip device and list an existing profile.  If no name is provided than all
    profiles of the specified type will be listed.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    profile_type
        The type of profile(s) to list
    name
        The name of the profile to list
 
    CLI Example::
 
        salt '*' bigip.list_profile bigip admin admin http my-http-profile
 
 
 
bigip.list_transaction:
 
    A function to connect to a bigip device and list an existing transaction.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    label
        the label of this transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.list_transaction bigip admin admin my_transaction
 
 
 
bigip.list_virtual:
 
    A function to connect to a bigip device and list all virtuals or a specific virtual.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the virtual to list. If no name is specified than all
        virtuals will be listed.
 
    CLI Example::
 
        salt '*' bigip.list_virtual bigip admin admin my-virtual
 
 
bigip.modify_monitor:
 
    A function to connect to a bigip device and modify an existing monitor.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    monitor_type
        The type of monitor to modify
    name
        The name of the monitor to modify
    kwargs
        Consult F5 BIGIP user guide for specific options for each monitor type.
        Typically, tmsh arg names are used.
 
    CLI Example::
 
        salt '*' bigip.modify_monitor bigip admin admin http my-http-monitor  timout=16 interval=6
 
 
 
bigip.modify_node:
 
    A function to connect to a bigip device and modify an existing node.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the node to modify
    connection_limit
        [integer]
    description
        [string]
    dynamic_ratio
        [integer]
    logging
        [enabled | disabled]
    monitor
        [[name] | none | default]
    rate_limit
        [integer]
    ratio
        [integer]
    session
        [user-enabled | user-disabled]
    state
        [user-down | user-up ]
    trans_label
        The label of the transaction stored within the grain:
        ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.modify_node bigip admin admin 10.1.1.2 ratio=2 logging=enabled
 
 
bigip.modify_pool:
 
    A function to connect to a bigip device and modify an existing pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to modify.
    allow_nat
        [yes | no]
    allow_snat
        [yes | no]
    description
        [string]
    gateway_failsafe_device
        [string]
    ignore_persisted_weight
        [yes | no]
    ip_tos_to_client
        [pass-through | [integer]]
    ip_tos_to_server
        [pass-through | [integer]]
    link_qos_to_client
        [pass-through | [integer]]
    link_qos_to_server
        [pass-through | [integer]]
    load_balancing_mode
        [dynamic-ratio-member | dynamic-ratio-node |
        fastest-app-response | fastest-node |
        least-connections-members |
        least-connections-node |
        least-sessions |
        observed-member | observed-node |
        predictive-member | predictive-node |
        ratio-least-connections-member |
        ratio-least-connections-node |
        ratio-member | ratio-node | ratio-session |
        round-robin | weighted-least-connections-member |
        weighted-least-connections-node]
    min_active_members
        [integer]
    min_up_members
        [integer]
    min_up_members_action
        [failover | reboot | restart-all]
    min_up_members_checking
        [enabled | disabled]
    monitor
        [name]
    profiles
        [none | profile_name]
    queue_on_connection_limit
        [enabled | disabled]
    queue_depth_limit
        [integer]
    queue_time_limit
        [integer]
    reselect_tries
        [integer]
    service_down_action
        [drop | none | reselect | reset]
    slow_ramp_time
        [integer]
 
    CLI Example::
 
        salt '*' bigip.modify_pool bigip admin admin my-pool 10.1.1.1:80,10.1.1.2:80,10.1.1.3:80 min_active_members=1
 
 
bigip.modify_pool_member:
 
    A function to connect to a bigip device and modify an existing member of a pool.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to modify
    member
        The name of the member to modify i.e. 10.1.1.2:80
    connection_limit
        [integer]
    description
        [string]
    dynamic_ratio
        [integer]
    inherit_profile
        [enabled | disabled]
    logging
        [enabled | disabled]
    monitor
        [name]
    priority_group
        [integer]
    profiles
        [none | profile_name]
    rate_limit
        [integer]
    ratio
        [integer]
    session
        [user-enabled | user-disabled]
    state
        [ user-up | user-down ]
 
    CLI Example::
 
        salt '*' bigip.modify_pool_member bigip admin admin my-pool 10.2.2.1:80 state=use-down session=user-disabled
 
 
bigip.modify_profile:
 
    A function to connect to a bigip device and create a profile.
 
    A function to connect to a bigip device and create a profile.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    profile_type
        The type of profile to create
    name
        The name of the profile to create
    kwargs
        ``[ arg=val ] ... [arg=key1:val1,key2:val2] ...``
 
        Consult F5 BIGIP user guide for specific options for each monitor type.
        Typically, tmsh arg names are used.
 
    Creating Complex Args
 
        Profiles can get pretty complicated in terms of the amount of possible
        config options. Use the following shorthand to create complex arguments such
        as lists, dictionaries, and lists of dictionaries. An option is also
        provided to pass raw json as well.
 
        lists ``[i,i,i]``:
            ``param='item1,item2,item3'``
 
        Dictionary ``[k:v,k:v,k,v]``:
            ``param='key-1:val-1,key-2:val2,key-3:va-3'``
 
        List of Dictionaries ``[k:v,k:v|k:v,k:v|k:v,k:v]``:
           ``param='key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2|key-1:val-1,key-2:val-2'``
 
        JSON: ``'j{ ... }j'``:
           ``cert-key-chain='j{ "default": { "cert": "default.crt", "chain": "default.crt", "key": "default.key" } }j'``
 
        Escaping Delimiters:
            Use ``\,`` or ``\:`` or ``\|`` to escape characters which shouldn't
            be treated as delimiters i.e. ``ciphers='DEFAULT\:!SSLv3'``
 
    CLI Examples::
 
        salt '*' bigip.modify_profile bigip admin admin http my-http-profile defaultsFrom='/Common/http'
 
        salt '*' bigip.modify_profile bigip admin admin http my-http-profile defaultsFrom='/Common/http' \
            enforcement=maxHeaderCount:3200,maxRequests:10
 
        salt '*' bigip.modify_profile bigip admin admin client-ssl my-client-ssl-1 retainCertificate=false \
            ciphers='DEFAULT\:!SSLv3'
            cert_key_chain='j{ "default": { "cert": "default.crt", "chain": "default.crt", "key": "default.key" } }j'
 
 
bigip.modify_virtual:
 
    A function to connect to a bigip device and modify an existing virtual server.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the virtual to modify
    destination
        [ [virtual_address_name:port] | [ipv4:port] | [ipv6.port] ]
    pool
        [ [pool_name] | none]
    address_status
        [yes | no]
    auto_lasthop
        [default | enabled | disabled ]
    bwc_policy
        [none] | string]
    cmp_enabled
        [yes | no]
    dhcp_relay
        [yes | no}
    connection_limit
        [integer]
    description
        [string]
    state
        [disabled | enabled]
    fallback_persistence
        [none | [profile name] ]
    flow_eviction_policy
        [none | [eviction policy name] ]
    gtm_score
        [integer]
    ip_forward
        [yes | no]
    ip_protocol
        [any | protocol]
    internal
        [yes | no]
    twelve_forward
        (12-forward)
        [yes | no]
    last_hop-pool
        [ [pool_name] | none]
    mask
        { [ipv4] | [ipv6] }
    mirror
        { [disabled | enabled | none] }
    nat64
        [enabled | disabled]
    persist
        [none | profile1,profile2,profile3 ... ]
    profiles
        [none | default | profile1,profile2,profile3 ... ]
    policies
        [none | default | policy1,policy2,policy3 ... ]
    rate_class
        [name]
    rate_limit
        [integer]
    rate_limitr_mode
        [destination | object | object-destination |
        object-source | object-source-destination |
        source | source-destination]
    rate_limit_dst
        [integer]
    rate_limit_src
        [integer]
    rules
        [none | [rule_one,rule_two ...] ]
    related_rules
        [none | [rule_one,rule_two ...] ]
    reject
        [yes | no]
    source
        { [ipv4[/prefixlen]] | [ipv6[/prefixlen]] }
    source_address_translation
        [none | snat:pool_name | lsn | automap ]
    source_port
        [change | preserve | preserve-strict]
    state
        [enabled | disable]
    traffic_classes
        [none | default | class_one,class_two ... ]
    translate_address
        [enabled | disabled]
    translate_port
        [enabled | disabled]
    vlans
        [none | default | [enabled|disabled]:vlan1,vlan2,vlan3 ... ]
 
    CLI Example::
 
        salt '*' bigip.modify_virtual bigip admin admin my-virtual source_address_translation=none
        salt '*' bigip.modify_virtual bigip admin admin my-virtual rules=my-rule,my-other-rule
 
 
bigip.replace_pool_members:
 
    A function to connect to a bigip device and replace members of an existing pool with new members.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    name
        The name of the pool to modify
    members
        List of comma delimited pool members to replace existing members with.
        i.e. 10.1.1.1:80,10.1.1.2:80,10.1.1.3:80
 
    CLI Example::
 
        salt '*' bigip.replace_pool_members bigip admin admin my-pool 10.2.2.1:80,10.2.2.2:80,10.2.2.3:80
 
 
bigip.start_transaction:
 
    A function to connect to a bigip device and start a new transaction.
 
    hostname
        The host/address of the bigip device
    username
        The iControl REST username
    password
        The iControl REST password
    label
        The name / alias for this transaction.  The actual transaction
        id will be stored within a grain called ``bigip_f5_trans:<label>``
 
    CLI Example::
 
        salt '*' bigip.start_transaction bigip admin admin my_transaction
 
 
 
blockdev.dump:
 
    Return all contents of dumpe2fs for a specified device
 
    args
        a list containing only the desired arguments to return
 
    CLI Example:
 
        salt '*' blockdev.dump /dev/sdX1
 
 
blockdev.format:
 
    Format a filesystem onto a block device
 
    New in version 2015.8.2
 
    device
        The block device in which to create the new filesystem
 
    fs_type
        The type of filesystem to create
 
    inode_size
        Size of the inodes
 
        This option is only enabled for ext and xfs filesystems
 
    lazy_itable_init
        If enabled and the uninit_bg feature is enabled, the inode table will
        not be fully initialized by mke2fs.  This speeds up filesystem
        initialization noticeably, but it requires the kernel to finish
        initializing the filesystem  in  the  background  when  the filesystem
        is first mounted.  If the option value is omitted, it defaults to 1 to
        enable lazy inode table zeroing.
 
        This option is only enabled for ext filesystems
 
    CLI Example:
 
        salt '*' blockdev.format /dev/sdX1
 
 
blockdev.fstype:
 
    Return the filesystem name of a block device
 
    New in version 2015.8.2
 
    device
        The name of the block device
 
    CLI Example:
 
        salt '*' blockdev.fstype /dev/sdX1
 
 
blockdev.resize2fs:
 
    Resizes the filesystem.
 
    CLI Example:
        salt '*' blockdev.resize2fs /dev/sdX1
 
 
blockdev.tune:
 
    Set attributes for the specified device
 
    CLI Example:
 
        salt '*' blockdev.tune /dev/sdX1 read-ahead=1024 read-write=True
 
    Valid options are: ``read-ahead``, ``filesystem-read-ahead``,
    ``read-only``, ``read-write``.
 
    See the ``blockdev(8)`` manpage for a more complete description of these
    options.
 
 
blockdev.wipe:
 
    Remove the filesystem information
 
    CLI Example:
 
        salt '*' blockdev.wipe /dev/sdX1
 
 
btrfs.add:
 
    Add a devices to a BTRFS filesystem.
 
    General options:
 
    * **nodiscard**: Do not perform whole device TRIM
    * **force**: Force overwrite existing filesystem on the disk
 
    CLI Example:
 
        salt '*' btrfs.add /mountpoint /dev/sda1 /dev/sda2
 
 
btrfs.convert:
 
    Convert ext2/3/4 to BTRFS. Device should be mounted.
 
    Filesystem can be converted temporarily so the further processing and rollback is possible,
    or permanently, where previous extended filesystem image gets deleted. Please note, permanent
    conversion takes a while as BTRFS filesystem needs to be properly rebalanced afterwards.
 
    General options:
 
    * **permanent**: Specify if the migration should be permanent (false by default)
    * **keeplf**: Keep ``lost+found`` of the partition (removed by default,
                  but still in the image, if not permanent migration)
 
    CLI Example:
 
        salt '*' btrfs.convert /dev/sda1
        salt '*' btrfs.convert /dev/sda1 permanent=True
 
 
btrfs.defragment:
 
    Defragment mounted BTRFS filesystem.
    In order to defragment a filesystem, device should be properly mounted and writable.
 
    If passed a device name, then defragmented whole filesystem, mounted on in.
    If passed a moun tpoint of the filesystem, then only this mount point is defragmented.
 
    CLI Example:
 
        salt '*' btrfs.defragment /dev/sda1
        salt '*' btrfs.defragment /path/on/filesystem
 
 
btrfs.delete:
 
    Remove devices from a BTRFS filesystem.
 
    CLI Example:
 
        salt '*' btrfs.delete /mountpoint /dev/sda1 /dev/sda2
 
 
btrfs.devices:
 
    Get known BTRFS formatted devices on the system.
 
    CLI Example:
 
        salt '*' btrfs.devices
 
 
btrfs.features:
 
    List currently available BTRFS features.
 
    CLI Example:
 
        salt '*' btrfs.mkfs_features
 
 
btrfs.info:
 
    Get BTRFS filesystem information.
 
    CLI Example:
 
        salt '*' btrfs.info /dev/sda1
 
 
btrfs.mkfs:
 
    Create a file system on the specified device. By default wipes out with force.
 
    General options:
 
    * **allocsize**: Specify the BTRFS offset from the start of the device.
    * **bytecount**: Specify the size of the resultant filesystem.
    * **nodesize**: Node size.
    * **leafsize**: Specify the nodesize, the tree block size in which btrfs stores data.
    * **noforce**: Prevent force overwrite when an existing filesystem is detected on the device.
    * **sectorsize**: Specify the sectorsize, the minimum data block allocation unit.
    * **nodiscard**: Do not perform whole device TRIM operation by default.
    * **uuid**: Pass UUID or pass True to generate one.
 
 
    Options:
 
    * **dto**: (raid0|raid1|raid5|raid6|raid10|single|dup)
               Specify how the data must be spanned across the devices specified.
    * **mto**: (raid0|raid1|raid5|raid6|raid10|single|dup)
               Specify how metadata must be spanned across the devices specified.
    * **fts**: Features (call ``salt <host> btrfs.features`` for full list of available features)
 
    See the ``mkfs.btrfs(8)`` manpage for a more complete description of corresponding options description.
 
    CLI Example:
 
        salt '*' btrfs.mkfs /dev/sda1
        salt '*' btrfs.mkfs /dev/sda1 noforce=True
 
 
btrfs.properties:
 
    List properties for given btrfs object. The object can be path of BTRFS device,
    mount point, or any directories/files inside the BTRFS filesystem.
 
    General options:
 
    * **type**: Possible types are s[ubvol], f[ilesystem], i[node] and d[evice].
    * **force**: Force overwrite existing filesystem on the disk
    * **set**: <key=value,key1=value1...> Options for a filesystem properties.
 
    CLI Example:
 
        salt '*' btrfs.properties /mountpoint
        salt '*' btrfs.properties /dev/sda1 type=subvol set='ro=false,label="My Storage"'
 
 
btrfs.resize:
 
    Resize filesystem.
 
    General options:
 
    * **mountpoint**: Specify the BTRFS mountpoint to resize.
    * **size**: ([+/-]<newsize>[kKmMgGtTpPeE]|max) Specify the new size of the target.
 
    CLI Example:
 
        salt '*' btrfs.resize /mountpoint size=+1g
        salt '*' btrfs.resize /dev/sda1 size=max
 
 
btrfs.usage:
 
    Show in which disk the chunks are allocated.
 
    CLI Example:
 
        salt '*' btrfs.usage /your/mountpoint
 
 
btrfs.version:
 
    Return BTRFS version.
 
    CLI Example:
 
        salt '*' btrfs.version
 
 
buildout.bootstrap:
 
    Run the buildout bootstrap dance (python bootstrap.py).
 
    directory
        directory to execute in
 
    config
        alternative buildout configuration file to use
 
    runas
        User used to run buildout as
 
    env
        environment variables to set when running
 
    buildout_ver
        force a specific buildout version (1 | 2)
 
    test_release
        buildout accept test release
 
    offline
        are we executing buildout in offline mode
 
    distribute
        Forcing use of distribute
 
    new_st
        Forcing use of setuptools >= 0.7
 
    python
        path to a python executable to use in place of default (salt one)
 
    onlyif
        Only execute cmd if statement on the host return 0
 
    unless
        Do not execute cmd if statement on the host return 0
 
    use_vt
        Use the new salt VT to stream output [experimental]
 
    CLI Example:
 
        salt '*' buildout.bootstrap /srv/mybuildout
 
 
buildout.buildout:
 
    Run buildout in a directory.
 
    directory
        directory to execute in
 
    config
        buildout config to use
 
    parts
        specific buildout parts to run
 
    runas
        user used to run buildout as
 
    env
        environment variables to set when running
 
    buildout_ver
        force a specific buildout version (1 | 2)
 
    test_release
        buildout accept test release
 
    new_st
        Forcing use of setuptools >= 0.7
 
    distribute
        use distribute over setuptools if possible
 
    offline
        does buildout run offline
 
    python
        python to use
 
    debug
        run buildout with -D debug flag
 
    onlyif
        Only execute cmd if statement on the host return 0
 
    unless
        Do not execute cmd if statement on the host return 0
    newest
        run buildout in newest mode
 
    verbose
        run buildout in verbose mode (-vvvvv)
 
    use_vt
        Use the new salt VT to stream output [experimental]
 
    CLI Example:
 
        salt '*' buildout.buildout /srv/mybuildout
 
 
buildout.run_buildout:
 
    Run a buildout in a directory.
 
    directory
        directory to execute in
 
    config
        alternative buildout configuration file to use
 
    offline
        are we executing buildout in offline mode
 
    runas
        user used to run buildout as
 
    env
        environment variables to set when running
 
    onlyif
        Only execute cmd if statement on the host return 0
 
    unless
        Do not execute cmd if statement on the host return 0
 
    newest
        run buildout in newest mode
 
    force
        run buildout unconditionally
 
    verbose
        run buildout in verbose mode (-vvvvv)
 
    use_vt
        Use the new salt VT to stream output [experimental]
 
    CLI Example:
 
        salt '*' buildout.run_buildout /srv/mybuildout
 
 
buildout.upgrade_bootstrap:
 
    Upgrade current bootstrap.py with the last released one.
 
    Indeed, when we first run a buildout, a common source of problem
    is to have a locally stale bootstrap, we just try to grab a new copy
 
    directory
        directory to execute in
 
    offline
        are we executing buildout in offline mode
 
    buildout_ver
        forcing to use a specific buildout version (1 | 2)
 
    onlyif
        Only execute cmd if statement on the host return 0
 
    unless
        Do not execute cmd if statement on the host return 0
 
    CLI Example:
 
        salt '*' buildout.upgrade_bootstrap /srv/mybuildout
 
 
cloud.action:
 
    Execute a single action on the given provider/instance
 
    CLI Example:
 
        salt '*' cloud.action start instance=myinstance
        salt '*' cloud.action stop instance=myinstance
        salt '*' cloud.action show_image provider=my-ec2-config image=ami-1624987f
 
 
cloud.create:
 
    Create an instance using Salt Cloud
 
    CLI Example:
 
        salt minionname cloud.create my-ec2-config myinstance image=ami-1624987f size='t1.micro' ssh_username=ec2-user securitygroup=default delvol_on_destroy=True
 
 
cloud.destroy:
 
    Destroy the named VM(s)
 
    CLI Example:
 
        salt '*' cloud.destroy myinstance
 
 
cloud.full_query:
 
    List all available cloud provider data
 
    CLI Example:
 
        salt '*' cloud.full_query
 
 
cloud.get_instance:
 
    Return details on an instance.
 
    Similar to the cloud action show_instance
    but returns only the instance details.
 
    CLI Example:
 
        salt '*' cloud.get_instance myinstance
 
    SLS Example:
 
        {{ salt['cloud.get_instance']('myinstance')['mac_address'] }}
 
 
 
cloud.has_instance:
 
    Return true if the instance is found on a provider
 
    CLI Example:
 
        salt '*' cloud.has_instance myinstance
 
 
cloud.list_images:
 
    List cloud provider images for the given providers
 
    CLI Example:
 
        salt '*' cloud.list_images my-gce-config
 
 
cloud.list_locations:
 
    List cloud provider locations for the given providers
 
    CLI Example:
 
        salt '*' cloud.list_locations my-gce-config
 
 
cloud.list_sizes:
 
    List cloud provider sizes for the given providers
 
    CLI Example:
 
        salt '*' cloud.list_sizes my-gce-config
 
 
cloud.network_create:
 
    Create private network
 
    CLI Example:
 
        salt minionname cloud.network_create my-nova names=['salt'] cidr='192.168.100.0/24'
 
 
 
cloud.network_list:
 
    List private networks
 
    CLI Example:
 
        salt minionname cloud.network_list my-nova
 
 
 
cloud.profile:
 
    Spin up an instance using Salt Cloud
 
    CLI Example:
 
        salt '*' cloud.profile my-gce-config myinstance
 
 
cloud.query:
 
    List cloud provider data for all providers
 
    CLI Examples:
 
        salt '*' cloud.query
        salt '*' cloud.query list_nodes_full
        salt '*' cloud.query list_nodes_select
 
 
cloud.select_query:
 
    List selected nodes
 
    CLI Example:
 
        salt '*' cloud.select_query
 
 
cloud.virtual_interface_create:
 
    Attach private interfaces to a server
 
    CLI Example:
 
        salt minionname cloud.virtual_interface_create my-nova names=['salt-master'] net_name='salt'
 
 
 
cloud.virtual_interface_list:
 
    List virtual interfaces on a server
 
    CLI Example:
 
        salt minionname cloud.virtual_interface_list my-nova names=['salt-master']
 
 
 
cloud.volume_attach:
 
    Attach volume to a server
 
    CLI Example:
 
        salt minionname cloud.volume_attach my-nova myblock server_name=myserver device='/dev/xvdf'
 
 
 
cloud.volume_create:
 
    Create volume
 
    CLI Example:
 
        salt minionname cloud.volume_create my-nova myblock size=100 voltype=SSD
 
 
 
cloud.volume_delete:
 
    Delete volume
 
    CLI Example:
 
        salt minionname cloud.volume_delete my-nova myblock
 
 
 
cloud.volume_detach:
 
    Detach volume from a server
 
    CLI Example:
 
        salt minionname cloud.volume_detach my-nova myblock server_name=myserver
 
 
 
cloud.volume_list:
 
    List block storage volumes
 
    CLI Example:
 
        salt minionname cloud.volume_list my-nova
 
 
 
cmd.exec_code:
 
    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 will be returned.
 
    CLI Example:
 
        salt '*' cmd.exec_code ruby 'puts "cheese"'
 
 
cmd.exec_code_all:
 
    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. All cmd artifacts (stdout, stderr, retcode, pid)
    will be returned.
 
    CLI Example:
 
        salt '*' cmd.exec_code_all ruby 'puts "cheese"'
 
 
cmd.has_exec:
 
    Returns true if the executable is available on the minion, false otherwise
 
    CLI Example:
 
        salt '*' cmd.has_exec cat
 
 
cmd.retcode:
 
    Execute a shell command and return the command's return code.
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
    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.
 
    :rtype: int
    :rtype: None
    :returns: Return Code as an int or None if there was an exception.
 
    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'
 
 
cmd.run:
 
    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.
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
 
    Warning:
 
        This function does not process commands through a shell
        unless the python_shell flag is set to True. This means that any
        shell-specific functionality such as 'echo' or the use of pipes,
        redirection or &&, should either be migrated to cmd.shell or
        have the python_shell=True flag set here.
 
        The use of python_shell=True means that the shell will accept _any_ input
        including potentially malicious commands such as 'good_command;rm -rf /'.
        Be absolutely certain that you have sanitized your input prior to using
        python_shell=True
 
    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'
 
    If an equal sign (``=``) appears in an argument to a Salt command it is
    interpreted as a keyword argument in the format ``key=val``. That
    processing can be bypassed in order to pass an equal sign through to the
    remote shell command by manually specifying the kwarg:
 
        salt '*' cmd.run cmd='sed -e s/=/:/g'
 
 
cmd.run_all:
 
    Execute the passed command and return a dict of return data
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
    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.
 
    redirect_stderr : False
        If set to ``True``, then stderr will be redirected to stdout. This is
        helpful for cases where obtaining both the retcode and output is
        desired, but it is not desired to have the output separated into both
        stdout and stderr.
 
        New in version 2015.8.2
 
    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'
 
 
cmd.run_chroot:
 
    New in version 2014.7.0
 
    This function runs :mod:`cmd.run_all <salt.modules.cmdmod.run_all>` wrapped
    within a chroot, with dev and proc mounted in the chroot
 
    root:
        Path to the root of the jail to use.
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
 
    CLI Example:
 
        salt '*' cmd.run_chroot /var/lib/lxc/container_name/rootfs 'sh /tmp/bootstrap.sh'
 
 
cmd.run_stderr:
 
    Execute a command and only return the standard error
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
    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'
 
 
cmd.run_stdout:
 
    Execute a command, and only return the standard out
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
 
    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'
 
 
cmd.script:
 
    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.
 
    source
        The location of the script to download. If the file is located on the
        master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs
 
    args
        String of command line args to pass to the script.  Only used if no
        args are specified as part of the `name` argument. To pass a string
        containing spaces in YAML, you will need to doubly-quote it:  "arg1
        'arg two' arg3"
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    quiet
        The command will be executed quietly, meaning no log entries of the
        actual command or its return data. This is deprecated as of the
        **2014.1.0** release, and is being replaced with
        ``output_loglevel: quiet``.
 
    timeout
        If the command has not terminated after timeout seconds, send the
        subprocess sigterm, and if sigterm is ignored, follow up with sigkill
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
 
    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'
 
 
        salt '*' cmd.script salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n'
 
 
cmd.script_retcode:
 
    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 formatted as a template, the default is jinja.
 
    Only evaluate the script return code and do not block for terminal output
 
    source
        The location of the script to download. If the file is located on the
        master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs
 
    args
        String of command line args to pass to the script.  Only used if no
        args are specified as part of the `name` argument. To pass a string
        containing spaces in YAML, you will need to doubly-quote it:  "arg1
        'arg two' arg3"
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    python_shell
        If False, let python handle the positional arguments. Set to True
        to use shell features, such as pipes or redirection
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    quiet
        The command will be executed quietly, meaning no log entries of the
        actual command or its return data. This is deprecated as of the
        **2014.1.0** release, and is being replaced with
        ``output_loglevel: quiet``.
 
    timeout
        If the command has not terminated after timeout seconds, send the
        subprocess sigterm, and if sigterm is ignored, follow up with sigkill
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
 
    CLI Example:
 
        salt '*' cmd.script_retcode salt://scripts/runme.sh
        salt '*' cmd.script_retcode salt://scripts/runme.sh 'arg1 arg2 "arg 3"'
        salt '*' cmd.script_retcode 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_retcode salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n'
 
 
cmd.shell:
 
    Execute the passed command and return the output as a string.
 
    New in version 2015.5.0
 
    cmd:
        The command to run. ex: 'ls -lart /home'
 
    cwd
        The current working directory to execute the command in, defaults to
        /root
 
    stdin
        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.:
 
    runas
        User to run script as.
 
    shell
        Shell to execute under. Defaults to the system default shell.
 
    env
        A list of environment variables to be set prior to execution.
        Example:
 
            salt://scripts/foo.sh:
              cmd.script:
                - env:
                  - BATCH: 'yes'
 
        Warning:
 
            The above illustrates a common PyYAML pitfall, that **yes**,
            **no**, **on**, **off**, **true**, and **false** are all loaded as
            boolean ``True`` and ``False`` values, and must be enclosed in
            quotes to be used as strings. More info on this (and other) PyYAML
            idiosyncrasies can be found :doc:`here
            </topics/troubleshooting/yaml_idiosyncrasies>`.
 
        Variables as values are not evaluated. So $PATH in the following
        example is a literal '$PATH':
 
            salt://scripts/bar.sh:
              cmd.script:
                - env: "PATH=/some/path:$PATH"
 
        One can still use the existing $PATH by using a bit of Jinja:
 
            {% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
 
            mycommand:
              cmd.run:
                - name: ls -l /
                - env:
                  - PATH: {{ [current_path, '/my/special/bin']|join(':') }}
 
     clean_env:
        Attempt to clean out all other shell environment variables and set
        only those provided in the 'env' argument to this function.
 
    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file. Currently jinja, mako, and wempy
        are supported
 
    rstrip
        Strip all whitespace off the end of output before it is returned.
 
    umask
         The umask (in octal) to use when running the command.
 
    output_loglevel
        Control the loglevel at which the output from the command is logged.
        Note that the command being run will still be logged (loglevel: DEBUG)
        regardless, unless ``quiet`` is used for this value.
 
    timeout
        A timeout in seconds for the executed process to return.
 
    use_vt
        Use VT utils (saltstack) to stream the command output more
        interactively to the console and the logs.
        This is experimental.
 
    Warning:
 
        This passes the cmd argument directly to the shell
        without any further processing! Be absolutely sure that you
        have properly santized the command passed to this function
        and do not use untrusted inputs.
 
    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.shell "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.shell template=jinja "ls -l /tmp/{{grains.id}} | awk '/foo/{print \$2}'"
 
    Specify an alternate shell with the shell parameter:
 
        salt '*' cmd.shell "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.shell "grep f" stdin='one\ntwo\nthree\nfour\nfive\n'
 
    If an equal sign (``=``) appears in an argument to a Salt command it is
    interpreted as a keyword argument in the format ``key=val``. That
    processing can be bypassed in order to pass an equal sign through to the
    remote shell command by manually specifying the kwarg:
 
        salt '*' cmd.shell cmd='sed -e s/=/:/g'
 
 
cmd.shells:
 
    Lists the valid shells on this system via the /etc/shells file
 
    New in version 2015.5.0
 
    CLI Example::
 
        salt '*' cmd.shells
 
 
cmd.tty:
 
    Echo a string to a specific tty
 
    CLI Example:
 
        salt '*' cmd.tty tty0 'This is a test'
        salt '*' cmd.tty pts3 'This is a test'
 
 
cmd.which:
 
    Returns the path of an executable available on the minion, None otherwise
 
    CLI Example:
 
        salt '*' cmd.which cat
 
 
cmd.which_bin:
 
    Returns the first command found in a list of commands
 
    CLI Example:
 
        salt '*' cmd.which_bin '[pip2, pip, pip-python]'
 
 
composer.did_composer_install:
 
    Test to see if the vendor directory exists in this directory
 
    dir
        Directory location of the composer.json file
 
    CLI Example:
 
        salt '*' composer.did_composer_install /var/www/application
 
 
composer.install:
 
    Install composer dependencies for a directory.
 
    If composer has not been installed globally making it available in the
    system PATH & making it executable, the ``composer`` and ``php`` parameters
    will need to be set to the location of the executables.
 
    dir
        Directory location of the composer.json file.
 
    composer
        Location of the composer.phar file. If not set composer will
        just execute "composer" as if it is installed globally.
        (i.e. /path/to/composer.phar)
 
    php
        Location of the php executable to use with composer.
        (i.e. /usr/bin/php)
 
    runas
        Which system user to run composer as.
 
    prefer_source
        --prefer-source option of composer.
 
    prefer_dist
        --prefer-dist option of composer.
 
    no_scripts
        --no-scripts option of composer.
 
    no_plugins
        --no-plugins option of composer.
 
    optimize
        --optimize-autoloader option of composer. Recommended for production.
 
    no_dev
        --no-dev option for composer. Recommended for production.
 
    quiet
        --quiet option for composer. Whether or not to return output from composer.
 
    composer_home
        $COMPOSER_HOME environment variable
 
    CLI Example:
 
        salt '*' composer.install /var/www/application
 
        salt '*' composer.install /var/www/application             no_dev=True optimize=True
 
 
composer.selfupdate:
 
    Update composer itself.
 
    If composer has not been installed globally making it available in the
    system PATH & making it executable, the ``composer`` and ``php`` parameters
    will need to be set to the location of the executables.
 
    composer
        Location of the composer.phar file. If not set composer will
        just execute "composer" as if it is installed globally.
        (i.e. /path/to/composer.phar)
 
    php
        Location of the php executable to use with composer.
        (i.e. /usr/bin/php)
 
    runas
        Which system user to run composer as.
 
    quiet
        --quiet option for composer. Whether or not to return output from composer.
 
    composer_home
        $COMPOSER_HOME environment variable
 
    CLI Example:
 
        salt '*' composer.selfupdate
 
 
composer.update:
 
    Update composer dependencies for a directory.
 
    If `composer install` has not yet been run, this runs `composer install`
    instead.
 
    If composer has not been installed globally making it available in the
    system PATH & making it executable, the ``composer`` and ``php`` parameters
    will need to be set to the location of the executables.
 
    dir
        Directory location of the composer.json file.
 
    composer
        Location of the composer.phar file. If not set composer will
        just execute "composer" as if it is installed globally.
        (i.e. /path/to/composer.phar)
 
    php
        Location of the php executable to use with composer.
        (i.e. /usr/bin/php)
 
    runas
        Which system user to run composer as.
 
    prefer_source
        --prefer-source option of composer.
 
    prefer_dist
        --prefer-dist option of composer.
 
    no_scripts
        --no-scripts option of composer.
 
    no_plugins
        --no-plugins option of composer.
 
    optimize
        --optimize-autoloader option of composer. Recommended for production.
 
    no_dev
        --no-dev option for composer. Recommended for production.
 
    quiet
        --quiet option for composer. Whether or not to return output from composer.
 
    composer_home
        $COMPOSER_HOME environment variable
 
    CLI Example:
 
        salt '*' composer.update /var/www/application
 
        salt '*' composer.update /var/www/application             no_dev=True optimize=True
 
 
config.backup_mode:
 
    Return the backup mode
 
    CLI Example:
 
        salt '*' config.backup_mode
 
 
config.dot_vals:
 
    Pass in a configuration value that should be preceded by the module name
    and a dot, this will return a list of all read key/value pairs
 
    CLI Example:
 
        salt '*' config.dot_vals host
 
 
config.gather_bootstrap_script:
 
    Download the salt-bootstrap script, and return its location
 
    bootstrap
        URL of alternate bootstrap script
 
    CLI Example:
 
        salt '*' config.gather_bootstrap_script
 
 
config.get:
 
    .. versionadded: 0.14.0
 
    Attempt to retrieve the named value from the minion config file, pillar,
    grains or the master config. If the named value is not available, return the
    value specified by ``default``. If not specified, the default is an empty
    string.
 
    Values can also be retrieved from nested dictionaries. Assume the below
    data structure:
 
        {'pkg': {'apache': 'httpd'}}
 
    To retrieve the value associated with the ``apache`` key, in the
    sub-dictionary corresponding to the ``pkg`` key, the following command can
    be used:
 
        salt myminion config.get pkg:apache
 
    The ``:`` (colon) is used to represent a nested dictionary level.
 
    Changed in version 2015.5.0
        The ``delimiter`` argument was added, to allow delimiters other than
        ``:`` to be used.
 
    This function traverses these data stores in this order, returning the
    first match found:
 
    - Minion config file
    - Minion's grains
    - Minion's pillar data
    - Master config file
 
    This means that if there is a value that is going to be the same for the
    majority of minions, it can be configured in the Master config file, and
    then overridden using the grains, pillar, or Minion config file.
 
    **Arguments**
 
    delimiter
        New in version 2015.5.0
 
        Override the delimiter used to separate nested levels of a data
        structure.
 
    merge
        New in version 2015.5.0
 
        If passed, this parameter will change the behavior of the function so
        that, instead of traversing each data store above in order and
        returning the first match, the data stores are first merged together
        and then searched. The pillar data is merged into the master config
        data, then the grains are merged, followed by the Minion config data.
        The resulting data structure is then searched for a match. This allows
        for configurations to be more flexible.
 
        Note:
 
            The merging described above does not mean that grain data will end
            up in the Minion's pillar data, or pillar data will end up in the
            master config data, etc. The data is just combined for the purposes
            of searching an amalgam of the different data stores.
 
        The supported merge strategies are as follows:
 
        - **recurse** - If a key exists in both dictionaries, and the new value
          is not a dictionary, it is replaced. Otherwise, the sub-dictionaries
          are merged together into a single dictionary, recursively on down,
          following the same criteria. For example:
 
              >>> dict1 = {'foo': {'bar': 1, 'qux': True},
                           'hosts': ['a', 'b', 'c'],
                           'only_x': None}
              >>> dict2 = {'foo': {'baz': 2, 'qux': False},
                           'hosts': ['d', 'e', 'f'],
                           'only_y': None}
              >>> merged
              {'foo': {'bar': 1, 'baz': 2, 'qux': False},
               'hosts': ['d', 'e', 'f'],
               'only_dict1': None,
               'only_dict2': None}
 
        - **overwrite** - If a key exists in the top level of both
          dictionaries, the new value completely overwrites the old. For
          example:
 
              >>> dict1 = {'foo': {'bar': 1, 'qux': True},
                           'hosts': ['a', 'b', 'c'],
                           'only_x': None}
              >>> dict2 = {'foo': {'baz': 2, 'qux': False},
                           'hosts': ['d', 'e', 'f'],
                           'only_y': None}
              >>> merged
              {'foo': {'baz': 2, 'qux': False},
               'hosts': ['d', 'e', 'f'],
               'only_dict1': None,
               'only_dict2': None}
 
    CLI Example:
 
        salt '*' config.get pkg:apache
        salt '*' config.get lxc.container_profile:centos merge=recurse
 
 
config.manage_mode:
 
    Return a mode value, normalized to a string
 
    CLI Example:
 
        salt '*' config.manage_mode
 
 
config.merge:
 
    Retrieves an option based on key, merging all matches.
 
    Same as ``option()`` except that it merges all matches, rather than taking
    the first match.
 
    CLI Example:
 
        salt '*' config.merge schedule
 
 
config.option:
 
    Pass in a generic option and receive the value that will be assigned
 
    CLI Example:
 
        salt '*' config.option redis.host
 
 
config.valid_fileproto:
 
    Returns a boolean value based on whether or not the URI passed has a valid
    remote file protocol designation
 
    CLI Example:
 
        salt '*' config.valid_fileproto salt://path/to/file
 
 
consul.acl_clone:
 
    Information about an ACL token.
 
    :param consul_url: The Consul server URL.
    :param id: Unique identifier for the ACL to update.
    :return: Boolean, message of success or
             failure, and new ID of cloned ACL.
 
    CLI Example:
 
        salt '*' consul.acl_info id='c1c4d223-91cb-3d1f-1ee8-f2af9e7b6716'
 
 
 
consul.acl_create:
 
    Create a new ACL token.
 
    :param consul_url: The Consul server URL.
    :param name: Meaningful indicator of the ACL's purpose.
    :param type: Type is either client or management. A management
                 token is comparable to a root user and has the
                 ability to perform any action including creating,
                 modifying, and deleting ACLs.
    :param rules: The Consul server URL.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.acl_create
 
 
 
consul.acl_delete:
 
    Delete an ACL token.
 
    :param consul_url: The Consul server URL.
    :param id: Unique identifier for the ACL to update.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.acl_delete id='c1c4d223-91cb-3d1f-1ee8-f2af9e7b6716'
 
 
 
consul.acl_info:
 
    Information about an ACL token.
 
    :param consul_url: The Consul server URL.
    :param id: Unique identifier for the ACL to update.
    :return: Information about the ACL requested.
 
    CLI Example:
 
        salt '*' consul.acl_info id='c1c4d223-91cb-3d1f-1ee8-f2af9e7b6716'
 
 
 
consul.acl_list:
 
    List the ACL tokens.
 
    :param consul_url: The Consul server URL.
    :return: List of ACLs
 
    CLI Example:
 
        salt '*' consul.acl_list
 
 
 
consul.acl_update:
 
    Update an ACL token.
 
    :param consul_url: The Consul server URL.
    :param name: Meaningful indicator of the ACL's purpose.
    :param id: Unique identifier for the ACL to update.
    :param type: Type is either client or management. A management
                 token is comparable to a root user and has the
                 ability to perform any action including creating,
                 modifying, and deleting ACLs.
    :param rules: The Consul server URL.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.acl_update
 
 
 
consul.agent_check_deregister:
 
    The agent will take care of deregistering the check from the Catalog.
 
    :param consul_url: The Consul server URL.
    :param checkid: The ID of the check to deregister from Consul.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_check_deregister checkid='Memory Utilization'
 
 
 
consul.agent_check_fail:
 
    This endpoint is used with a check that is of the TTL type. When this
    is called, the status of the check is set to critical and the
    TTL clock is reset.
 
    :param consul_url: The Consul server URL.
    :param checkid: The ID of the check to deregister from Consul.
    :param note: A human-readable message with the status of the check.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_check_fail checkid='redis_check1'
                note='Forcing check into critical state.'
 
 
 
consul.agent_check_pass:
 
    This endpoint is used with a check that is of the TTL type. When this
    is called, the status of the check is set to passing and the TTL
    clock is reset.
 
    :param consul_url: The Consul server URL.
    :param checkid: The ID of the check to mark as passing.
    :param note: A human-readable message with the status of the check.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_check_pass checkid='redis_check1'
                note='Forcing check into passing state.'
 
 
 
consul.agent_check_register:
 
    The register endpoint is used to add a new check to the local agent.
 
    :param consul_url: The Consul server URL.
    :param name: The description of what the check is for.
    :param id: The unique name to use for the check, if not
               provided 'name' is used.
    :param notes: Human readable description of the check.
    :param script: If script is provided, the check type is
                   a script, and Consul will evaluate that script
                   based on the interval parameter.
    :param http: Check will perform an HTTP GET request against
                 the value of HTTP (expected to be a URL) based
                 on the interval parameter.
    :param ttl: If a TTL type is used, then the TTL update endpoint
                must be used periodically to update the state of the check.
    :param interval: Interval at which the check should run.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_check_register name='Memory Utilization'
                script='/usr/local/bin/check_mem.py' interval='15s'
 
 
 
consul.agent_check_warn:
 
    This endpoint is used with a check that is of the TTL type. When this
    is called, the status of the check is set to warning and the TTL
    clock is reset.
 
    :param consul_url: The Consul server URL.
    :param checkid: The ID of the check to deregister from Consul.
    :param note: A human-readable message with the status of the check.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_check_warn checkid='redis_check1'
                note='Forcing check into warning state.'
 
 
 
consul.agent_checks:
 
    Returns the checks the local agent is managing
 
    :param consul_url: The Consul server URL.
    :return: Returns the checks the local agent is managing
 
    CLI Example:
 
        salt '*' consul.agent_checks
 
 
 
consul.agent_join:
 
    Triggers the local agent to join a node
 
    :param consul_url: The Consul server URL.
    :param address: The address for the agent to connect to.
    :param wan: Causes the agent to attempt to join using the WAN pool.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_join address='192.168.1.1'
 
 
 
consul.agent_leave:
 
    Used to instruct the agent to force a node into the left state.
 
    :param consul_url: The Consul server URL.
    :param node: The node the agent will force into left state
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_leave node='web1.example.com'
 
 
 
consul.agent_maintenance:
 
    Manages node maintenance mode
 
    :param consul_url: The Consul server URL.
    :param enable: The enable flag is required.
                   Acceptable values are either true
                   (to enter maintenance mode) or
                   false (to resume normal operation).
    :param reason: If provided, its value should be a
                   text string explaining the reason for
                   placing the node into maintenance mode.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_maintenance enable='False' reason='Upgrade in progress'
 
 
 
consul.agent_members:
 
    Returns the members as seen by the local serf agent
 
    :param consul_url: The Consul server URL.
    :return: Returns the members as seen by the local serf agent
 
    CLI Example:
 
        salt '*' consul.agent_members
 
 
 
consul.agent_self:
 
    Returns the local node configuration
 
    :param consul_url: The Consul server URL.
    :return: Returns the local node configuration
 
    CLI Example:
 
        salt '*' consul.agent_self
 
 
 
consul.agent_service_deregister:
 
    Used to remove a service.
 
    :param consul_url: The Consul server URL.
    :param serviceid: A serviceid describing the service.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_service_deregister serviceid='redis'
 
 
 
consul.agent_service_maintenance:
 
    Used to place a service into maintenance mode.
 
    :param consul_url: The Consul server URL.
    :param serviceid: A name of the service.
    :param enable: Whether the service should be enabled or disabled.
    :param reason: A human readable message of why the service was
                   enabled or disabled.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_service_deregister serviceid='redis'
                enable='True' reason='Down for upgrade'
 
 
 
consul.agent_service_register:
 
    The used to add a new service, with an optional
    health check, to the local agent.
 
    :param consul_url: The Consul server URL.
    :param name: A name describing the service.
    :param address: The address used by the service, defaults
                    to the address of the agent.
    :param port: The port used by the service.
    :param id: Unique ID to identify the service, if not
               provided the value of the name parameter is used.
    :param tags: Identifying tags for service, string or list.
    :param script: If script is provided, the check type is
                   a script, and Consul will evaluate that script
                   based on the interval parameter.
    :param http: Check will perform an HTTP GET request against
                 the value of HTTP (expected to be a URL) based
                 on the interval parameter.
    :param check_ttl: If a TTL type is used, then the TTL update
                      endpoint must be used periodically to update
                      the state of the check.
    :param check_interval: Interval at which the check should run.
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.agent_service_register name='redis'
            tags='["master", "v1"]' address="127.0.0.1" port="8080"
            check_script="/usr/local/bin/check_redis.py" interval="10s"
 
 
 
consul.agent_services:
 
    Returns the services the local agent is managing
 
    :param consul_url: The Consul server URL.
    :return: Returns the services the local agent is managing
 
    CLI Example:
 
        salt '*' consul.agent_services
 
 
 
consul.catalog_datacenters:
 
    Return list of available datacenters from catalog.
 
    :param consul_url: The Consul server URL.
    :return: The list of available datacenters.
 
    CLI Example:
 
        salt '*' consul.catalog_datacenters
 
 
 
consul.catalog_deregister:
 
    Deregisters a node, service, or check
 
    :param consul_url: The Consul server URL.
    :param node: The node to deregister.
    :param datacenter: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param checkid: The ID of the health check to deregister.
    :param serviceid: The ID of the service to deregister.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.catalog_register node='node1'
            serviceid='redis_server1' checkid='redis_check1'
 
 
 
consul.catalog_node:
 
    Information about the registered node.
 
    :param consul_url: The Consul server URL.
    :param node: The node to request information about.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: Information about the requested node.
 
    CLI Example:
 
        salt '*' consul.catalog_service service='redis'
 
 
 
consul.catalog_nodes:
 
    Return list of available nodes from catalog.
 
    :param consul_url: The Consul server URL.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: The list of available nodes.
 
    CLI Example:
 
        salt '*' consul.catalog_nodes
 
 
 
consul.catalog_register:
 
    Registers a new node, service, or check
 
    :param consul_url: The Consul server URL.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param node: The node to register.
    :param address: The address of the node.
    :param service: The service that will be registered.
    :param service_address: The address that the service listens on.
    :param service_port: The port for the service.
    :param service_id: A unique identifier for the service, if this is not
                       provided "name" will be used.
    :param service_tags: Any tags associated with the service.
    :param check: The name of the health check to register
    :param check_status: The initial status of the check,
                         must be one of unknown, passing, warning, or critical.
    :param check_service: The service that the check is performed against.
    :param check_id: Unique identifier for the service.
    :param check_notes: An opaque field that is meant to hold human-readable text.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.catalog_register node='node1' address='192.168.1.1'
            service='redis' service_address='127.0.0.1' service_port='8080'
            service_id='redis_server1'
 
 
 
consul.catalog_service:
 
    Information about the registered service.
 
    :param consul_url: The Consul server URL.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param tag: Filter returned services with tag parameter.
    :return: Information about the requested service.
 
    CLI Example:
 
        salt '*' consul.catalog_service service='redis'
 
 
 
consul.catalog_services:
 
    Return list of available services rom catalog.
 
    :param consul_url: The Consul server URL.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: The list of available services.
 
    CLI Example:
 
        salt '*' consul.catalog_services
 
 
 
consul.delete:
 
    Delete values from Consul
 
    :param consul_url: The Consul server URL.
    :param key: The key to use as the starting point for the list.
    :param recurse: Delete values recursively beginning at the value of key.
    :param cas: This flag is used to turn the DELETE into
                a Check-And-Set operation.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.delete key='web'
 
        salt '*' consul.delete key='web' recurse='True'
 
 
 
consul.event_fire:
 
    List the ACL tokens.
 
    :param consul_url: The Consul server URL.
    :param name: The name of the event to fire.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param node: Filter by node name.
    :param service: Filter by service name.
    :param tag: Filter by tag name.
    :return: List of ACLs
 
    CLI Example:
 
        salt '*' consul.event_fire name='deploy'
 
 
 
consul.event_list:
 
    List the recent events.
 
    :param consul_url: The Consul server URL.
    :param name: The name of the event to fire.
    :return: List of ACLs
 
    CLI Example:
 
        salt '*' consul.event_list
 
 
 
consul.get:
 
    Get key from Consul
 
    :param consul_url: The Consul server URL.
    :param key: The key to use as the starting point for the list.
    :param recurse: Return values recursively beginning at the value of key.
    :param decode: By default values are stored as Base64 encoded values,
                   decode will return the whole key with the value decoded.
    :param raw: Simply return the decoded value of the key.
    :return: The keys in Consul.
 
    CLI Example:
 
        salt '*' consul.get key='web/key1'
 
        salt '*' consul.list key='web' recurse='True
 
        salt '*' consul.list key='web' recurse='True' decode='True'
 
    By default values stored in Consul are base64 encoded, passing the
    decode option will show them as the decoded values.
 
        salt '*' consul.list key='web' recurse='True' decode='True' raw='True'
 
    By default Consult will return other information about the key, the raw
    option will return only the raw value.
 
 
 
consul.health_checks:
 
    Health information about the registered service.
 
    :param consul_url: The Consul server URL.
    :param service: The service to request health information about.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: Health information about the requested node.
 
    CLI Example:
 
        salt '*' consul.health_checks service='redis1'
 
 
 
consul.health_node:
 
    Health information about the registered node.
 
    :param consul_url: The Consul server URL.
    :param node: The node to request health information about.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: Health information about the requested node.
 
    CLI Example:
 
        salt '*' consul.health_node node='node1'
 
 
 
consul.health_service:
 
    Health information about the registered service.
 
    :param consul_url: The Consul server URL.
    :param service: The service to request health information about.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param tag: Filter returned services with tag parameter.
    :param passing: Filter results to only nodes with all
                    checks in the passing state.
    :return: Health information about the requested node.
 
    CLI Example:
 
        salt '*' consul.health_service service='redis1'
 
        salt '*' consul.health_service service='redis1' passing='True'
 
 
 
consul.health_state:
 
    Returns the checks in the state provided on the path.
 
    :param consul_url: The Consul server URL.
    :param state: The state to show checks for. The supported states
                  are any, unknown, passing, warning, or critical.
                  The any state is a wildcard that can be used to
                  return all checks.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: The checks in the provided state.
 
    CLI Example:
 
        salt '*' consul.health_state state='redis1'
 
        salt '*' consul.health_state service='redis1' passing='True'
 
 
 
consul.list:
 
    List keys in Consul
 
    :param consul_url: The Consul server URL.
    :param key: The key to use as the starting point for the list.
    :return: The list of keys.
 
    CLI Example:
 
        salt '*' consul.list
 
        salt '*' consul.list key='web'
 
 
 
consul.put:
 
    Put values into Consul
 
    :param consul_url: The Consul server URL.
    :param key: The key to use as the starting point for the list.
    :param value: The value to set the key to.
    :param flags: This can be used to specify an unsigned value
                  between 0 and 2^64-1. Clients can choose to use
                  this however makes sense for their application.
    :param cas: This flag is used to turn the PUT into a
                Check-And-Set operation.
    :param acquire: This flag is used to turn the PUT into a
                    lock acquisition operation.
    :param release: This flag is used to turn the PUT into a
                    lock release operation.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.put key='web/key1' value="Hello there"
 
        salt '*' consul.put key='web/key1' value="Hello there"
                                acquire='d5d371f4-c380-5280-12fd-8810be175592'
 
        salt '*' consul.put key='web/key1' value="Hello there"
                                release='d5d371f4-c380-5280-12fd-8810be175592'
 
 
 
consul.session_create:
 
    Used to create a session.
 
    :param consul_url: The Consul server URL.
    :param lockdelay: Duration string using a "s" suffix for seconds.
                      The default is 15s.
    :param node: Must refer to a node that is already registered,
                 if specified. By default, the agent's own node
                 name is used.
    :param name: A human-readable name for the session
    :param checks: A list of associated health checks. It is highly
                   recommended that, if you override this list, you
                   include the default "serfHealth".
    :param behavior: Can be set to either release or delete. This controls
                     the behavior when a session is invalidated. By default,
                     this is release, causing any locks that are held to be
                     released. Changing this to delete causes any locks that
                     are held to be deleted. delete is useful for creating
                     ephemeral key/value entries.
    :param ttl: Session is invalidated if it is not renewed before
                the TTL expires
    :return: Boolean and message indicating success or failure.
 
    CLI Example:
 
        salt '*' consul.session_create node='node1' name='my-session'
                behavior='delete' ttl='3600s'
 
 
 
consul.session_destroy:
 
    Destroy session
 
    :param consul_url: The Consul server URL.
    :param session: The ID of the session to destroy.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.session_destroy session='c1c4d223-91cb-3d1f-1ee8-f2af9e7b6716'
 
 
 
consul.session_info:
 
    Information about a session
 
    :param consul_url: The Consul server URL.
    :param session: The ID of the session to return information about.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :return: Boolean & message of success or failure.
 
    CLI Example:
 
        salt '*' consul.session_info session='c1c4d223-91cb-3d1f-1ee8-f2af9e7b6716'
 
 
 
consul.session_list:
 
    Used to list sessions.
 
    :param consul_url: The Consul server URL.
    :param dc: By default, the datacenter of the agent is queried;
               however, the dc can be provided using the "dc" parameter.
    :param return_list: By default, all information about the sessions is
                        returned, using the return_list parameter will return
                        a list of session IDs.
    :return: A list of all available sessions.
 
    CLI Example:
 
        salt '*' consul.session_list
 
 
 
consul.status_leader:
 
    Returns the current Raft leader
 
    :param consul_url: The Consul server URL.
    :return: The address of the Raft leader.
 
    CLI Example:
 
        salt '*' consul.status_leader
 
 
 
consul.status_peers:
 
    Returns the current Raft peer set
 
    :param consul_url: The Consul server URL.
    :return: Retrieves the Raft peers for the
             datacenter in which the the agent is running.
 
    CLI Example:
 
        salt '*' consul.status_peers
 
 
 
container_resource.cache_file:
 
    Wrapper for cp.cache_file which raises an error if the file was unable to
    be cached.
 
    CLI Example:
 
        salt myminion container_resource.cache_file salt://foo/bar/baz.txt
 
 
container_resource.copy_to:
 
    Common logic for copying files to containers
 
    path
        path to the container parent (for LXC only)
        default: /var/lib/lxc (system default)
 
    CLI Example:
 
        salt myminion container_resource.copy_to mycontainer /local/file/path /container/file/path container_type=docker exec_driver=nsenter
 
 
container_resource.run:
 
    Common logic for running shell commands in containers
 
    path
        path to the container parent (for LXC only)
        default: /var/lib/lxc (system default)
 
    CLI Example:
 
        salt myminion container_resource.run mycontainer 'ps aux' container_type=docker exec_driver=nsenter output=stdout
 
 
cp.cache_dir:
 
    Download and cache everything under a directory from the master
 
 
    include_pat : None
        Glob or regex to narrow down the files cached from the given path. If
        matching with a regex, the regex must be prefixed with ``E@``,
        otherwise the expression will be interpreted as a glob.
 
        New in version 2014.7.0
 
    exclude_pat : None
        Glob or regex to exclude certain files from being cached from the given
        path. If matching with a regex, the regex must be prefixed with ``E@``,
        otherwise the expression will be interpreted as a glob.
 
        Note:
 
            If used with ``include_pat``, files matching this pattern will be
            excluded from the subset of files defined by ``include_pat``.
 
        New in version 2014.7.0
 
 
    CLI Examples:
 
        salt '*' cp.cache_dir salt://path/to/dir
        salt '*' cp.cache_dir salt://path/to/dir include_pat='E@*.py$'
 
 
cp.cache_file:
 
    Used to cache a single file on the salt-minion
    Returns the location of the new cached file on the minion
 
    CLI Example:
 
        salt '*' cp.cache_file salt://path/to/file
 
 
cp.cache_files:
 
    Used to gather many files from the master, the gathered files will be
    saved in the minion cachedir reflective to the paths retrieved from the
    master.
 
    CLI Example:
 
        salt '*' cp.cache_files salt://pathto/file1,salt://pathto/file1
 
 
cp.cache_local_file:
 
    Cache a local file on the minion in the localfiles cache
 
    CLI Example:
 
        salt '*' cp.cache_local_file /etc/hosts
 
 
cp.cache_master:
 
    Retrieve all of the files on the master and cache them locally
 
    CLI Example:
 
        salt '*' cp.cache_master
 
 
cp.get_dir:
 
    Used to recursively copy a directory from the salt master
 
    CLI Example:
 
        salt '*' cp.get_dir salt://path/to/dir/ /minion/dest
 
    get_dir supports the same template and gzip arguments as get_file.
 
 
cp.get_file:
 
    Used to get a single file from the salt master
 
    CLI Example:
 
        salt '*' cp.get_file salt://path/to/file /minion/dest
 
    Template rendering can be enabled on both the source and destination file
    names like so:
 
        salt '*' cp.get_file "salt://{{grains.os}}/vimrc" /etc/vimrc template=jinja
 
    This example would instruct all Salt minions to download the vimrc from a
    directory with the same name as their os grain and copy it to /etc/vimrc
 
    For larger files, the cp.get_file module also supports gzip compression.
    Because gzip is CPU-intensive, this should only be used in scenarios where
    the compression ratio is very high (e.g. pretty-printed JSON or YAML
    files).
 
    Use the *gzip* named argument to enable it.  Valid values are 1..9, where 1
    is the lightest compression and 9 the heaviest.  1 uses the least CPU on
    the master (and minion), 9 uses the most.
 
 
cp.get_file_str:
 
    Return the contents of a file from a URL
 
    CLI Example:
 
        salt '*' cp.get_file_str salt://my/file
 
 
cp.get_template:
 
    Render a file as a template before setting it down.
    Warning, order is not the same as in fileclient.cp for
    non breaking old API.
 
    CLI Example:
 
        salt '*' cp.get_template salt://path/to/template /minion/dest
 
 
cp.get_url:
 
    Used to get a single file from a URL.
 
    The default behaviuor is to write the fetched file to the given
    destination path. To simply return the text contents instead, set destination to
    None.
 
    CLI Example:
 
        salt '*' cp.get_url salt://my/file /tmp/mine
        salt '*' cp.get_url http://www.slashdot.org /tmp/index.html
 
 
cp.hash_file:
 
    Return the hash of a file, to get the hash of a file on the
    salt master file server prepend the path with salt://<file on server>
    otherwise, prepend the file with / for a local file.
 
    CLI Example:
 
        salt '*' cp.hash_file salt://path/to/file
 
 
cp.is_cached:
 
    Return a boolean if the given path on the master has been cached on the
    minion
 
    CLI Example:
 
        salt '*' cp.is_cached salt://path/to/file
 
 
cp.list_master:
 
    List all of the files stored on the master
 
    CLI Example:
 
        salt '*' cp.list_master
 
 
cp.list_master_dirs:
 
    List all of the directories stored on the master
 
    CLI Example:
 
        salt '*' cp.list_master_dirs
 
 
cp.list_master_symlinks:
 
    List all of the symlinks stored on the master
 
    CLI Example:
 
        salt '*' cp.list_master_symlinks
 
 
cp.list_minion:
 
    List all of the files cached on the minion
 
    CLI Example:
 
        salt '*' cp.list_minion
 
 
cp.list_states:
 
    List all of the available state modules in an environment
 
    CLI Example:
 
        salt '*' cp.list_states
 
 
cp.push:
 
    Push a file from the minion up to the master, the file will be saved to
    the salt master in the master's minion files cachedir
    (defaults to ``/var/cache/salt/master/minions/minion-id/files``)
 
    Since this feature allows a minion to push a file up to the master server
    it is disabled by default for security purposes. To enable, set
    ``file_recv`` to ``True`` in the master configuration file, and restart the
    master.
 
    keep_symlinks
        Keep the path value without resolving its canonical form
 
    upload_path
        Provide a different path inside the master's minion files cachedir
 
    CLI Example:
 
        salt '*' cp.push /etc/fstab
        salt '*' cp.push /etc/system-release keep_symlinks=True
        salt '*' cp.push /etc/fstab upload_path='/new/path/fstab'
 
 
cp.push_dir:
 
    Push a directory from the minion up to the master, the files will be saved
    to the salt master in the master's minion files cachedir (defaults to
    ``/var/cache/salt/master/minions/minion-id/files``).  It also has a glob
    for matching specific files using globbing.
 
    New in version 2014.7.0
 
    Since this feature allows a minion to push files up to the master server it
    is disabled by default for security purposes. To enable, set ``file_recv``
    to ``True`` in the master configuration file, and restart the master.
 
    upload_path
        Provide a different path and directory name inside the master's minion
        files cachedir
 
    CLI Example:
 
        salt '*' cp.push /usr/lib/mysql
        salt '*' cp.push /usr/lib/mysql upload_path='/newmysql/path'
        salt '*' cp.push_dir /etc/modprobe.d/ glob='*.conf'
 
 
cp.recv:
 
    Used with salt-cp, pass the files dict, and the destination.
 
    This function receives small fast copy files from the master via salt-cp.
    It does not work via the CLI.
 
 
cron.list_tab:
 
    Return the contents of the specified user's crontab
 
    CLI Example:
 
        salt '*' cron.list_tab root
 
 
cron.ls:
 
This function is an alias of ``list_tab``.
 
    Return the contents of the specified user's crontab
 
    CLI Example:
 
        salt '*' cron.list_tab root
 
 
cron.raw_cron:
 
    Return the contents of the user's crontab
 
    CLI Example:
 
        salt '*' cron.raw_cron root
 
 
cron.rm:
 
This function is an alias of ``rm_job``.
 
    Remove a cron job for a specified user. If any of the day/time params are
    specified, the job will only be removed if the specified params match.
 
    CLI Example:
 
        salt '*' cron.rm_job root /usr/local/weekly
        salt '*' cron.rm_job root /usr/bin/foo dayweek=1
 
 
cron.rm_env:
 
    Remove cron environment variable for a specified user.
 
    CLI Example:
 
        salt '*' cron.rm_env root MAILTO
 
 
cron.rm_job:
 
    Remove a cron job for a specified user. If any of the day/time params are
    specified, the job will only be removed if the specified params match.
 
    CLI Example:
 
        salt '*' cron.rm_job root /usr/local/weekly
        salt '*' cron.rm_job root /usr/bin/foo dayweek=1
 
 
cron.rm_special:
 
    Remove a special cron job for a specified user.
 
    CLI Example:
 
        salt '*' cron.rm_job root @hourly /usr/bin/foo
 
 
cron.set_env:
 
    Set up an environment variable in the crontab.
 
    CLI Example:
 
        salt '*' cron.set_env root MAILTO user@example.com
 
 
cron.set_job:
 
    Sets a cron job up for a specified user.
 
    CLI Example:
 
        salt '*' cron.set_job root '*' '*' '*' '*' 1 /usr/local/weekly
 
 
cron.set_special:
 
    Set up a special command in the crontab.
 
    CLI Example:
 
        salt '*' cron.set_special root @hourly 'echo foobar'
 
 
cron.write_cron_file:
 
    Writes the contents of a file to a user's crontab
 
    CLI Example:
 
        salt '*' cron.write_cron_file root /tmp/new_cron
 
 
cron.write_cron_file_verbose:
 
    Writes the contents of a file to a user's crontab and return error message on error
 
    CLI Example:
 
        salt '*' cron.write_cron_file_verbose root /tmp/new_cron
 
 
data.cas:
 
    Check and set a value in the minion datastore
 
    CLI Example:
 
        salt '*' data.cas <key> <value> <old_value>
 
 
data.clear:
 
    Clear out all of the data in the minion datastore, this function is
    destructive!
 
    CLI Example:
 
        salt '*' data.clear
 
 
data.dump:
 
    Replace the entire datastore with a passed data structure
 
    CLI Example:
 
        salt '*' data.dump '{'eggs': 'spam'}'
 
 
data.get:
 
    Get a (list of) value(s) from the minion datastore
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' data.get <key(s)>
 
 
data.getval:
 
    Get a value from the minion datastore
 
    .. deprecated:: Boron
         Use ``get`` instead
 
    CLI Example:
 
        salt '*' data.getval <key>
 
 
data.getvals:
 
    Get values from the minion datastore
 
    .. deprecated:: Boron
         Use ``get`` instead
 
    CLI Example:
 
        salt '*' data.getvals <key> [<key> ...]
 
 
data.has_key:
 
    Check if key is in the minion datastore
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' data.has_key <mykey>
 
 
data.items:
 
    Get items from the minion datastore
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' data.items
 
 
data.keys:
 
    Get all keys from the minion datastore
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' data.keys
 
 
data.load:
 
    Return all of the data in the minion datastore
 
    CLI Example:
 
        salt '*' data.load
 
 
data.pop:
 
    Pop (return & delete) a value from the minion datastore
 
    New in version 2015.5.2
 
    CLI Example:
 
        salt '*' data.pop <key> "there was no val"
 
 
data.update:
 
    Update a key with a value in the minion datastore
 
    CLI Example:
 
        salt '*' data.update <key> <value>
 
 
data.values:
 
    Get values from the minion datastore
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' data.values
 
 
defaults.get:
 
    defaults.get is used much like pillar.get except that it will read
    a default value for a pillar from defaults.json or defaults.yaml
    files that are stored in the root of a salt formula.
 
    CLI Example:
 
        salt '*' defaults.get core:users:root
 
    The defaults is computed from pillar key. The first entry is considered as
    the formula namespace.
 
    For example, querying ``core:users:root`` will try to load
    ``salt://core/defaults.yaml`` and ``salt://core/defaults.json``.
 
 
devmap.multipath_flush:
 
    Device-Mapper Multipath flush
 
    CLI Example:
 
        salt '*' devmap.multipath_flush mpath1
 
 
devmap.multipath_list:
 
    Device-Mapper Multipath list
 
    CLI Example:
 
        salt '*' devmap.multipath_list
 
 
disk.blkid:
 
    Return block device attributes: UUID, LABEL, etc. This function only works
    on systems where blkid is available.
 
    CLI Example:
 
        salt '*' disk.blkid
        salt '*' disk.blkid /dev/sda
 
 
disk.inodeusage:
 
    Return inode usage information for volumes mounted on this minion
 
    CLI Example:
 
        salt '*' disk.inodeusage
 
 
disk.percent:
 
    Return partition information for volumes mounted on this minion
 
    CLI Example:
 
        salt '*' disk.percent /var
 
 
disk.usage:
 
    Return usage information for volumes mounted on this minion
 
    CLI Example:
 
        salt '*' disk.usage
 
 
django.collectstatic:
 
    Collect static files from each of your applications into a single location
    that can easily be served in production.
 
    CLI Example:
 
        salt '*' django.collectstatic <settings_module>
 
 
django.command:
 
    Run arbitrary django management command
 
    CLI Example:
 
        salt '*' django.command <settings_module> <command>
 
 
django.createsuperuser:
 
    Create a super user for the database.
    This function defaults to use the ``--noinput`` flag which prevents the
    creation of a password for the superuser.
 
    CLI Example:
 
        salt '*' django.createsuperuser <settings_module> user user@example.com
 
 
django.loaddata:
 
    Load fixture data
 
    Fixtures:
        comma separated list of fixtures to load
 
    CLI Example:
 
        salt '*' django.loaddata <settings_module> <comma delimited list of fixtures>
 
 
 
django.syncdb:
 
    Run syncdb
 
    Execute the Django-Admin syncdb command, if South is available on the
    minion the ``migrate`` option can be passed as ``True`` calling the
    migrations to run after the syncdb completes
 
    CLI Example:
 
        salt '*' django.syncdb <settings_module>
 
 
dnsmasq.fullversion:
 
    Shows installed version of dnsmasq and compile options.
 
    CLI Example:
 
        salt '*' dnsmasq.version
 
 
dnsmasq.get_config:
 
    Dumps all options from the config file.
 
    CLI Examples:
 
        salt '*' dnsmasq.get_config
        salt '*' dnsmasq.get_config file=/etc/dnsmasq.conf
 
 
dnsmasq.set_config:
 
    Sets a value or a set of values in the specified file. By default, if
    conf-dir is configured in this file, salt will attempt to set the option
    in any file inside the conf-dir where it has already been enabled. If it
    does not find it inside any files, it will append it to the main config
    file. Setting follow to False will turn off this behavior.
 
    If a config option currently appears multiple times (such as dhcp-host,
    which is specified at least once per host), the new option will be added
    to the end of the main config file (and not to any includes). If you need
    an option added to a specific include file, specify it as the config_file.
 
    CLI Examples:
 
        salt '*' dnsmasq.set_config domain=mydomain.com
        salt '*' dnsmasq.set_config follow=False domain=mydomain.com
        salt '*' dnsmasq.set_config file=/etc/dnsmasq.conf domain=mydomain.com
 
 
dnsmasq.version:
 
    Shows installed version of dnsmasq.
 
    CLI Example:
 
        salt '*' dnsmasq.version
 
 
dnsutil.A:
 
    Return the A record(s) for `host`.
 
    Always returns a list.
 
    CLI Example:
 
        salt ns1 dnsutil.A www.google.com
 
 
dnsutil.AAAA:
 
    Return the AAAA record(s) for `host`.
 
    Always returns a list.
 
    New in version 2014.7.5
 
    CLI Example:
 
        salt ns1 dnsutil.AAAA www.google.com
 
 
dnsutil.MX:
 
    Return a list of lists for the MX of ``domain``.
 
    If the 'resolve' argument is True, resolve IPs for the servers.
 
    It's limited to one IP, because although in practice it's very rarely a
    round robin, it is an acceptable configuration and pulling just one IP lets
    the data be similar to the non-resolved version. If you think an MX has
    multiple IPs, don't use the resolver here, resolve them in a separate step.
 
    CLI Example:
 
        salt ns1 dig.MX google.com
 
 
dnsutil.NS:
 
    Return a list of IPs of the nameservers for ``domain``
 
    If 'resolve' is False, don't resolve names.
 
    CLI Example:
 
        salt ns1 dig.NS google.com
 
 
 
dnsutil.SPF:
 
    Return the allowed IPv4 ranges in the SPF record for ``domain``.
 
    If record is ``SPF`` and the SPF record is empty, the TXT record will be
    searched automatically. If you know the domain uses TXT and not SPF,
    specifying that will save a lookup.
 
    CLI Example:
 
        salt ns1 dig.SPF google.com
 
 
dnsutil.check_ip:
 
    Check that string ip_addr is a valid IP
 
    CLI Example:
 
        salt ns1 dig.check_ip 127.0.0.1
 
 
dnsutil.hosts_append:
 
    Append a single line to the /etc/hosts file.
 
    CLI Example:
 
        salt '*' dnsutil.hosts_append /etc/hosts 127.0.0.1 ad1.yuk.co,ad2.yuk.co
 
 
dnsutil.hosts_remove:
 
    Remove a host from the /etc/hosts file. If doing so will leave a line
    containing only an IP address, then the line will be deleted. This function
    will leave comments and blank lines intact.
 
    CLI Examples:
 
        salt '*' dnsutil.hosts_remove /etc/hosts ad1.yuk.co
        salt '*' dnsutil.hosts_remove /etc/hosts ad2.yuk.co,ad1.yuk.co
 
 
dnsutil.parse_hosts:
 
    Parse /etc/hosts file.
 
    CLI Example:
 
        salt '*' dnsutil.parse_hosts
 
 
dnsutil.parse_zone:
 
    Parses a zone file. Can be passed raw zone data on the API level.
 
    CLI Example:
 
        salt ns1 dnsutil.parse_zone /var/lib/named/example.com.zone
 
 
dnsutil.serial:
 
    Return, store and update a dns serial for your zone files.
 
    zone: a keywork for a specific zone
 
    update: store an updated version of the serial in a grain
 
    If ``update`` is False, the function will retrieve an existing serial or
    return the current date if no serial is stored. Nothing will be stored
 
    If ``update`` is True, the function will set the serial to the current date
    if none exist or if the existing serial is for a previous date. If a serial
    for greater than the current date is already stored, the function will
    increment it.
 
    This module stores the serial in a grain, you can explicitly set the
    stored value as a grain named ``dnsserial_<zone_name>``.
 
    CLI Example:
 
        salt ns1 dnsutil.serial example.com
 
 
drbd.overview:
 
    Show status of the DRBD devices
 
    CLI Example:
 
        salt '*' drbd.overview
 
 
elasticsearch.alias_create:
 
    Create an alias for a specific index/indices
 
    CLI example::
 
        salt myminion elasticsearch.alias_create testindex_v1 testindex
 
 
elasticsearch.alias_delete:
 
    Delete an alias of an index
 
    CLI example::
 
        salt myminion elasticsearch.alias_delete testindex_v1 testindex
 
 
elasticsearch.alias_exists:
 
    Return a boolean indicating whether given alias exists
 
    CLI example::
 
        salt myminion elasticsearch.alias_exists testindex
 
 
elasticsearch.alias_get:
 
    Check for the existence of an alias and if it exists, return it
 
    CLI example::
 
        salt myminion elasticsearch.alias_get testindex
 
 
elasticsearch.document_create:
 
    Create a document in a specified index
 
    CLI example::
 
        salt myminion elasticsearch.document_create testindex doctype1 '{}'
 
 
elasticsearch.document_delete:
 
    Delete a document from an index
 
    CLI example::
 
        salt myminion elasticsearch.document_delete testindex doctype1 AUx-384m0Bug_8U80wQZ
 
 
elasticsearch.document_exists:
 
    Return a boolean indicating whether given document exists
 
    CLI example::
 
        salt myminion elasticsearch.document_exists testindex AUx-384m0Bug_8U80wQZ
 
 
elasticsearch.document_get:
 
    Check for the existence of a document and if it exists, return it
 
    CLI example::
 
        salt myminion elasticsearch.document_get testindex AUx-384m0Bug_8U80wQZ
 
 
elasticsearch.index_create:
 
    Create an index
 
    CLI example::
 
        salt myminion elasticsearch.index_create testindex
 
 
elasticsearch.index_delete:
 
    Delete an index
 
    CLI example::
 
        salt myminion elasticsearch.index_delete testindex
 
 
elasticsearch.index_exists:
 
    Return a boolean indicating whether given index exists
 
    CLI example::
 
        salt myminion elasticsearch.index_exists testindex
 
 
elasticsearch.index_get:
 
    Check for the existence of an index and if it exists, return it
 
    CLI example::
 
        salt myminion elasticsearch.index_get testindex
 
 
elasticsearch.index_template_create:
 
    Create an index template
 
    CLI example::
 
        salt myminion elasticsearch.index_template_create testindex_templ '{ "template": "logstash-*", "order": 1, "settings": { "number_of_shards": 1 } }'
 
 
elasticsearch.index_template_delete:
 
    Delete an index template (type) along with its data
 
    CLI example::
 
        salt myminion elasticsearch.index_template_delete testindex_templ user
 
 
elasticsearch.index_template_exists:
 
    Return a boolean indicating whether given index template exists
 
    CLI example::
 
        salt myminion elasticsearch.index_template_exists testindex_templ
 
 
elasticsearch.index_template_get:
 
    Retrieve template definition of index or index/type
 
    CLI example::
 
        salt myminion elasticsearch.index_template_get testindex_templ user
 
 
elasticsearch.mapping_create:
 
    Create a mapping in a given index
 
    CLI example::
 
        salt myminion elasticsearch.mapping_create testindex user '{ "user" : { "properties" : { "message" : {"type" : "string", "store" : true } } } }'
 
 
elasticsearch.mapping_delete:
 
    Delete a mapping (type) along with its data
 
    CLI example::
 
        salt myminion elasticsearch.mapping_delete testindex user
 
 
elasticsearch.mapping_get:
 
    Retrieve mapping definition of index or index/type
 
    CLI example::
 
        salt myminion elasticsearch.mapping_get testindex user
 
 
environ.get:
 
    Get a single salt process environment variable.
 
    key
        String used as the key for environment lookup.
 
    default
        If the key is not found in the environment, return this value.
        Default: ''
 
 
    CLI Example:
 
        salt '*' environ.get foo
        salt '*' environ.get baz default=False
 
 
environ.has_value:
 
    Determine whether the key exists in the current salt process
    environment dictionary. Optionally compare the current value
    of the environment against the supplied value string.
 
    key
        Must be a string. Used as key for environment lookup.
 
    value:
        Optional. If key exists in the environment, compare the
        current value with this value. Return True if they are equal.
 
    CLI Example:
 
        salt '*' environ.has_value foo
 
 
environ.item:
 
    Get one or more salt process environment variables.
    Returns a dict.
 
    keys
        Either a string or a list of strings that will be used as the
        keys for environment lookup.
 
    default
        If the key is not found in the environment, return this value.
        Default: ''
 
    CLI Example:
 
        salt '*' environ.item foo
        salt '*' environ.item '[foo, baz]' default=None
 
 
environ.items:
 
    Return a dict of the entire environment set for the salt process
 
    CLI Example:
 
        salt '*' environ.items
 
 
environ.setenv:
 
    Set multiple salt process environment variables from a dict.
    Returns a dict.
 
    environ
        Must be a dict. The top-level keys of the dict are the names
        of the environment variables to set. Each key's value must be
        a string or False. Refer to the 'false_unsets' parameter for
        behavior when a value set to False.
 
    false_unsets
        If a key's value is False and false_unsets is True, then the
        key will be removed from the salt processes environment dict
        entirely. If a key's value is False and false_unsets is not
        True, then the key's value will be set to an empty string.
        Default: False
 
    clear_all
        USE WITH CAUTION! This option can unset environment variables
        needed for salt to function properly.
        If clear_all is True, then any environment variables not
        defined in the environ dict will be deleted.
        Default: False
 
    update_minion
        If True, apply these environ changes to the main salt-minion
        process. If False, the environ changes will only affect the
        current salt subprocess.
        Default: False
 
 
    CLI Example:
 
        salt '*' environ.setenv '{"foo": "bar", "baz": "quux"}'
        salt '*' environ.setenv '{"a": "b", "c": False}' false_unsets=True
 
 
environ.setval:
 
    Set a single salt process environment variable. Returns True
    on success.
 
    key
        The environment key to set. Must be a string.
 
    val
        The value to set. Must be a string or False. Refer to the
        'false_unsets' parameter for behavior when set to False.
 
    false_unsets
        If val is False and false_unsets is True, then the key will be
        removed from the salt processes environment dict entirely.
        If val is False and false_unsets is not True, then the key's
        value will be set to an empty string.
        Default: False.
 
 
    CLI Example:
 
        salt '*' environ.setval foo bar
        salt '*' environ.setval baz val=False false_unsets=True
 
 
etcd.get:
 
    New in version 2014.7.0
 
    Get a value from etcd, by direct path
 
    CLI Examples:
 
        salt myminion etcd.get /path/to/key
        salt myminion etcd.get /path/to/key profile=my_etcd_config
        salt myminion etcd.get /path/to/key recurse=True profile=my_etcd_config
 
 
etcd.ls:
 
    New in version 2014.7.0
 
    Return all keys and dirs inside a specific path
 
    CLI Example:
 
 
        salt myminion etcd.ls /path/to/dir/
        salt myminion etcd.ls /path/to/dir/ profile=my_etcd_config
 
 
etcd.rm:
 
    New in version 2014.7.0
 
    Delete a key from etcd
 
    CLI Example:
 
 
        salt myminion etcd.rm /path/to/key
        salt myminion etcd.rm /path/to/key profile=my_etcd_config
        salt myminion etcd.rm /path/to/dir recurse=True profile=my_etcd_config
 
 
etcd.set:
 
    New in version 2014.7.0
 
    Set a value in etcd, by direct path
 
    CLI Example:
 
        salt myminion etcd.set /path/to/key value
        salt myminion etcd.set /path/to/key value profile=my_etcd_config
 
 
etcd.tree:
 
    New in version 2014.7.0
 
    Recurse through etcd and return all values
 
    CLI Example:
 
 
        salt myminion etcd.tree
        salt myminion etcd.tree profile=my_etcd_config
        salt myminion etcd.tree /path/to/keys profile=my_etcd_config
 
 
event.fire:
 
    Fire an event on the local minion event bus. Data must be formed as a dict.
 
    CLI Example:
 
        salt '*' event.fire '{"data":"my event data"}' 'tag'
 
 
event.fire_master:
 
    Fire an event off up to the master server
 
    CLI Example:
 
        salt '*' event.fire_master '{"data":"my event data"}' 'tag'
 
 
event.send:
 
    Send an event to the Salt Master
 
    New in version 2014.7.0
 
    :param tag: A tag to give the event.
        Use slashes to create a namespace for related events. E.g.,
        ``myco/build/buildserver1/start``, ``myco/build/buildserver1/success``,
        ``myco/build/buildserver1/failure``.
 
    :param data: A dictionary of data to send in the event.
        This is free-form. Send any data points that are needed for whoever is
        consuming the event. Arguments on the CLI are interpreted as YAML so
        complex data structures are possible.
 
    :param with_env: Include environment variables from the current shell
        environment in the event data as ``environ``.. This is a short-hand for
        working with systems that seed the environment with relevant data such
        as Jenkins.
    :type with_env: Specify ``True`` to include all environment variables, or
        specify a list of strings of variable names to include.
 
    :param with_grains: Include grains from the current minion in the event
        data as ``grains``.
    :type with_grains: Specify ``True`` to include all grains, or specify a
        list of strings of grain names to include.
 
    :param with_pillar: Include Pillar values from the current minion in the
        event data as ``pillar``. Remember Pillar data is often sensitive data
        so be careful. This is useful for passing ephemeral Pillar values
        through an event. Such as passing the ``pillar={}`` kwarg in
        :py:func:`state.sls <salt.modules.state.sls>` from the Master, through
        an event on the Minion, then back to the Master.
    :type with_pillar: Specify ``True`` to include all Pillar values, or
        specify a list of strings of Pillar keys to include. It is a
        best-practice to only specify a relevant subset of Pillar data.
 
    :param kwargs: Any additional keyword arguments passed to this function
        will be interpreted as key-value pairs and included in the event data.
        This provides a convenient alternative to YAML for simple values.
 
    CLI Example:
 
        salt-call event.send myco/mytag foo=Foo bar=Bar
        salt-call event.send 'myco/mytag' '{foo: Foo, bar: Bar}'
 
    A convenient way to allow Jenkins to execute ``salt-call`` is via sudo. The
    following rule in sudoers will allow the ``jenkins`` user to run only the
    following command.
 
    ``/etc/sudoers`` (allow preserving the environment):
 
        jenkins ALL=(ALL) NOPASSWD:SETENV: /usr/bin/salt-call event.send*
 
    Call Jenkins via sudo (preserve the environment):
 
        sudo -E salt-call event.send myco/jenkins/build/success with_env=[BUILD_ID, BUILD_URL, GIT_BRANCH, GIT_COMMIT]
 
 
 
extfs.attributes:
 
    Return attributes from dumpe2fs for a specified device
 
    CLI Example:
 
        salt '*' extfs.attributes /dev/sda1
 
 
extfs.blocks:
 
    Return block and inode info from dumpe2fs for a specified device
 
    CLI Example:
 
        salt '*' extfs.blocks /dev/sda1
 
 
extfs.dump:
 
    Return all contents of dumpe2fs for a specified device
 
    CLI Example:
 
        salt '*' extfs.dump /dev/sda1
 
 
extfs.mkfs:
 
    Create a file system on the specified device
 
    CLI Example:
 
        salt '*' extfs.mkfs /dev/sda1 fs_type=ext4 opts='acl,noexec'
 
    Valid options are:
 
    * **block_size**: 1024, 2048 or 4096
    * **check**: check for bad blocks
    * **direct**: use direct IO
    * **ext_opts**: extended file system options (comma-separated)
    * **fragment_size**: size of fragments
    * **force**: setting force to True will cause mke2fs to specify the -F
      option twice (it is already set once); this is truly dangerous
    * **blocks_per_group**: number of blocks in a block group
    * **number_of_groups**: ext4 option for a virtual block group
    * **bytes_per_inode**: set the bytes/inode ratio
    * **inode_size**: size of the inode
    * **journal**: set to True to create a journal (default on ext3/4)
    * **journal_opts**: options for the fs journal (comma separated)
    * **blocks_file**: read bad blocks from file
    * **label**: label to apply to the file system
    * **reserved**: percentage of blocks reserved for super-user
    * **last_dir**: last mounted directory
    * **test**: set to True to not actually create the file system (mke2fs -n)
    * **number_of_inodes**: override default number of inodes
    * **creator_os**: override "creator operating system" field
    * **opts**: mount options (comma separated)
    * **revision**: set the filesystem revision (default 1)
    * **super**: write superblock and group descriptors only
    * **fs_type**: set the filesystem type (REQUIRED)
    * **usage_type**: how the filesystem is going to be used
    * **uuid**: set the UUID for the file system
 
    See the ``mke2fs(8)`` manpage for a more complete description of these
    options.
 
 
extfs.tune:
 
    Set attributes for the specified device (using tune2fs)
 
    CLI Example:
 
        salt '*' extfs.tune /dev/sda1 force=True label=wildstallyns opts='acl,noexec'
 
    Valid options are:
 
    * **max**: max mount count
    * **count**: mount count
    * **error**: error behavior
    * **extended_opts**: extended options (comma separated)
    * **force**: force, even if there are errors (set to True)
    * **group**: group name or gid that can use the reserved blocks
    * **interval**: interval between checks
    * **journal**: set to True to create a journal (default on ext3/4)
    * **journal_opts**: options for the fs journal (comma separated)
    * **label**: label to apply to the file system
    * **reserved**: percentage of blocks reserved for super-user
    * **last_dir**: last mounted directory
    * **opts**: mount options (comma separated)
    * **feature**: set or clear a feature (comma separated)
    * **mmp_check**: mmp check interval
    * **reserved**: reserved blocks count
    * **quota_opts**: quota options (comma separated)
    * **time**: time last checked
    * **user**: user or uid who can use the reserved blocks
    * **uuid**: set the UUID for the file system
 
    See the ``mke2fs(8)`` manpage for a more complete description of these
    options.
 
 
file.access:
 
    New in version 2014.1.0
 
    Test whether the Salt process has the specified access to the file. One of
    the following modes must be specified:
 
    .. code-block::text
 
        f: Test the existence of the path
        r: Test the readability of the path
        w: Test the writability of the path
        x: Test whether the path can be executed
 
    CLI Example:
 
        salt '*' file.access /path/to/file f
        salt '*' file.access /path/to/file x
 
 
file.append:
 
    New in version 0.9.5
 
    Append text to the end of a file
 
    path
        path to file
 
    `*args`
        strings to append to file
 
    CLI Example:
 
        salt '*' file.append /etc/motd \
                "With all thine offerings thou shalt offer salt." \
                "Salt is what makes things taste bad when it isn't in them."
 
    .. admonition:: Attention
 
        If you need to pass a string to append and that string contains
        an equal sign, you **must** include the argument name, args.
        For example:
 
            salt '*' file.append /etc/motd args='cheese=spam'
 
            salt '*' file.append /etc/motd args="['cheese=spam','spam=cheese']"
 
 
 
file.basename:
 
    Returns the final component of a pathname
 
    New in version 2015.5.0
 
    This can be useful at the CLI but is frequently useful when scripting.
 
        {%- set filename = salt['file.basename'](source_file) %}
 
    CLI Example:
 
        salt '*' file.basename 'test/test.config'
 
 
file.blockreplace:
 
    New in version 2014.1.0
 
    Replace content of a text block in a file, delimited by line markers
 
    A block of content delimited by comments can help you manage several lines
    entries without worrying about old entries removal.
 
    Note:
 
        This function will store two copies of the file in-memory (the original
        version and the edited version) in order to detect changes and only
        edit the targeted file if necessary.
 
    path
        Filesystem path to the file to be edited
 
    marker_start
        The line content identifying a line as the start of the content block.
        Note that the whole line containing this marker will be considered, so
        whitespace or extra content before or after the marker is included in
        final output
 
    marker_end
        The line content identifying a line as the end of the content block.
        Note that the whole line containing this marker will be considered, so
        whitespace or extra content before or after the marker is included in
        final output
 
    content
        The content to be used between the two lines identified by marker_start
        and marker_stop.
 
    append_if_not_found : False
        If markers are not found and set to ``True`` then, the markers and
        content will be appended to the file.
 
    prepend_if_not_found : False
        If markers are not found and set to ``True`` then, the markers and
        content will be prepended to the file.
 
 
    backup
        The file extension to use for a backup of the file if any edit is made.
        Set to ``False`` to skip making a backup.
 
    dry_run
        Don't make any edits to the file.
 
    show_changes
        Output a unified diff of the old file and the new file. If ``False``,
        return a boolean if any changes were made.
 
    CLI Example:
 
        salt '*' file.blockreplace /etc/hosts '#-- start managed zone foobar : DO NOT EDIT --' \
        '#-- end managed zone foobar --' $'10.0.1.1 foo.foobar\n10.0.1.2 bar.foobar' True
 
 
 
file.check_file_meta:
 
    Check for the changes in the file metadata.
 
    CLI Example:
 
        salt '*' file.check_file_meta /etc/httpd/conf.d/httpd.conf salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' root, root, '755' base
 
    Note:
 
        Supported hash types include sha512, sha384, sha256, sha224, sha1, and
        md5.
 
    name
        Path to file destination
 
    sfn
        Template-processed source file contents
 
    source
        URL to file source
 
    source_sum
        File checksum information as a dictionary
 
            {hash_type: md5, hsum: <md5sum>}
 
    user
        Destination file user owner
 
    group
        Destination file group owner
 
    mode
        Destination file permissions mode
 
    saltenv
        Salt environment used to resolve source files
 
    contents
        File contents
 
 
file.check_hash:
 
    Check if a file matches the given hash string
 
    Returns true if the hash matched, otherwise false. Raises ValueError if
    the hash was not formatted correctly.
 
    path
        A file path
    hash
        A string in the form <hash_type>:<hash_value>. For example:
        ``md5:e138491e9d5b97023cea823fe17bac22``
 
    CLI Example:
 
        salt '*' file.check_hash /etc/fstab md5:<md5sum>
 
 
file.check_managed:
 
    Check to see what changes need to be made for a file
 
    CLI Example:
 
        salt '*' file.check_managed /etc/httpd/conf.d/httpd.conf salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' root, root, '755' jinja True None None base
 
 
file.check_managed_changes:
 
    Return a dictionary of what changes need to be made for a file
 
    CLI Example:
 
        salt '*' file.check_managed_changes /etc/httpd/conf.d/httpd.conf salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' root, root, '755' jinja True None None base
 
 
file.check_perms:
 
    Check the permissions on files and chown if needed
 
    CLI Example:
 
        salt '*' file.check_perms /etc/sudoers '{}' root root 400
 
    Changed in version 2014.1.3
        ``follow_symlinks`` option added
 
 
file.chgrp:
 
    Change the group of a file
 
    path
        path to the file or directory
 
    group
        group owner
 
    CLI Example:
 
        salt '*' file.chgrp /etc/passwd root
 
 
file.chown:
 
    Chown a file, pass the file the desired user and group
 
    path
        path to the file or directory
 
    user
        user owner
 
    group
        group owner
 
    CLI Example:
 
        salt '*' file.chown /etc/passwd root root
 
 
file.comment:
 
    .. deprecated:: 0.17.0
       Use :py:func:`~salt.modules.file.replace` instead.
 
    Comment out specified lines in a file
 
    path
        The full path to the file to be edited
    regex
        A regular expression used to find the lines that are to be commented;
        this pattern will be wrapped in parenthesis and will move any
        preceding/trailing ``^`` or ``$`` characters outside the parenthesis
        (e.g., the pattern ``^foo$`` will be rewritten as ``^(foo)$``)
    char : ``#``
        The character to be inserted at the beginning of a line in order to
        comment it out
    backup : ``.bak``
        The file will be backed up before edit with this file extension
 
        Warning:
 
            This backup will be overwritten each time ``sed`` / ``comment`` /
            ``uncomment`` is called. Meaning the backup will only be useful
            after the first invocation.
 
    CLI Example:
 
        salt '*' file.comment /etc/modules pcspkr
 
 
file.comment_line:
 
    Comment or Uncomment a line in a text file.
 
    :param path: string
        The full path to the text file.
 
    :param regex: string
        A regex expression that begins with ``^`` that will find the line you wish
        to comment. Can be as simple as ``^color =``
 
    :param char: string
        The character used to comment a line in the type of file you're referencing.
        Default is ``#``
 
    :param cmnt: boolean
        True to comment the line. False to uncomment the line. Default is True.
 
    :param backup: string
        The file extension to give the backup file. Default is ``.bak``
 
    :return: boolean
        Returns True if successful, False if not
 
    CLI Example:
 
    The following example will comment out the ``pcspkr`` line in the
    ``/etc/modules`` file using the default ``#`` character and create a backup
    file named ``modules.bak``
 
        salt '*' file.comment_line '/etc/modules' '^pcspkr'
 
 
    CLI Example:
 
    The following example will uncomment the ``log_level`` setting in ``minion``
    config file if it is set to either ``warning``, ``info``, or ``debug`` using
    the ``#`` character and create a backup file named ``minion.bk``
 
        salt '*' file.comment_line 'C:\salt\conf\minion' '^log_level: (warning|info|debug)' '#' False '.bk'
 
 
file.contains:
 
    .. deprecated:: 0.17.0
       Use :func:`search` instead.
 
    Return ``True`` if the file at ``path`` contains ``text``
 
    CLI Example:
 
        salt '*' file.contains /etc/crontab 'mymaintenance.sh'
 
 
file.contains_glob:
 
    .. deprecated:: 0.17.0
       Use :func:`search` instead.
 
    Return ``True`` if the given glob matches a string in the named file
 
    CLI Example:
 
        salt '*' file.contains_glob /etc/foobar '*cheese*'
 
 
file.contains_regex:
 
    .. deprecated:: 0.17.0
       Use :func:`search` instead.
 
    Return True if the given regular expression matches on any line in the text
    of a given file.
 
    If the lchar argument (leading char) is specified, it
    will strip `lchar` from the left side of each line before trying to match
 
    CLI Example:
 
        salt '*' file.contains_regex /etc/crontab
 
 
file.contains_regex_multiline:
 
    .. deprecated:: 0.17.0
       Use :func:`search` instead.
 
    Return True if the given regular expression matches anything in the text
    of a given file
 
    Traverses multiple lines at a time, via the salt BufferedReader (reads in
    chunks)
 
    CLI Example:
 
        salt '*' file.contains_regex_multiline /etc/crontab '^maint'
 
 
file.copy:
 
    Copy a file or directory from source to dst
 
    In order to copy a directory, the recurse flag is required, and
    will by default overwrite files in the destination with the same path,
    and retain all other existing files. (similar to cp -r on unix)
 
    remove_existing will remove all files in the target directory,
    and then copy files from the source.
 
    CLI Example:
 
        salt '*' file.copy /path/to/src /path/to/dst
        salt '*' file.copy /path/to/src_dir /path/to/dst_dir recurse=True
        salt '*' file.copy /path/to/src_dir /path/to/dst_dir recurse=True remove_existing=True
 
 
 
file.delete_backup:
 
    New in version 0.17.0
 
    Delete a previous version of a file that was backed up using Salt's
    :doc:`file state backup </ref/states/backup_mode>` system.
 
    path
        The path on the minion to check for backups
    backup_id
        The numeric id for the backup you wish to delete, as found using
        :mod:`file.list_backups <salt.modules.file.list_backups>`
 
    CLI Example:
 
        salt '*' file.restore_backup /foo/bar/baz.txt 0
 
 
file.directory_exists:
 
    Tests to see if path is a valid directory.  Returns True/False.
 
    CLI Example:
 
        salt '*' file.directory_exists /etc
 
 
 
file.dirname:
 
    Returns the directory component of a pathname
 
    New in version 2015.5.0
 
    This can be useful at the CLI but is frequently useful when scripting.
 
        {%- from salt['file.dirname'](tpldir) + '/vars.jinja' import parent_vars %}
 
    CLI Example:
 
        salt '*' file.dirname 'test/path/filename.config'
 
 
file.diskusage:
 
    Recursively calculate disk usage of path and return it
    in bytes
 
    CLI Example:
 
        salt '*' file.diskusage /path/to/check
 
 
file.extract_hash:
 
    This routine is called from the :mod:`file.managed
    <salt.states.file.managed>` state to pull a hash from a remote file.
    Regular expressions are used line by line on the ``source_hash`` file, to
    find a potential candidate of the indicated hash type.  This avoids many
    problems of arbitrary file lay out rules. It specifically permits pulling
    hash codes from debian ``*.dsc`` files.
 
    For example:
 
        openerp_7.0-latest-1.tar.gz:
          file.managed:
            - name: /tmp/openerp_7.0-20121227-075624-1_all.deb
            - source: http://nightly.openerp.com/7.0/nightly/deb/openerp_7.0-20121227-075624-1.tar.gz
            - source_hash: http://nightly.openerp.com/7.0/nightly/deb/openerp_7.0-20121227-075624-1.dsc
 
    CLI Example:
 
        salt '*' file.extract_hash /etc/foo sha512 /path/to/hash/file
 
 
file.file_exists:
 
    Tests to see if path is a valid file.  Returns True/False.
 
    CLI Example:
 
        salt '*' file.file_exists /etc/passwd
 
 
 
file.find:
 
    Approximate the Unix ``find(1)`` command and return a list of paths that
    meet the specified criteria.
 
    The options include match criteria:
 
        name    = path-glob                 # case sensitive
        iname   = path-glob                 # case insensitive
        regex   = path-regex                # case sensitive
        iregex  = path-regex                # case insensitive
        type    = file-types                # match any listed type
        user    = users                     # match any listed user
        group   = groups                    # match any listed group
        size    = [+-]number[size-unit]     # default unit = byte
        mtime   = interval                  # modified since date
        grep    = regex                     # search file contents
 
    and/or actions:
 
        delete [= file-types]               # default type = 'f'
        exec    = command [arg ...]         # where {} is replaced by pathname
        print  [= print-opts]
 
    and/or depth criteria:
 
        maxdepth = maximum depth to transverse in path
        mindepth = minimum depth to transverse before checking files or directories
 
    The default action is ``print=path``
 
    ``path-glob``:
 
        *                = match zero or more chars
        ?                = match any char
        [abc]            = match a, b, or c
        [!abc] or [^abc] = match anything except a, b, and c
        [x-y]            = match chars x through y
        [!x-y] or [^x-y] = match anything except chars x through y
        {a,b,c}          = match a or b or c
 
    ``path-regex``: a Python Regex (regular expression) pattern to match pathnames
 
    ``file-types``: a string of one or more of the following:
 
        a: all file types
        b: block device
        c: character device
        d: directory
        p: FIFO (named pipe)
        f: plain file
        l: symlink
        s: socket
 
    ``users``: a space and/or comma separated list of user names and/or uids
 
    ``groups``: a space and/or comma separated list of group names and/or gids
 
    ``size-unit``:
 
        b: bytes
        k: kilobytes
        m: megabytes
        g: gigabytes
        t: terabytes
 
    interval:
 
        [<num>w] [<num>d] [<num>h] [<num>m] [<num>s]
 
        where:
            w: week
            d: day
            h: hour
            m: minute
            s: second
 
    print-opts: a comma and/or space separated list of one or more of the
    following:
 
        group: group name
        md5:   MD5 digest of file contents
        mode:  file permissions (as integer)
        mtime: last modification time (as time_t)
        name:  file basename
        path:  file absolute path
        size:  file size in bytes
        type:  file type
        user:  user name
 
    CLI Examples:
 
        salt '*' file.find / type=f name=\*.bak size=+10m
        salt '*' file.find /var mtime=+30d size=+10m print=path,size,mtime
        salt '*' file.find /var/log name=\*.[0-9] mtime=+30d size=+10m delete
 
 
file.get_devmm:
 
    Get major/minor info from a device
 
    CLI Example:
 
       salt '*' file.get_devmm /dev/chr
 
 
file.get_diff:
 
    Return unified diff of file compared to file on master
 
    CLI Example:
 
        salt '*' file.get_diff /home/fred/.vimrc salt://users/fred/.vimrc
 
 
file.get_gid:
 
    Return the id of the group that owns a given file
 
    path
        file or directory of which to get the gid
 
    follow_symlinks
        indicated if symlinks should be followed
 
 
    CLI Example:
 
        salt '*' file.get_gid /etc/passwd
 
    Changed in version 0.16.4
        ``follow_symlinks`` option added
 
 
file.get_group:
 
    Return the group that owns a given file
 
    path
        file or directory of which to get the group
 
    follow_symlinks
        indicated if symlinks should be followed
 
    CLI Example:
 
        salt '*' file.get_group /etc/passwd
 
    Changed in version 0.16.4
        ``follow_symlinks`` option added
 
 
file.get_hash:
 
    Get the hash sum of a file
 
    This is better than ``get_sum`` for the following reasons:
        - It does not read the entire file into memory.
        - It does not return a string on error. The returned value of
            ``get_sum`` cannot really be trusted since it is vulnerable to
            collisions: ``get_sum(..., 'xyz') == 'Hash xyz not supported'``
 
    path
        path to the file or directory
 
    form
        desired sum format
 
    chunk_size
        amount to sum at once
 
    CLI Example:
 
        salt '*' file.get_hash /etc/shadow
 
 
file.get_managed:
 
    Return the managed file data for file.managed
 
    name
        location where the file lives on the server
 
    template
        template format
 
    source
        managed source file
 
    source_hash
        hash of the source file
 
    user
        user owner
 
    group
        group owner
 
    mode
        file mode
 
    context
        variables to add to the environment
 
    default
        default values of for context_dict
 
 
    CLI Example:
 
        salt '*' file.get_managed /etc/httpd/conf.d/httpd.conf jinja salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' root root '755' base None None
 
 
file.get_mode:
 
    Return the mode of a file
 
    path
        file or directory of which to get the mode
 
    follow_symlinks
        indicated if symlinks should be followed
 
    CLI Example:
 
        salt '*' file.get_mode /etc/passwd
 
    Changed in version 2014.1.0
        ``follow_symlinks`` option added
 
 
file.get_selinux_context:
 
    Get an SELinux context from a given path
 
    CLI Example:
 
        salt '*' file.get_selinux_context /etc/hosts
 
 
file.get_sum:
 
    Return the checksum for the given file. The following checksum algorithms
    are supported:
 
    * md5
    * sha1
    * sha224
    * sha256 **(default)**
    * sha384
    * sha512
 
    path
        path to the file or directory
 
    form
        desired sum format
 
    CLI Example:
 
        salt '*' file.get_sum /etc/passwd sha512
 
 
file.get_uid:
 
    Return the id of the user that owns a given file
 
    path
        file or directory of which to get the uid
 
    follow_symlinks
        indicated if symlinks should be followed
 
    CLI Example:
 
        salt '*' file.get_uid /etc/passwd
 
    Changed in version 0.16.4
        ``follow_symlinks`` option added
 
 
file.get_user:
 
    Return the user that owns a given file
 
    path
        file or directory of which to get the user
 
    follow_symlinks
        indicated if symlinks should be followed
 
    CLI Example:
 
        salt '*' file.get_user /etc/passwd
 
    Changed in version 0.16.4
        ``follow_symlinks`` option added
 
 
file.gid_to_group:
 
    Convert the group id to the group name on this system
 
    gid
        gid to convert to a group name
 
    CLI Example:
 
        salt '*' file.gid_to_group 0
 
 
file.grep:
 
    Grep for a string in the specified file
 
    Note:
        This function's return value is slated for refinement in future
        versions of Salt
 
    path
        A file path
    pattern
        A string. For example:
        ``test``
        ``a[0-5]``
    args
        grep options. For example:
        ``" -v"``
        ``" -i -B2"``
 
    CLI Example:
 
        salt '*' file.grep /etc/passwd nobody
        salt '*' file.grep /etc/sysconfig/network-scripts/ifcfg-eth0 ipaddr " -i"
        salt '*' file.grep /etc/sysconfig/network-scripts/ifcfg-eth0 ipaddr " -i -B2"
        salt '*' file.grep "/etc/sysconfig/network-scripts/*" ipaddr " -i -l"
 
 
file.group_to_gid:
 
    Convert the group to the gid on this system
 
    group
        group to convert to its gid
 
    CLI Example:
 
        salt '*' file.group_to_gid root
 
 
file.is_blkdev:
 
    Check if a file exists and is a block device.
 
    CLI Example:
 
       salt '*' file.is_blkdev /dev/blk
 
 
file.is_chrdev:
 
    Check if a file exists and is a character device.
 
    CLI Example:
 
       salt '*' file.is_chrdev /dev/chr
 
 
file.is_fifo:
 
    Check if a file exists and is a FIFO.
 
    CLI Example:
 
       salt '*' file.is_fifo /dev/fifo
 
 
file.is_link:
 
    Check if the path is a symlink
 
    CLI Example:
 
       salt '*' file.is_link /path/to/link
 
 
file.join:
 
    Return a normalized file system path for the underlying OS
 
    New in version 2014.7.0
 
    This can be useful at the CLI but is frequently useful when scripting
    combining path variables:
 
        {% set www_root = '/var' %}
        {% set app_dir = 'myapp' %}
 
        myapp_config:
          file:
            - managed
            - name: {{ salt['file.join'](www_root, app_dir, 'config.yaml') }}
 
    CLI Example:
 
        salt '*' file.join '/' 'usr' 'local' 'bin'
 
 
file.lchown:
 
    Chown a file, pass the file the desired user and group without following
    symlinks.
 
    path
        path to the file or directory
 
    user
        user owner
 
    group
        group owner
 
    CLI Example:
 
        salt '*' file.chown /etc/passwd root root
 
 
file.line:
 
    New in version 2015.8.0
 
    Edit a line in the configuration file.
 
    :param path:
        Filesystem path to the file to be edited.
 
    :param content:
        Content of the line.
 
    :param match:
        Match the target line for an action by
        a fragment of a string or regular expression.
 
    :param mode:
        Ensure
            If line does not exist, it will be added.
 
        Replace
            If line already exist, it will be replaced.
 
        Delete
            Delete the line, once found.
 
        Insert
            Insert a line.
 
    :param location:
        start
            Place the content at the beginning of the file.
 
        end
            Place the content at the end of the file.
 
    :param before:
        Regular expression or an exact case-sensitive fragment of the string.
 
    :param after:
        Regular expression or an exact case-sensitive fragment of the string.
 
    :param show_changes
        Output a unified diff of the old file and the new file.
        If ``False`` return a boolean if any changes were made.
        Default is ``True``
 
        Note:
 
            Using this option will store two copies of the file in-memory
            (the original version and the edited version) in order to generate the diff.
 
    :param backup
        Create a backup of the original file with the extension:
        "Year-Month-Day-Hour-Minutes-Seconds".
 
    :param quiet
        Do not raise any exceptions. E.g. ignore the fact that the file that is
        tried to be edited does not exist and nothing really happened.
 
    :param indent
        Keep indentation with the previous line.
 
    If an equal sign (``=``) appears in an argument to a Salt command, it is
    interpreted as a keyword argument in the format of ``key=val``. That
    processing can be bypassed in order to pass an equal sign through to the
    remote shell command by manually specifying the kwarg:
 
        salt '*' file.line /path/to/file content="CREATEMAIL_SPOOL=no" match="CREATE_MAIL_SPOOL=yes" mode="replace"
 
    CLI Examples:
 
        salt '*' file.line /etc/nsswitch.conf "networks:	files dns", after="hosts:.*?", mode='ensure'
 
 
file.link:
 
    New in version 2014.1.0
 
    Create a hard link to a file
 
    CLI Example:
 
        salt '*' file.link /path/to/file /path/to/link
 
 
file.list_backup:
 
This function is an alias of ``list_backups``.
 
    New in version 0.17.0
 
    Lists the previous versions of a file backed up using Salt's :doc:`file
    state backup </ref/states/backup_mode>` system.
 
    path
        The path on the minion to check for backups
    limit
        Limit the number of results to the most recent N backups
 
    CLI Example:
 
        salt '*' file.list_backups /foo/bar/baz.txt
 
 
file.list_backups:
 
    New in version 0.17.0
 
    Lists the previous versions of a file backed up using Salt's :doc:`file
    state backup </ref/states/backup_mode>` system.
 
    path
        The path on the minion to check for backups
    limit
        Limit the number of results to the most recent N backups
 
    CLI Example:
 
        salt '*' file.list_backups /foo/bar/baz.txt
 
 
file.list_backups_dir:
 
    Lists the previous versions of a directory backed up using Salt's :doc:`file
    state backup </ref/states/backup_mode>` system.
 
    path
        The directory on the minion to check for backups
    limit
        Limit the number of results to the most recent N backups
 
    CLI Example:
 
        salt '*' file.list_backups_dir /foo/bar/baz/
 
 
file.lstat:
 
    New in version 2014.1.0
 
    Returns the lstat attributes for the given file or dir. Does not support
    symbolic links.
 
    CLI Example:
 
        salt '*' file.lstat /path/to/file
 
 
file.makedirs:
 
    Ensure that the directory containing this path is available.
 
    Note:
 
        The path must end with a trailing slash otherwise the directory/directories
        will be created up to the parent directory. For example if path is
        ``/opt/code``, then it would be treated as ``/opt/`` but if the path
        ends with a trailing slash like ``/opt/code/``, then it would be
        treated as ``/opt/code/``.
 
    CLI Example:
 
        salt '*' file.makedirs /opt/code/
 
 
file.makedirs_perms:
 
    Taken and modified from os.makedirs to set user, group and mode for each
    directory created.
 
    CLI Example:
 
        salt '*' file.makedirs_perms /opt/code
 
 
file.manage_file:
 
    Checks the destination against what was retrieved with get_managed and
    makes the appropriate modifications (if necessary).
 
    name
        location to place the file
 
    sfn
        location of cached file on the minion
 
        This is the path to the file stored on the minion. This file is placed on the minion
        using cp.cache_file.  If the hash sum of that file matches the source_sum, we do not
        transfer the file to the minion again.
 
        This file is then grabbed and if it has template set, it renders the file to be placed
        into the correct place on the system using salt.files.utils.copyfile()
 
    ret
        The initial state return data structure. Pass in ``None`` to use the default structure.
 
    source
        file reference on the master
 
    source_hash
        sum hash for source
 
    user
        user owner
 
    group
        group owner
 
    backup
        backup_mode
 
    makedirs
        make directories if they do not exist
 
    template
        format of templating
 
    show_diff
        Include diff in state return
 
    contents:
        contents to be placed in the file
 
    dir_mode
        mode for directories created with makedirs
 
    CLI Example:
 
        salt '*' file.manage_file /etc/httpd/conf.d/httpd.conf '' '{}' salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' root root '755' base ''
 
    Changed in version 2014.7.0
        ``follow_symlinks`` option added
 
 
 
file.mkdir:
 
    Ensure that a directory is available.
 
    CLI Example:
 
        salt '*' file.mkdir /opt/jetty/context
 
 
file.mknod:
 
    New in version 0.17.0
 
    Create a block device, character device, or fifo pipe.
    Identical to the gnu mknod.
 
    CLI Examples:
 
        salt '*' file.mknod /dev/chr c 180 31
        salt '*' file.mknod /dev/blk b 8 999
        salt '*' file.nknod /dev/fifo p
 
 
file.mknod_blkdev:
 
    New in version 0.17.0
 
    Create a block device.
 
    CLI Example:
 
       salt '*' file.mknod_blkdev /dev/blk 8 999
 
 
file.mknod_chrdev:
 
    New in version 0.17.0
 
    Create a character device.
 
    CLI Example:
 
       salt '*' file.mknod_chrdev /dev/chr 180 31
 
 
file.mknod_fifo:
 
    New in version 0.17.0
 
    Create a FIFO pipe.
 
    CLI Example:
 
       salt '*' file.mknod_fifo /dev/fifo
 
 
file.move:
 
    Move a file or directory
 
    CLI Example:
 
        salt '*' file.move /path/to/src /path/to/dst
 
 
file.normpath:
 
    Returns Normalize path, eliminating double slashes, etc.
 
    New in version 2015.5.0
 
    This can be useful at the CLI but is frequently useful when scripting.
 
        {%- from salt['file.normpath'](tpldir + '/../vars.jinja') import parent_vars %}
 
    CLI Example:
 
        salt '*' file.normpath 'a/b/c/..'
 
 
file.open_files:
 
    Return a list of all physical open files on the system.
 
    CLI Examples:
 
        salt '*' file.open_files
        salt '*' file.open_files by_pid=True
 
 
file.pardir:
 
    Return the relative parent directory path symbol for underlying OS
 
    New in version 2014.7.0
 
    This can be useful when constructing Salt Formulas.
 
        {% set pardir = salt['file.pardir']() %}
        {% set final_path = salt['file.join']('subdir', pardir, 'confdir') %}
 
    CLI Example:
 
        salt '*' file.pardir
 
 
file.patch:
 
    New in version 0.10.4
 
    Apply a patch to a file
 
    Equivalent to:
 
        patch <options> <originalfile> <patchfile>
 
    originalfile
        The full path to the file or directory to be patched
    patchfile
        A patch file to apply to ``originalfile``
    options
        Options to pass to patch.
 
    CLI Example:
 
        salt '*' file.patch /opt/file.txt /tmp/file.txt.patch
 
 
file.path_exists_glob:
 
    Tests to see if path after expansion is a valid path (file or directory).
    Expansion allows usage of ? * and character ranges []. Tilde expansion
    is not supported. Returns True/False.
 
    New in version Hellium
 
    CLI Example:
 
        salt '*' file.path_exists_glob /etc/pam*/pass*
 
 
 
file.prepend:
 
    New in version 2014.7.0
 
    Prepend text to the beginning of a file
 
    path
        path to file
 
    `*args`
        strings to prepend to the file
 
    CLI Example:
 
        salt '*' file.prepend /etc/motd \
                "With all thine offerings thou shalt offer salt." \
                "Salt is what makes things taste bad when it isn't in them."
 
    .. admonition:: Attention
 
        If you need to pass a string to append and that string contains
        an equal sign, you **must** include the argument name, args.
        For example:
 
            salt '*' file.prepend /etc/motd args='cheese=spam'
 
            salt '*' file.prepend /etc/motd args="['cheese=spam','spam=cheese']"
 
 
 
file.psed:
 
    .. deprecated:: 0.17.0
       Use :py:func:`~salt.modules.file.replace` instead.
 
    Make a simple edit to a file (pure Python version)
 
    Equivalent to:
 
        sed <backup> <options> "/<limit>/ s/<before>/<after>/<flags> <file>"
 
    path
        The full path to the file to be edited
    before
        A pattern to find in order to replace with ``after``
    after
        Text that will replace ``before``
    limit : ``''``
        An initial pattern to search for before searching for ``before``
    backup : ``.bak``
        The file will be backed up before edit with this file extension;
        **WARNING:** each time ``sed``/``comment``/``uncomment`` is called will
        overwrite this backup
    flags : ``gMS``
        Flags to modify the search. Valid values are:
          - ``g``: Replace all occurrences of the pattern, not just the first.
          - ``I``: Ignore case.
          - ``L``: Make ``\w``, ``\W``, ``\b``, ``\B``, ``\s`` and ``\S``
            dependent on the locale.
          - ``M``: Treat multiple lines as a single line.
          - ``S``: Make `.` match all characters, including newlines.
          - ``U``: Make ``\w``, ``\W``, ``\b``, ``\B``, ``\d``, ``\D``,
            ``\s`` and ``\S`` dependent on Unicode.
          - ``X``: Verbose (whitespace is ignored).
    multi: ``False``
        If True, treat the entire file as a single line
 
    Forward slashes and single quotes will be escaped automatically in the
    ``before`` and ``after`` patterns.
 
    CLI Example:
 
        salt '*' file.sed /etc/httpd/httpd.conf 'LogLevel warn' 'LogLevel info'
 
 
file.readdir:
 
    New in version 2014.1.0
 
    Return a list containing the contents of a directory
 
    CLI Example:
 
        salt '*' file.readdir /path/to/dir/
 
 
file.readlink:
 
    New in version 2014.1.0
 
    Return the path that a symlink points to
    If canonicalize is set to True, then it return the final target
 
    CLI Example:
 
        salt '*' file.readlink /path/to/link
 
 
file.remove:
 
    Remove the named file. If a directory is supplied, it will be recursively
    deleted.
 
    CLI Example:
 
        salt '*' file.remove /tmp/foo
 
 
file.remove_backup:
 
This function is an alias of ``delete_backup``.
 
    New in version 0.17.0
 
    Delete a previous version of a file that was backed up using Salt's
    :doc:`file state backup </ref/states/backup_mode>` system.
 
    path
        The path on the minion to check for backups
    backup_id
        The numeric id for the backup you wish to delete, as found using
        :mod:`file.list_backups <salt.modules.file.list_backups>`
 
    CLI Example:
 
        salt '*' file.restore_backup /foo/bar/baz.txt 0
 
 
file.rename:
 
    Rename a file or directory
 
    CLI Example:
 
        salt '*' file.rename /path/to/src /path/to/dst
 
 
file.replace:
 
    New in version 0.17.0
 
    Replace occurrences of a pattern in a file. If ``show_changes`` is
    ``True``, then a diff of what changed will be returned, otherwise a
    ``True`` will be returnd when changes are made, and ``False`` when
    no changes are made.
 
    This is a pure Python implementation that wraps Python's :py:func:`~re.sub`.
 
    path
        Filesystem path to the file to be edited
 
    pattern
        A regular expression, to be matched using Python's
        :py:func:`~re.search`.
 
    repl
        The replacement text
 
    count : 0
        Maximum number of pattern occurrences to be replaced. If count is a
        positive integer ``n``, only ``n`` occurrences will be replaced,
        otherwise all occurrences will be replaced.
 
    flags (list or int)
        A list of flags defined in the :ref:`re module documentation
        <contents-of-module-re>`. Each list item should be a string that will
        correlate to the human-friendly flag name. E.g., ``['IGNORECASE',
        'MULTILINE']``. Optionally, ``flags`` may be an int, with a value
        corresponding to the XOR (``|``) of all the desired flags. Defaults to
        8 (which supports 'MULTILINE').
 
    bufsize (int or str)
        How much of the file to buffer into memory at once. The
        default value ``1`` processes one line at a time. The special value
        ``file`` may be specified which will read the entire file into memory
        before processing.
 
    append_if_not_found : False
        New in version 2014.7.0
 
        If set to ``True``, and pattern is not found, then the content will be
        appended to the file.
 
    prepend_if_not_found : False
        New in version 2014.7.0
 
        If set to ``True`` and pattern is not found, then the content will be
        prepended to the file.
 
    not_found_content
        New in version 2014.7.0
 
        Content to use for append/prepend if not found. If None (default), uses
        ``repl``. Useful when ``repl`` uses references to group in pattern.
 
    backup : .bak
        The file extension to use for a backup of the file before editing. Set
        to ``False`` to skip making a backup.
 
    dry_run : False
        If set to ``True``, no changes will be made to the file, the function
        will just return the changes that would have been made (or a
        ``True``/``False`` value if ``show_changes`` is set to ``False``).
 
    search_only : False
        If set to true, this no changes will be perfomed on the file, and this
        function will simply return ``True`` if the pattern was matched, and
        ``False`` if not.
 
    show_changes : True
        If ``True``, return a diff of changes made. Otherwise, return ``True``
        if changes were made, and ``False`` if not.
 
        Note:
            Using this option will store two copies of the file in memory (the
            original version and the edited version) in order to generate the
            diff. This may not normally be a concern, but could impact
            performance if used with large files.
 
    ignore_if_missing : False
        New in version 2015.8.0
 
        If set to ``True``, this function will simply return ``False``
        if the file doesn't exist. Otherwise, an error will be thrown.
 
    preserve_inode : True
        New in version 2015.8.0
 
        Preserve the inode of the file, so that any hard links continue to
        share the inode with the original filename. This works by *copying* the
        file, reading from the copy, and writing to the file at the original
        inode. If ``False``, the file will be *moved* rather than copied, and a
        new file will be written to a new inode, but using the original
        filename. Hard links will then share an inode with the backup, instead
        (if using ``backup`` to create a backup copy).
 
    If an equal sign (``=``) appears in an argument to a Salt command it is
    interpreted as a keyword argument in the format ``key=val``. That
    processing can be bypassed in order to pass an equal sign through to the
    remote shell command by manually specifying the kwarg:
 
        salt '*' file.replace /path/to/file pattern='=' repl=':'
        salt '*' file.replace /path/to/file pattern="bind-address\s*=" repl='bind-address:'
 
    CLI Examples:
 
        salt '*' file.replace /etc/httpd/httpd.conf pattern='LogLevel warn' repl='LogLevel info'
        salt '*' file.replace /some/file pattern='before' repl='after' flags='[MULTILINE, IGNORECASE]'
 
 
file.restore_backup:
 
    New in version 0.17.0
 
    Restore a previous version of a file that was backed up using Salt's
    :doc:`file state backup </ref/states/backup_mode>` system.
 
    path
        The path on the minion to check for backups
    backup_id
        The numeric id for the backup you wish to restore, as found using
        :mod:`file.list_backups <salt.modules.file.list_backups>`
 
    CLI Example:
 
        salt '*' file.restore_backup /foo/bar/baz.txt 0
 
 
file.restorecon:
 
    Reset the SELinux context on a given path
 
    CLI Example:
 
         salt '*' file.restorecon /home/user/.ssh/authorized_keys
 
 
file.rmdir:
 
    New in version 2014.1.0
 
    Remove the specified directory. Fails if a directory is not empty.
 
    CLI Example:
 
        salt '*' file.rmdir /tmp/foo/
 
 
file.search:
 
    New in version 0.17.0
 
    Search for occurrences of a pattern in a file
 
    Except for multiline, params are identical to
    :py:func:`~salt.modules.file.replace`.
 
    multiline
        If true, inserts 'MULTILINE' into ``flags`` and sets ``bufsize`` to
        'file'.
 
        New in version 2015.8.0
 
    CLI Example:
 
        salt '*' file.search /etc/crontab 'mymaintenance.sh'
 
 
file.sed:
 
    .. deprecated:: 0.17.0
       Use :py:func:`~salt.modules.file.replace` instead.
 
    Make a simple edit to a file
 
    Equivalent to:
 
        sed <backup> <options> "/<limit>/ s/<before>/<after>/<flags> <file>"
 
    path
        The full path to the file to be edited
    before
        A pattern to find in order to replace with ``after``
    after
        Text that will replace ``before``
    limit : ``''``
        An initial pattern to search for before searching for ``before``
    backup : ``.bak``
        The file will be backed up before edit with this file extension;
        **WARNING:** each time ``sed``/``comment``/``uncomment`` is called will
        overwrite this backup
    options : ``-r -e``
        Options to pass to sed
    flags : ``g``
        Flags to modify the sed search; e.g., ``i`` for case-insensitive pattern
        matching
    negate_match : False
        Negate the search command (``!``)
 
        New in version 0.17.0
 
    Forward slashes and single quotes will be escaped automatically in the
    ``before`` and ``after`` patterns.
 
    CLI Example:
 
        salt '*' file.sed /etc/httpd/httpd.conf 'LogLevel warn' 'LogLevel info'
 
 
file.sed_contains:
 
    .. deprecated:: 0.17.0
       Use :func:`search` instead.
 
    Return True if the file at ``path`` contains ``text``. Utilizes sed to
    perform the search (line-wise search).
 
    Note: the ``p`` flag will be added to any flags you pass in.
 
    CLI Example:
 
        salt '*' file.contains /etc/crontab 'mymaintenance.sh'
 
 
file.seek_read:
 
    New in version 2014.1.0
 
    Seek to a position on a file and read it
 
    path
        path to file
 
    seek
        amount to read at once
 
    offset
        offset to start into the file
 
    CLI Example:
 
        salt '*' file.seek_read /path/to/file 4096 0
 
 
file.seek_write:
 
    New in version 2014.1.0
 
    Seek to a position on a file and write to it
 
    path
        path to file
 
    data
        data to write to file
 
    offset
        position in file to start writing
 
    CLI Example:
 
        salt '*' file.seek_write /path/to/file 'some data' 4096
 
 
file.set_mode:
 
    Set the mode of a file
 
    path
        file or directory of which to set the mode
 
    mode
        mode to set the path to
 
    CLI Example:
 
        salt '*' file.set_mode /etc/passwd 0644
 
 
file.set_selinux_context:
 
    Set a specific SELinux label on a given path
 
    CLI Example:
 
        salt '*' file.set_selinux_context path <role> <type> <range>
 
 
file.source_list:
 
    Check the source list and return the source to use
 
    CLI Example:
 
        salt '*' file.source_list salt://http/httpd.conf '{hash_type: 'md5', 'hsum': <md5sum>}' base
 
 
file.stats:
 
    Return a dict containing the stats for a given file
 
    CLI Example:
 
        salt '*' file.stats /etc/passwd
 
 
file.statvfs:
 
    New in version 2014.1.0
 
    Perform a statvfs call against the filesystem that the file resides on
 
    CLI Example:
 
        salt '*' file.statvfs /path/to/file
 
 
file.symlink:
 
    Create a symbolic link to a file
 
    CLI Example:
 
        salt '*' file.symlink /path/to/file /path/to/link
 
 
file.touch:
 
    New in version 0.9.5
 
    Just like the ``touch`` command, create a file if it doesn't exist or
    simply update the atime and mtime if it already does.
 
    atime:
        Access time in Unix epoch time
    mtime:
        Last modification in Unix epoch time
 
    CLI Example:
 
        salt '*' file.touch /var/log/emptyfile
 
 
file.truncate:
 
    New in version 2014.1.0
 
    Seek to a position on a file and delete everything after that point
 
    path
        path to file
 
    length
        offset into file to truncate
 
    CLI Example:
 
        salt '*' file.truncate /path/to/file 512
 
 
file.uid_to_user:
 
    Convert a uid to a user name
 
    uid
        uid to convert to a username
 
    CLI Example:
 
        salt '*' file.uid_to_user 0
 
 
file.uncomment:
 
    .. deprecated:: 0.17.0
       Use :py:func:`~salt.modules.file.replace` instead.
 
    Uncomment specified commented lines in a file
 
    path
        The full path to the file to be edited
    regex
        A regular expression used to find the lines that are to be uncommented.
        This regex should not include the comment character. A leading ``^``
        character will be stripped for convenience (for easily switching
        between comment() and uncomment()).
    char : ``#``
        The character to remove in order to uncomment a line
    backup : ``.bak``
        The file will be backed up before edit with this file extension;
        **WARNING:** each time ``sed``/``comment``/``uncomment`` is called will
        overwrite this backup
 
    CLI Example:
 
        salt '*' file.uncomment /etc/hosts.deny 'ALL: PARANOID'
 
 
file.user_to_uid:
 
    Convert user name to a uid
 
    user
        user name to convert to its uid
 
    CLI Example:
 
        salt '*' file.user_to_uid root
 
 
file.write:
 
    New in version 2014.7.0
 
    Write text to a file, overwriting any existing contents.
 
    path
        path to file
 
    `*args`
        strings to write to the file
 
    CLI Example:
 
        salt '*' file.write /etc/motd \
                "With all thine offerings thou shalt offer salt."
 
    .. admonition:: Attention
 
        If you need to pass a string to append and that string contains
        an equal sign, you **must** include the argument name, args.
        For example:
 
            salt '*' file.write /etc/motd args='cheese=spam'
 
            salt '*' file.write /etc/motd args="['cheese=spam','spam=cheese']"
 
 
 
firewalld.add_masquerade:
 
    Enable masquerade on a zone.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.add_masquerade
 
 
firewalld.add_port:
 
    Allow specific ports in a zone.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.add_port internal 443/tcp
 
 
firewalld.add_port_fwd:
 
    Add port forwarding.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.add_port_fwd public 80 443 tcp
 
 
firewalld.add_service:
 
    Add a service for zone. If zone is omitted, default zone will be used.
 
    CLI Example:
 
        salt '*' firewalld.add_service ssh
 
    To assign a service to a specific zone:
 
        salt '*' firewalld.add_service ssh my_zone
 
 
firewalld.allow_icmp:
 
    Allow a specific ICMP type on a zone
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.allow_icmp zone echo-reply
 
 
firewalld.block_icmp:
 
    Block a specific ICMP type on a zone
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.block_icmp zone echo-reply
 
 
firewalld.default_zone:
 
    Print default zone for connections and interfaces
 
    CLI Example:
 
        salt '*' firewalld.default_zone
 
 
firewalld.delete_service:
 
    Delete an existing service
 
    CLI Example:
 
        salt '*' firewalld.delete_service my_service
 
    By default firewalld will be reloaded. However, to avoid reloading
    you need to specify the restart as False
 
        salt '*' firewalld.delete_service my_service False
 
 
firewalld.delete_zone:
 
    Delete an existing zone
 
    CLI Example:
 
        salt '*' firewalld.delete_zone my_zone
 
    By default firewalld will be reloaded. However, to avoid reloading
    you need to specify the restart as False
 
        salt '*' firewalld.delete_zone my_zone False
 
 
firewalld.get_icmp_types:
 
    Print predefined icmptypes
 
    CLI Example:
 
        salt '*' firewalld.get_icmp_types
 
 
firewalld.get_masquerade:
 
    Show if masquerading is enabled on a zone
 
    CLI Example:
 
        salt '*' firewalld.get_masquerade zone
 
 
firewalld.get_services:
 
    Print predefined services
 
    CLI Example:
 
        salt '*' firewalld.get_services
 
 
firewalld.get_zones:
 
    Print predefined zones
 
    CLI Example:
 
        salt '*' firewalld.get_zones
 
 
firewalld.list_all:
 
    List everything added for or enabled in a zone
 
    CLI Example:
 
        salt '*' firewalld.list_all
 
    List a specific zone
 
        salt '*' firewalld.list_all my_zone
 
 
firewalld.list_icmp_block:
 
    List ICMP blocks on a zone
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewlld.list_icmp_block zone
 
 
firewalld.list_port_fwd:
 
    List port forwarding
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.list_port_fwd public
 
 
firewalld.list_ports:
 
    List all ports in a zone.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.list_ports
 
 
firewalld.list_services:
 
    List services added for zone as a space separated list.
    If zone is omitted, default zone will be used.
 
    CLI Example:
 
        salt '*' firewalld.list_services
 
    List a specific zone
 
        salt '*' firewalld.list_services my_zone
 
 
firewalld.list_zones:
 
    List everything added for or enabled in all zones
 
    CLI Example:
 
        salt '*' firewalld.list_zones
 
 
firewalld.new_service:
 
    Add a new service
 
    CLI Example:
 
        salt '*' firewalld.new_service my_service
 
    By default firewalld will be reloaded. However, to avoid reloading
    you need to specify the restart as False
 
        salt '*' firewalld.new_service my_service False
 
 
firewalld.new_zone:
 
    Add a new zone
 
    CLI Example:
 
        salt '*' firewalld.new_zone my_zone
 
    By default firewalld will be reloaded. However, to avoid reloading
    you need to specify the restart as False
 
        salt '*' firewalld.new_zone my_zone False
 
 
firewalld.remove_masquerade:
 
    Remove masquerade on a zone.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.remove_masquerade
 
 
firewalld.remove_port:
 
    Remove a specific port from a zone.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.remove_port internal 443/tcp
 
 
firewalld.remove_port_fwd:
 
    Remove Port Forwarding.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' firewalld.remove_port_fwd public 80 443 tcp
 
 
firewalld.remove_service:
 
    Remove a service from zone. This option can be specified multiple times.
    If zone is omitted, default zone will be used.
 
    CLI Example:
 
        salt '*' firewalld.remove_service ssh
 
    To remove a service from a specific zone
 
        salt '*' firewalld.remove_service ssh dmz
 
 
firewalld.set_default_zone:
 
    Set default zone
 
    CLI Example:
 
        salt '*' firewalld.set_default_zone damian
 
 
firewalld.version:
 
    Return version from firewall-cmd
 
    CLI Example:
 
        salt '*' firewalld.version
 
 
gem.install:
 
    Installs one or several gems.
 
    :param gems: string
        The gems to install
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
    :param version: string : None
        Specify the version to install for the gem.
        Doesn't play nice with multiple gems at once
    :param rdoc: boolean : False
        Generate RDoc documentation for the gem(s).
    :param ri: boolean : False
        Generate RI documentation for the gem(s).
    :param pre_releases: boolean : False
        Include pre-releases in the available versions
    :param proxy: string : None
        Use the specified HTTP proxy server for all outgoing traffic.
        Format: http://hostname[:port]
 
    CLI Example:
 
        salt '*' gem.install vagrant
 
        salt '*' gem.install redphone gem_bin=/opt/sensu/embedded/bin/gem
 
 
gem.list:
 
    List locally installed gems.
 
    :param prefix: string :
        Only list gems when the name matches this prefix.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.list
 
 
gem.list_upgrades:
 
    New in version 2015.8.0
 
    Check if an upgrade is available for installed gems
 
    gem_bin : None
        Full path to ``gem`` binary to use.
    ruby : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    runas : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.list_upgrades
 
 
gem.sources_add:
 
    Add a gem source.
 
    :param source_uri: string
        The source URI to add.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.sources_add http://rubygems.org/
 
 
gem.sources_list:
 
    List the configured gem sources.
 
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.sources_list
 
 
gem.sources_remove:
 
    Remove a gem source.
 
    :param source_uri: string
        The source URI to remove.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.sources_remove http://rubygems.org/
 
 
gem.uninstall:
 
    Uninstall one or several gems.
 
    :param gems: string
        The gems to uninstall.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.uninstall vagrant
 
 
gem.update:
 
    Update one or several gems.
 
    :param gems: string
        The gems to update.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.update vagrant
 
 
gem.update_system:
 
    Update rubygems.
 
    :param version: string : (newest)
        The version of rubygems to install.
    :param gem_bin: string : None
        Full path to ``gem`` binary to use.
    :param ruby: string : None
        If RVM or rbenv are installed, the ruby version and gemset to use.
        Ignored if ``gem_bin`` is specified.
    :param runas: string : None
        The user to run gem as.
 
    CLI Example:
 
        salt '*' gem.update_system
 
 
genesis.avail_platforms:
 
    Return which platforms are available
 
    CLI Example:
 
        salt myminion genesis.avail_platforms
 
 
genesis.bootstrap:
 
    Create an image for a specific platform.
 
    Please note that this function *MUST* be run as root, as images that are
    created make files belonging to root.
 
    platform
        Which platform to use to create the image. Currently supported platforms
        are rpm, deb and pacman.
 
    root
        Local path to create the root of the image filesystem.
 
    img_format
        Which format to create the image in. By default, just copies files into
        a directory on the local filesystem (``dir``). Future support will exist
        for ``sparse``.
 
    fs_format
        When using a non-``dir`` img_format, which filesystem to format the
        image to. By default, ``ext2``.
 
    arch
        Architecture to install packages for, if supported by the underlying
        bootstrap tool. Currently only used for deb.
 
    flavor
        Which flavor of operating system to install. This correlates to a
        specific directory on the distribution repositories. For instance,
        ``wheezy`` on Debian.
 
    repo_url
        Mainly important for Debian-based repos. Base URL for the mirror to
        install from. (e.x.: http://ftp.debian.org/debian/)
 
    static_qemu
        Local path to the static qemu binary required for this arch.
        (e.x.: /usr/bin/qemu-amd64-static)
 
    pkg_confs
        The location of the conf files to copy into the image, to point the
        installer to the right repos and configuration.
 
    CLI Examples:
 
        salt myminion genesis.bootstrap pacman /root/arch
        salt myminion genesis.bootstrap rpm /root/redhat
        salt myminion genesis.bootstrap deb /root/wheezy arch=amd64             flavor=wheezy static_qemu=/usr/bin/qemu-x86_64-static
 
 
 
genesis.pack:
 
    Pack up a directory structure, into a specific format
 
    CLI Examples:
 
        salt myminion genesis.pack centos /root/centos
        salt myminion genesis.pack centos /root/centos pack_format='tar'
 
 
genesis.unpack:
 
    Unpack an image into a directory structure
 
    CLI Example:
 
        salt myminion genesis.unpack centos /root/centos
 
 
gnome.get:
 
    Get key in a particular GNOME schema
 
    CLI Example:
 
        salt '*' gnome.get user=<username> schema=org.gnome.desktop.screensaver key=idle-activation-enabled
 
 
 
gnome.getClockFormat:
 
    Return the current clock format, either 12h or 24h format.
 
    CLI Example:
 
        salt '*' gnome.getClockFormat user=<username>
 
 
 
gnome.getClockShowDate:
 
    Return the current setting, if the date is shown in the clock
 
    CLI Example:
 
        salt '*' gnome.getClockShowDate user=<username>
 
 
 
gnome.getIdleActivation:
 
    Get whether the idle activation is enabled
 
    CLI Example:
 
        salt '*' gnome.getIdleActivation user=<username>
 
 
 
gnome.getIdleDelay:
 
    Return the current idle delay setting in seconds
 
    CLI Example:
 
        salt '*' gnome.getIdleDelay user=<username>
 
 
 
gnome.ping:
 
    A test to ensure the GNOME module is loaded
 
    CLI Example:
 
        salt '*' gnome.ping user=<username>
 
 
 
gnome.set:
 
    Set key in a particular GNOME schema
 
    CLI Example:
 
        salt '*' gnome.set user=<username> schema=org.gnome.desktop.screensaver key=idle-activation-enabled value=False
 
 
 
gnome.setClockFormat:
 
    Set the clock format, either 12h or 24h format.
 
    CLI Example:
 
        salt '*' gnome.setClockFormat <12h|24h> user=<username>
 
 
 
gnome.setClockShowDate:
 
    Set whether the date is visible in the clock
 
    CLI Example:
 
        salt '*' gnome.setClockShowDate <True|False> user=<username>
 
 
 
gnome.setIdleActivation:
 
    Set whether the idle activation is enabled
 
    CLI Example:
 
        salt '*' gnome.setIdleActivation <True|False> user=<username>
 
 
 
gnome.setIdleDelay:
 
    Set the current idle delay setting in seconds
 
    CLI Example:
 
        salt '*' gnome.setIdleDelay <seconds> user=<username>
 
 
 
grains.append:
 
    New in version 0.17.0
 
    Append a value to a list in the grains config file. If the grain doesn't
    exist, the grain key is added and the value is appended to the new grain
    as a list item.
 
    key
        The grain key to be appended to
 
    val
        The value to append to the grain key
 
    :param convert: If convert is True, convert non-list contents into a list.
        If convert is False and the grain contains non-list contents, an error
        is given. Defaults to False.
 
    :param delimiter: The key can be a nested dict key. Use this parameter to
        specify the delimiter you use, instead of the default ``:``.
        You can now append values to a list in nested dictionary grains. If the
        list doesn't exist at this level, it will be created.
 
        New in version 2014.7.6
 
    CLI Example:
 
        salt '*' grains.append key val
 
 
grains.delval:
 
    New in version 0.17.0
 
    Delete a grain from the grains config file
 
    :param destructive: Delete the key, too. Defaults to False.
 
    CLI Example:
 
        salt '*' grains.delval key
 
 
grains.filter_by:
 
    New in version 0.17.0
 
    Look up the given grain in a given dictionary for the current OS and return
    the result
 
    Although this may occasionally be useful at the CLI, the primary intent of
    this function is for use in Jinja to make short work of creating lookup
    tables for OS-specific data. For example:
 
        {% set apache = salt['grains.filter_by']({
            'Debian': {'pkg': 'apache2', 'srv': 'apache2'},
            'RedHat': {'pkg': 'httpd', 'srv': 'httpd'},
        }, default='Debian') %}
 
        myapache:
          pkg.installed:
            - name: {{ apache.pkg }}
          service.running:
            - name: {{ apache.srv }}
 
    Values in the lookup table may be overridden by values in Pillar. An
    example Pillar to override values in the example above could be as follows:
 
        apache:
          lookup:
            pkg: apache_13
            srv: apache
 
    The call to ``filter_by()`` would be modified as follows to reference those
    Pillar values:
 
        {% set apache = salt['grains.filter_by']({
            ...
        }, merge=salt['pillar.get']('apache:lookup')) %}
 
 
    :param lookup_dict: A dictionary, keyed by a grain, containing a value or
        values relevant to systems matching that grain. For example, a key
        could be the grain for an OS and the value could the name of a package
        on that particular OS.
    :param grain: The name of a grain to match with the current system's
        grains. For example, the value of the "os_family" grain for the current
        system could be used to pull values from the ``lookup_dict``
        dictionary.
    :param merge: A dictionary to merge with the results of the grain selection
        from ``lookup_dict``. This allows Pillar to override the values in the
        ``lookup_dict``. This could be useful, for example, to override the
        values for non-standard package names such as when using a different
        Python version from the default Python version provided by the OS
        (e.g., ``python26-mysql`` instead of ``python-mysql``).
    :param default: default lookup_dict's key used if the grain does not exists
        or if the grain value has no match on lookup_dict.  If unspecified
        the value is "default".
 
        New in version 2014.1.0
 
    :param base: A lookup_dict key to use for a base dictionary.  The
        grain-selected ``lookup_dict`` is merged over this and then finally
        the ``merge`` dictionary is merged.  This allows common values for
        each case to be collected in the base and overridden by the grain
        selection dictionary and the merge dictionary.  Default is unset.
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' grains.filter_by '{Debian: Debheads rule, RedHat: I love my hat}'
        # this one will render {D: {E: I, G: H}, J: K}
        salt '*' grains.filter_by '{A: B, C: {D: {E: F,G: H}}}' 'xxx' '{D: {E: I},J: K}' 'C'
        # next one renders {A: {B: G}, D: J}
        salt '*' grains.filter_by '{default: {A: {B: C}, D: E}, F: {A: {B: G}}, H: {D: I}}' 'xxx' '{D: J}' 'F' 'default'
        # next same as above when default='H' instead of 'F' renders {A: {B: C}, D: J}
 
 
grains.get:
 
    Attempt to retrieve the named value from grains, if the named value is not
    available return the passed default. The default return is an empty string.
 
    The value can also represent a value in a nested dict using a ":" delimiter
    for the dict. This means that if a dict in grains looks like this::
 
        {'pkg': {'apache': 'httpd'}}
 
    To retrieve the value associated with the apache key in the pkg dict this
    key can be passed::
 
        pkg:apache
 
 
    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' grains.get pkg:apache
 
 
grains.get_or_set_hash:
 
    Perform a one-time generation of a hash and write it to the local grains.
    If that grain has already been set return the value instead.
 
    This is useful for generating passwords or keys that are specific to a
    single minion that don't need to be stored somewhere centrally.
 
    State Example:
 
        some_mysql_user:
          mysql_user:
            - present
            - host: localhost
            - password: {{ salt['grains.get_or_set_hash']('mysql:some_mysql_user') }}
 
    CLI Example:
 
        salt '*' grains.get_or_set_hash 'django:SECRET_KEY' 50
 
    Warning:
 
        This function could return strings which may contain characters which are reserved
        as directives by the YAML parser, such as strings beginning with ``%``. To avoid
        issues when using the output of this function in an SLS file containing YAML+Jinja,
        surround the call with single quotes.
 
 
grains.has_value:
 
    Determine whether a named value exists in the grains dictionary.
 
    Given a grains dictionary that contains the following structure::
 
        {'pkg': {'apache': 'httpd'}}
 
    One would determine if the apache key in the pkg dict exists by::
 
        pkg:apache
 
    CLI Example:
 
        salt '*' grains.has_value pkg:apache
 
 
grains.item:
 
    Return one or more grains
 
    CLI Example:
 
        salt '*' grains.item os
        salt '*' grains.item os osrelease oscodename
 
    Sanitized CLI Example:
 
        salt '*' grains.item host sanitize=True
 
 
grains.items:
 
    Return all of the minion's grains
 
    CLI Example:
 
        salt '*' grains.items
 
    Sanitized CLI Example:
 
        salt '*' grains.items sanitize=True
 
 
grains.ls:
 
    Return a list of all available grains
 
    CLI Example:
 
        salt '*' grains.ls
 
 
grains.remove:
 
    New in version 0.17.0
 
    Remove a value from a list in the grains config file
 
    :param delimiter: The key can be a nested dict key. Use this parameter to
        specify the delimiter you use, instead of the default ``:``.
        You can now append values to a list in nested dictionary grains. If the
        list doesn't exist at this level, it will be created.
 
        New in version Boron
 
    CLI Example:
 
        salt '*' grains.remove key val
 
 
grains.set:
 
    Set a key to an arbitrary value. It is used like setval but works
    with nested keys.
 
    This function is conservative. It will only overwrite an entry if
    its value and the given one are not a list or a dict. The ``force``
    parameter is used to allow overwriting in all cases.
 
    New in version 2015.8.0
 
    :param force: Force writing over existing entry if given or existing
                  values are list or dict. Defaults to False.
    :param destructive: If an operation results in a key being removed,
                  delete the key, too. Defaults to False.
    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict,
        the default being ``:``
 
    CLI Example:
 
        salt '*' grains.set 'apps:myApp:port' 2209
        salt '*' grains.set 'apps:myApp' '{port: 2209}'
 
 
grains.setval:
 
    Set a grains value in the grains config file
 
    :param Destructive: If an operation results in a key being removed, delete the key, too. Defaults to False.
 
    CLI Example:
 
        salt '*' grains.setval key val
        salt '*' grains.setval key "{'sub-key': 'val', 'sub-key2': 'val2'}"
 
 
grains.setvals:
 
    Set new grains values in the grains config file
 
    :param Destructive: If an operation results in a key being removed, delete the key, too. Defaults to False.
 
    CLI Example:
 
        salt '*' grains.setvals "{'key1': 'val1', 'key2': 'val2'}"
 
 
group.add:
 
    Add the specified group
 
    CLI Example:
 
        salt '*' group.add foo 3456
 
 
group.adduser:
 
    Add a user in the group.
 
    CLI Example:
 
         salt '*' group.adduser foo bar
 
    Verifies if a valid username 'bar' as a member of an existing group 'foo',
    if not then adds it.
 
 
group.chgid:
 
    Change the gid for a named group
 
    CLI Example:
 
        salt '*' group.chgid foo 4376
 
 
group.delete:
 
    Remove the named group
 
    CLI Example:
 
        salt '*' group.delete foo
 
 
group.deluser:
 
    Remove a user from the group.
 
    CLI Example:
 
         salt '*' group.deluser foo bar
 
    Removes a member user 'bar' from a group 'foo'. If group is not present
    then returns True.
 
 
group.getent:
 
    Return info on all groups
 
    CLI Example:
 
        salt '*' group.getent
 
 
group.info:
 
    Return information about a group
 
    CLI Example:
 
        salt '*' group.info foo
 
 
group.members:
 
    Replaces members of the group with a provided list.
 
    CLI Example:
 
        salt '*' group.members foo 'user1,user2,user3,...'
 
    Replaces a membership list for a local group 'foo'.
        foo:x:1234:user1,user2,user3,...
 
 
hashutil.base64_decodestring:
 
    Decode a base64-encoded string
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' hashutil.base64_decodestring 'Z2V0IHNhbHRlZA==\n'
 
 
hashutil.base64_encodestring:
 
    Encode a string as base64
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' hashutil.base64_encodestring 'get salted'
 
 
hashutil.hmac_signature:
 
    Verify a challenging hmac signature against a string / shared-secret
 
    New in version 2014.7.0
 
    Returns a boolean if the verification succeeded or failed.
 
    CLI Example:
 
        salt '*' hashutil.hmac_signature 'get salted' 'shared secret' 'eBWf9bstXg+NiP5AOwppB5HMvZiYMPzEM9W5YMm/AmQ='
 
 
hashutil.md5_digest:
 
    Generate an md5 hash of a given string
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' hashutil.md5_digest 'get salted'
 
 
hashutil.sha256_digest:
 
    Generate an sha256 hash of a given string
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' hashutil.sha256_digest 'get salted'
 
 
hashutil.sha512_digest:
 
    Generate an sha512 hash of a given string
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' hashutil.sha512_digest 'get salted'
 
 
hg.archive:
 
    Export a tarball from the repository
 
    cwd
        The path to the Mercurial repository
 
    output
        The path to the archive tarball
 
    rev: tip
        The revision to create an archive from
 
    fmt: None
        Format of the resulting archive. Mercurial supports: tar,
        tbz2, tgz, zip, uzip, and files formats.
 
    prefix : None
        Prepend <prefix>/ to every filename in the archive
 
    user : None
        Run hg as a user other than what the minion runs as
 
    If ``prefix`` is not specified it defaults to the basename of the repo
    directory.
 
    CLI Example:
 
        salt '*' hg.archive /path/to/repo output=/tmp/archive.tgz fmt=tgz
 
 
hg.clone:
 
    Clone a new repository
 
    cwd
        The path to the Mercurial repository
 
    repository
        The hg URI of the repository
 
    opts : None
        Any additional options to add to the command line
 
    user : None
        Run hg as a user other than what the minion runs as
 
    identity : None
        Private SSH key on the minion server for authentication (ssh://)
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' hg.clone /path/to/repo https://bitbucket.org/birkenfeld/sphinx
 
 
hg.describe:
 
    Mimic git describe and return an identifier for the given revision
 
    cwd
        The path to the Mercurial repository
 
    rev: tip
        The path to the archive tarball
 
    user : None
        Run hg as a user other than what the minion runs as
 
    CLI Example:
 
        salt '*' hg.describe /path/to/repo
 
 
hg.pull:
 
    Perform a pull on the given repository
 
    cwd
        The path to the Mercurial repository
 
    repository : None
        Perform pull from the repository different from .hg/hgrc:[paths]:default
 
    opts : None
        Any additional options to add to the command line
 
    user : None
        Run hg as a user other than what the minion runs as
 
    identity : None
        Private SSH key on the minion server for authentication (ssh://)
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' hg.pull /path/to/repo opts=-u
 
 
hg.revision:
 
    Returns the long hash of a given identifier (hash, branch, tag, HEAD, etc)
 
    cwd
        The path to the Mercurial repository
 
    rev: tip
        The revision
 
    short: False
        Return an abbreviated commit hash
 
    user : None
        Run hg as a user other than what the minion runs as
 
    CLI Example:
 
        salt '*' hg.revision /path/to/repo mybranch
 
 
hg.update:
 
    Update to a given revision
 
    cwd
        The path to the Mercurial repository
 
    rev
        The revision to update to
 
    force : False
        Force an update
 
    user : None
        Run hg as a user other than what the minion runs as
 
    CLI Example:
 
        salt devserver1 hg.update /path/to/repo somebranch
 
 
hipchat.find_room:
 
    Find a room by name and return it.
    :param name:    The room name.
    :param api_key: The HipChat admin api key.
    :param api_version: The HipChat api version, if not specified in the configuration.
    :return:        The room object.
 
    CLI Example:
 
        salt '*' hipchat.find_room name="Development Room"
 
        salt '*' hipchat.find_room name="Development Room" api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15 api_version=v1
 
 
hipchat.find_user:
 
    Find a user by name and return it.
    :param name:        The user name.
    :param api_key:     The HipChat admin api key.
    :param api_version: The HipChat api version, if not specified in the configuration.
    :return:            The user object.
 
    CLI Example:
 
        salt '*' hipchat.find_user name="Thomas Hatch"
 
        salt '*' hipchat.find_user name="Thomas Hatch" api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15 api_version=v1
 
 
hipchat.list_rooms:
 
    List all HipChat rooms.
 
    :param api_key: The HipChat admin api key.
    :param api_version: The HipChat api version, if not specified in the configuration.
    :return: The room list.
 
    CLI Example:
 
        salt '*' hipchat.list_rooms
 
        salt '*' hipchat.list_rooms api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15 api_version=v1
 
 
hipchat.list_users:
 
    List all HipChat users.
    :param api_key: The HipChat admin api key.
    :param api_version: The HipChat api version, if not specified in the configuration.
    :return: The user list.
 
    CLI Example:
 
        salt '*' hipchat.list_users
 
        salt '*' hipchat.list_users api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15 api_version=v1
 
 
hipchat.send_message:
 
    Send a message to a HipChat room.
    :param room_id:     The room id or room name, either will work.
    :param message:     The message to send to the HipChat room.
    :param from_name:   Specify who the message is from.
    :param api_key:     The HipChat api key, if not specified in the configuration.
    :param api_version: The HipChat api version, if not specified in the configuration.
    :param color:       The color for the message, default: yellow.
    :param notify:      Whether to notify the room, default: False.
    :return:            Boolean if message was sent successfully.
 
    CLI Example:
 
        salt '*' hipchat.send_message room_id="Development Room" message="Build is done" from_name="Build Server"
 
        salt '*' hipchat.send_message room_id="Development Room" message="Build failed" from_name="Build Server" color="red" notify=True
 
 
hosts.add_host:
 
    Add a host to an existing entry, if the entry is not in place then create
    it with the given host
 
    CLI Example:
 
        salt '*' hosts.add_host <ip> <alias>
 
 
hosts.get_alias:
 
    Return the list of aliases associated with an ip
 
    CLI Example:
 
        salt '*' hosts.get_alias <ip addr>
 
 
hosts.get_ip:
 
    Return the ip associated with the named host
 
    CLI Example:
 
        salt '*' hosts.get_ip <hostname>
 
 
hosts.has_pair:
 
    Return true if the alias is set
 
    CLI Example:
 
        salt '*' hosts.has_pair <ip> <alias>
 
 
hosts.list_hosts:
 
    Return the hosts found in the hosts file in this format::
 
        {'<ip addr>': ['alias1', 'alias2', ...]}
 
    CLI Example:
 
        salt '*' hosts.list_hosts
 
 
hosts.rm_host:
 
    Remove a host entry from the hosts file
 
    CLI Example:
 
        salt '*' hosts.rm_host <ip> <alias>
 
 
hosts.set_host:
 
    Set the host entry in the hosts file for the given ip, this will overwrite
    any previous entry for the given ip
 
    CLI Example:
 
        salt '*' hosts.set_host <ip> <alias>
 
 
http.query:
 
    Query a resource, and decode the return data
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' http.query http://somelink.com/
        salt '*' http.query http://somelink.com/ method=POST             params='key1=val1&key2=val2'
        salt '*' http.query http://somelink.com/ method=POST             data='<xml>somecontent</xml>'
 
 
http.update_ca_bundle:
 
    Update the local CA bundle file from a URL
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' http.update_ca_bundle
        salt '*' http.update_ca_bundle target=/path/to/cacerts.pem
        salt '*' http.update_ca_bundle source=https://example.com/cacerts.pem
 
    If the ``target`` is not specified, it will be pulled from the ``ca_cert``
    configuration variable available to the minion. If it cannot be found there,
    it will be placed at ``<<FILE_ROOTS>>/cacerts.pem``.
 
    If the ``source`` is not specified, it will be pulled from the
    ``ca_cert_url`` configuration variable available to the minion. If it cannot
    be found, it will be downloaded from the cURL website, using an http (not
    https) URL. USING THE DEFAULT URL SHOULD BE AVOIDED!
 
    ``merge_files`` may also be specified, which includes a string or list of
    strings representing a file or files to be appended to the end of the CA
    bundle, once it is downloaded.
 
    CLI Example:
 
        salt '*' http.update_ca_bundle merge_files=/path/to/mycert.pem
 
 
img.bootstrap:
 
    HIGHLY EXPERIMENTAL
    Bootstrap a virtual machine image
 
    location:
        The location to create the image
 
    size:
        The size of the image to create in megabytes
 
    fmt:
        The image format, raw or qcow2
 
    CLI Example:
 
        salt '*' img.bootstrap /srv/salt-images/host.qcow 4096 qcow2
 
 
img.mnt_image:
 
This function is an alias of ``mount_image``.
 
    Mount the named image and return the mount point
 
    CLI Example:
 
        salt '*' img.mount_image /tmp/foo
 
 
img.mount_image:
 
    Mount the named image and return the mount point
 
    CLI Example:
 
        salt '*' img.mount_image /tmp/foo
 
 
img.umount_image:
 
    Unmount an image mountpoint
 
    CLI Example:
 
        salt '*' img.umount_image /mnt/foo
 
 
incron.list_tab:
 
    Return the contents of the specified user's incrontab
 
    CLI Example:
 
        salt '*' incron.list_tab root
 
 
incron.ls:
 
This function is an alias of ``list_tab``.
 
    Return the contents of the specified user's incrontab
 
    CLI Example:
 
        salt '*' incron.list_tab root
 
 
incron.raw_incron:
 
    Return the contents of the user's incrontab
 
    CLI Example:
 
        salt '*' incron.raw_incron root
 
 
incron.raw_system_incron:
 
    Return the contents of the system wide incrontab
 
    CLI Example:
 
        salt '*' incron.raw_system_incron
 
 
incron.rm:
 
This function is an alias of ``rm_job``.
 
    Remove a incron job for a specified user. If any of the day/time params are
    specified, the job will only be removed if the specified params match.
 
    CLI Example:
 
        salt '*' incron.rm_job root /path
 
 
incron.rm_job:
 
    Remove a incron job for a specified user. If any of the day/time params are
    specified, the job will only be removed if the specified params match.
 
    CLI Example:
 
        salt '*' incron.rm_job root /path
 
 
incron.set_job:
 
    Sets an incron job up for a specified user.
 
    CLI Example:
 
        salt '*' incron.set_job root '/root' 'IN_MODIFY' 'echo "$$ $@ $# $% $&"'
 
 
incron.write_incron_file:
 
    Writes the contents of a file to a user's incrontab
 
    CLI Example:
 
        salt '*' incron.write_incron_file root /tmp/new_incron
 
 
incron.write_incron_file_verbose:
 
    Writes the contents of a file to a user's incrontab and return error message on error
 
    CLI Example:
 
        salt '*' incron.write_incron_file_verbose root /tmp/new_incron
 
 
ini.get_option:
 
    Get value of a key from a section in an ini file. Returns ``None`` if
    no matching key was found.
 
    API Example:
 
        import salt
        sc = salt.client.get_local_client()
        sc.cmd('target', 'ini.get_option',
               [path_to_ini_file, section_name, option])
 
    CLI Example:
 
        salt '*' ini.get_option /path/to/ini section_name option_name
 
 
ini.get_section:
 
    Retrieve a section from an ini file. Returns the section as dictionary. If
    the section is not found, an empty dictionary is returned.
 
    API Example:
 
        import salt
        sc = salt.client.get_local_client()
        sc.cmd('target', 'ini.get_section',
               [path_to_ini_file, section_name])
 
    CLI Example:
 
        salt '*' ini.get_section /path/to/ini section_name
 
 
ini.remove_option:
 
    Remove a key/value pair from a section in an ini file. Returns the value of
    the removed key, or ``None`` if nothing was removed.
 
    API Example:
 
        import salt
        sc = salt.client.get_local_client()
        sc.cmd('target', 'ini.remove_option',
               [path_to_ini_file, section_name, option])
 
    CLI Example:
 
        salt '*' ini.remove_option /path/to/ini section_name option_name
 
 
ini.remove_section:
 
    Remove a section in an ini file. Returns the removed section as dictionary,
    or ``None`` if nothing was removed.
 
    API Example:
 
        import salt
        sc = salt.client.get_local_client()
        sc.cmd('target', 'ini.remove_section',
               [path_to_ini_file, section_name])
 
    CLI Example:
 
        salt '*' ini.remove_section /path/to/ini section_name
 
 
ini.set_option:
 
    Edit an ini file, replacing one or more sections. Returns a dictionary
    containing the changes made.
 
    file_name
        path of ini_file
 
    sections : None
        A dictionary representing the sections to be edited ini file
 
    Set ``summary=False`` if return data need not have previous option value
 
    API Example:
 
        import salt
        sc = salt.client.get_local_client()
        sc.cmd('target', 'ini.set_option',
               ['path_to_ini_file', '{"section_to_change": {"key": "value"}}'])
 
    CLI Example:
 
        salt '*' ini.set_option /path/to/ini '{section_foo: {key: value}}'
 
 
introspect.enabled_service_owners:
 
    Return which packages own each of the services that are currently enabled.
 
    CLI Example:
 
        salt myminion introspect.enabled_service_owners
 
 
introspect.running_service_owners:
 
    Determine which packages own the currently running services. By default,
    excludes files whose full path starts with ``/dev``, ``/home``, ``/media``,
    ``/proc``, ``/run``, ``/sys``, ``/tmp`` and ``/var``. This can be
    overridden by passing in a new list to ``exclude``.
 
    CLI Example:
 
        salt myminion introspect.running_service_owners
 
 
introspect.service_highstate:
 
    Return running and enabled services in a highstate structure. By default
    also returns package dependencies for those services, which means that
    package definitions must be created outside this function. To drop the
    package dependencies, set ``requires`` to False.
 
    CLI Example:
 
        salt myminion introspect.service_highstate
        salt myminion introspect.service_highstate requires=False
 
 
ip.apply_network_settings:
 
    Apply global network configuration.
 
    CLI Example:
 
        salt '*' ip.apply_network_settings
 
 
ip.build_bond:
 
    Create a bond script in /etc/modprobe.d with the passed settings
    and load the bonding kernel module.
 
    CLI Example:
 
        salt '*' ip.build_bond bond0 mode=balance-alb
 
 
ip.build_interface:
 
    Build an interface script for a network interface.
 
    CLI Example:
 
        salt '*' ip.build_interface eth0 eth <settings>
 
 
ip.build_network_settings:
 
    Build the global network script.
 
    CLI Example:
 
        salt '*' ip.build_network_settings <settings>
 
 
ip.build_routes:
 
    Build a route script for a network interface.
 
    CLI Example:
 
        salt '*' ip.build_routes eth0 <settings>
 
 
ip.down:
 
    Shutdown a network interface
 
    CLI Example:
 
        salt '*' ip.down eth0
 
 
ip.get_bond:
 
    Return the content of a bond script
 
    CLI Example:
 
        salt '*' ip.get_bond bond0
 
 
ip.get_interface:
 
    Return the contents of an interface script
 
    CLI Example:
 
        salt '*' ip.get_interface eth0
 
 
ip.get_network_settings:
 
    Return the contents of the global network script.
 
    CLI Example:
 
        salt '*' ip.get_network_settings
 
 
ip.get_routes:
 
    Return the contents of the interface routes script.
 
    CLI Example:
 
        salt '*' ip.get_routes eth0
 
 
ip.up:
 
    Start up a network interface
 
    CLI Example:
 
        salt '*' ip.up eth0
 
 
iptables.append:
 
    Append a rule to the specified table/chain.
 
    This function accepts a rule in a standard iptables command format,
        starting with the chain. Trying to force users to adapt to a new
        method of creating rules would be irritating at best, and we
        already have a parser that can handle it.
 
    CLI Example:
 
        salt '*' iptables.append filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
 
        IPv6:
        salt '*' iptables.append filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \
            family=ipv6
 
 
iptables.build_rule:
 
    Build a well-formatted iptables rule based on kwargs. A `table` and `chain`
    are not required, unless `full` is True.
 
    If `full` is `True`, then `table`, `chain` and `command` are required.
    `command` may be specified as either a short option ('I') or a long option
    (`--insert`). This will return the iptables command, exactly as it would
    be used from the command line.
 
    If a position is required (as with `-I` or `-D`), it may be specified as
    `position`. This will only be useful if `full` is True.
 
    If `connstate` is passed in, it will automatically be changed to `state`.
 
    To pass in jump options that doesn't take arguments, pass in an empty
    string.
 
    CLI Examples:
 
        salt '*' iptables.build_rule match=state \
            connstate=RELATED,ESTABLISHED jump=ACCEPT
 
        salt '*' iptables.build_rule filter INPUT command=I position=3 \
            full=True match=state state=RELATED,ESTABLISHED jump=ACCEPT
 
        salt '*' iptables.build_rule filter INPUT command=A \
            full=True match=state state=RELATED,ESTABLISHED \
            source='127.0.0.1' jump=ACCEPT
 
        .. Invert Rules
        salt '*' iptables.build_rule filter INPUT command=A \
            full=True match=state state=RELATED,ESTABLISHED \
            source='! 127.0.0.1' jump=ACCEPT
 
        salt '*' iptables.build_rule filter INPUT command=A \
            full=True match=state state=RELATED,ESTABLISHED \
            destination='not 127.0.0.1' jump=ACCEPT
 
        IPv6:
        salt '*' iptables.build_rule match=state \
            connstate=RELATED,ESTABLISHED jump=ACCEPT \
            family=ipv6
        salt '*' iptables.build_rule filter INPUT command=I position=3 \
            full=True match=state state=RELATED,ESTABLISHED jump=ACCEPT \
            family=ipv6
 
 
 
iptables.check:
 
    Check for the existence of a rule in the table and chain
 
    This function accepts a rule in a standard iptables command format,
        starting with the chain. Trying to force users to adapt to a new
        method of creating rules would be irritating at best, and we
        already have a parser that can handle it.
 
    CLI Example:
 
        salt '*' iptables.check filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
 
        IPv6:
        salt '*' iptables.check filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \
            family=ipv6
 
 
iptables.check_chain:
 
    New in version 2014.1.0
 
    Check for the existence of a chain in the table
 
    CLI Example:
 
        salt '*' iptables.check_chain filter INPUT
 
        IPv6:
        salt '*' iptables.check_chain filter INPUT family=ipv6
 
 
iptables.delete:
 
    Delete a rule from the specified table/chain, specifying either the rule
        in its entirety, or the rule's position in the chain.
 
    This function accepts a rule in a standard iptables command format,
        starting with the chain. Trying to force users to adapt to a new
        method of creating rules would be irritating at best, and we
        already have a parser that can handle it.
 
    CLI Examples:
 
        salt '*' iptables.delete filter INPUT position=3
        salt '*' iptables.delete filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
 
        IPv6:
        salt '*' iptables.delete filter INPUT position=3 family=ipv6
        salt '*' iptables.delete filter INPUT \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \
            family=ipv6
 
 
iptables.delete_chain:
 
    New in version 2014.1.0
 
    Delete custom chain to the specified table.
 
    CLI Example:
 
        salt '*' iptables.delete_chain filter CUSTOM_CHAIN
 
        IPv6:
        salt '*' iptables.delete_chain filter CUSTOM_CHAIN family=ipv6
 
 
iptables.flush:
 
    Flush the chain in the specified table, flush all chains in the specified
    table if not specified chain.
 
    CLI Example:
 
        salt '*' iptables.flush filter INPUT
 
        IPv6:
        salt '*' iptables.flush filter INPUT family=ipv6
 
 
iptables.get_policy:
 
    Return the current policy for the specified table/chain
 
    CLI Example:
 
        salt '*' iptables.get_policy filter INPUT
 
        IPv6:
        salt '*' iptables.get_policy filter INPUT family=ipv6
 
 
iptables.get_rules:
 
    Return a data structure of the current, in-memory rules
 
    CLI Example:
 
        salt '*' iptables.get_rules
 
        IPv6:
        salt '*' iptables.get_rules family=ipv6
 
 
 
iptables.get_saved_policy:
 
    Return the current policy for the specified table/chain
 
    CLI Examples:
 
        salt '*' iptables.get_saved_policy filter INPUT
        salt '*' iptables.get_saved_policy filter INPUT \
            conf_file=/etc/iptables.saved
 
        IPv6:
        salt '*' iptables.get_saved_policy filter INPUT family=ipv6
        salt '*' iptables.get_saved_policy filter INPUT \
            conf_file=/etc/iptables.saved family=ipv6
 
 
 
iptables.get_saved_rules:
 
    Return a data structure of the rules in the conf file
 
    CLI Example:
 
        salt '*' iptables.get_saved_rules
 
        IPv6:
        salt '*' iptables.get_saved_rules family=ipv6
 
 
iptables.insert:
 
    Insert a rule into the specified table/chain, at the specified position.
 
    This function accepts a rule in a standard iptables command format,
        starting with the chain. Trying to force users to adapt to a new
        method of creating rules would be irritating at best, and we
        already have a parser that can handle it.
 
    If the position specified is a negative number, then the insert will be
        performed counting from the end of the list. For instance, a position
        of -1 will insert the rule as the second to last rule. To insert a rule
        in the last position, use the append function instead.
 
    CLI Examples:
 
        salt '*' iptables.insert filter INPUT position=3 \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT'
 
        IPv6:
        salt '*' iptables.insert filter INPUT position=3 \
            rule='-m state --state RELATED,ESTABLISHED -j ACCEPT' \
            family=ipv6
 
 
iptables.new_chain:
 
    New in version 2014.1.0
 
    Create new custom chain to the specified table.
 
    CLI Example:
 
        salt '*' iptables.new_chain filter CUSTOM_CHAIN
 
        IPv6:
        salt '*' iptables.new_chain filter CUSTOM_CHAIN family=ipv6
 
 
iptables.save:
 
    Save the current in-memory rules to disk
 
    CLI Example:
 
        salt '*' iptables.save /etc/sysconfig/iptables
 
        IPv6:
        salt '*' iptables.save /etc/sysconfig/iptables family=ipv6
 
 
iptables.set_policy:
 
    Set the current policy for the specified table/chain
 
    CLI Example:
 
        salt '*' iptables.set_policy filter INPUT ACCEPT
 
        IPv6:
        salt '*' iptables.set_policy filter INPUT ACCEPT family=ipv6
 
 
iptables.version:
 
    Return version from iptables --version
 
    CLI Example:
 
        salt '*' iptables.version
 
        IPv6:
        salt '*' iptables.version family=ipv6
 
 
jboss7.create_datasource:
 
    Create datasource in running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
    name
        Datasource name
    datasource_properties
        A dictionary of datasource properties to be created:
          - driver-name: mysql
          - connection-url: 'jdbc:mysql://localhost:3306/sampleDatabase'
          - jndi-name: 'java:jboss/datasources/sampleDS'
          - user-name: sampleuser
          - password: secret
          - min-pool-size: 3
          - use-java-context: True
 
    CLI Example:
 
        salt '*' jboss7.create_datasource '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' 'my_datasource' '{"driver-name": "mysql", "connection-url": "jdbc:mysql://localhost:3306/sampleDatabase", "jndi-name": "java:jboss/datasources/sampleDS", "user-name": "sampleuser", "password": "secret", "min-pool-size": 3, "use-java-context": True}'
 
 
jboss7.create_simple_binding:
 
    Create a simple jndi binding in the running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
    binding_name
        Binding name to be created
    value
        Binding value
 
    CLI Example:
 
        salt '*' jboss7.create_simple_binding \
                '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", \
                "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' \
                my_binding_name my_binding_value
 
 
jboss7.deploy:
 
    Deploy the application on the jboss instance from the local file system where minion is running.
 
    jboss_config
        Configuration dictionary with properties specified above.
    source_file
        Source file to deploy from
 
    CLI Example:
 
        salt '*' jboss7.deploy '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' /opt/deploy_files/my_deploy
 
 
jboss7.list_deployments:
 
    List all deployments on the jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
 
     CLI Example:
 
         salt '*' jboss7.list_deployments '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}'
 
 
 
jboss7.read_datasource:
 
    Read datasource properties in the running jboss instance.
 
    jboss_config
        Configuration dictionary with properties specified above.
    name
        Datasource name
 
    CLI Example:
 
        salt '*' jboss7.read_datasource '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}'
 
 
jboss7.read_simple_binding:
 
    Read jndi binding in the running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
    binding_name
        Binding name to be created
 
    CLI Example:
 
        salt '*' jboss7.read_simple_binding '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_binding_name
 
 
jboss7.reload:
 
    Reload running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
 
    CLI Example:
 
        salt '*' jboss7.reload '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}'
 
 
 
jboss7.remove_datasource:
 
    Remove an existing datasource from the running jboss instance.
 
    jboss_config
        Configuration dictionary with properties specified above.
    name
        Datasource name
 
    CLI Example:
 
        salt '*' jboss7.remove_datasource '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_datasource_name
 
 
jboss7.status:
 
    Get status of running jboss instance.
 
    jboss_config
        Configuration dictionary with properties specified above.
 
    CLI Example:
 
        salt '*' jboss7.status '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}'
 
 
 
jboss7.stop_server:
 
    Stop running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
 
    CLI Example:
 
        salt '*' jboss7.stop_server '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}'
 
 
 
jboss7.undeploy:
 
    Undeploy the application from jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
    deployment
        Deployment name to undeploy
 
    CLI Example:
 
        salt '*' jboss7.undeploy '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_deployment
 
 
jboss7.update_datasource:
 
    Update an existing datasource in running jboss instance.
    If the property doesn't exist if will be created, if it does, it will be updated with the new value
 
    jboss_config
        Configuration dictionary with properties specified above.
    name
        Datasource name
    new_properties
        A dictionary of datasource properties to be updated. For example:
          - driver-name: mysql
          - connection-url: 'jdbc:mysql://localhost:3306/sampleDatabase'
          - jndi-name: 'java:jboss/datasources/sampleDS'
          - user-name: sampleuser
          - password: secret
          - min-pool-size: 3
          - use-java-context: True
 
    CLI Example:
 
        salt '*' jboss7.update_datasource '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' 'my_datasource' '{"driver-name": "mysql", "connection-url": "jdbc:mysql://localhost:3306/sampleDatabase", "jndi-name": "java:jboss/datasources/sampleDS", "user-name": "sampleuser", "password": "secret", "min-pool-size": 3, "use-java-context": True}'
 
 
 
jboss7.update_simple_binding:
 
    Update the simple jndi binding in the running jboss instance
 
    jboss_config
        Configuration dictionary with properties specified above.
    binding_name
        Binding name to be updated
    value
        New binding value
 
    CLI Example:
 
        salt '*' jboss7.update_simple_binding '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_binding_name my_binding_value
 
 
jboss7_cli.run_command:
 
    Execute a command against jboss instance through the CLI interface.
 
    jboss_config
           Configuration dictionary with properties specified above.
    command
           Command to execute against jboss instance
    fail_on_error (default=True)
           Is true, raise CommandExecutionException exception if execution fails.
           If false, 'success' property of the returned dictionary is set to False
 
    CLI Example:
 
        salt '*' jboss7_cli.run_command '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_command
 
 
jboss7_cli.run_operation:
 
    Execute an operation against jboss instance through the CLI interface.
 
    jboss_config
           Configuration dictionary with properties specified above.
    operation
           An operation to execute against jboss instance
 
    fail_on_error (default=True)
           Is true, raise CommandExecutionException exception if execution fails.
           If false, 'success' property of the returned dictionary is set to False
    retries:
           Number of retries in case of "JBAS012144: Could not connect to remote" error.
 
    CLI Example:
 
        salt '*' jboss7_cli.run_operation '{"cli_path": "integration.modules.sysmod.SysModuleTest.test_valid_docs", "controller": "10.11.12.13:9999", "cli_user": "jbossadm", "cli_password": "jbossadm"}' my_operation
 
 
key.finger:
 
    Return the minion's public key fingerprint
 
    CLI Example:
 
        salt '*' key.finger
 
 
key.finger_master:
 
    Return the fingerprint of the master's public key on the minion.
 
    CLI Example:
 
        salt '*' key.finger_master
 
 
keyboard.get_sys:
 
    Get current system keyboard setting
 
    CLI Example:
 
        salt '*' keyboard.get_sys
 
 
keyboard.get_x:
 
    Get current X keyboard setting
 
    CLI Example:
 
        salt '*' keyboard.get_x
 
 
keyboard.set_sys:
 
    Set current system keyboard setting
 
    CLI Example:
 
        salt '*' keyboard.set_sys dvorak
 
 
keyboard.set_x:
 
    Set current X keyboard setting
 
    CLI Example:
 
        salt '*' keyboard.set_x dvorak
 
 
kmod.available:
 
    Return a list of all available kernel modules
 
    CLI Example:
 
        salt '*' kmod.available
 
 
kmod.check_available:
 
    Check to see if the specified kernel module is available
 
    CLI Example:
 
        salt '*' kmod.check_available kvm
 
 
kmod.is_loaded:
 
    Check to see if the specified kernel module is loaded
 
    CLI Example:
 
        salt '*' kmod.is_loaded kvm
 
 
kmod.load:
 
    Load the specified kernel module
 
    mod
        Name of module to add
 
    persist
        Write module to /etc/modules to make it load on system reboot
 
    CLI Example:
 
        salt '*' kmod.load kvm
 
 
kmod.lsmod:
 
    Return a dict containing information about currently loaded modules
 
    CLI Example:
 
        salt '*' kmod.lsmod
 
 
kmod.mod_list:
 
    Return a list of the loaded module names
 
    CLI Example:
 
        salt '*' kmod.mod_list
 
 
kmod.remove:
 
    Remove the specified kernel module
 
    mod
        Name of module to remove
 
    persist
        Also remove module from /etc/modules
 
    comment
        If persist is set don't remove line from /etc/modules but only
        comment it
 
    CLI Example:
 
        salt '*' kmod.remove kvm
 
 
locale.avail:
 
    Check if a locale is available.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' locale.avail 'en_US.UTF-8'
 
 
locale.gen_locale:
 
    Generate a locale. Options:
 
    New in version 2014.7.0
 
    :param locale: Any locale listed in /usr/share/i18n/locales or
        /usr/share/i18n/SUPPORTED for Debian and Gentoo based distributions,
        which require the charmap to be specified as part of the locale
        when generating it.
 
    verbose
        Show extra warnings about errors that are normally ignored.
 
    CLI Example:
 
        salt '*' locale.gen_locale en_US.UTF-8
        salt '*' locale.gen_locale 'en_IE.UTF-8 UTF-8'    # Debian/Gentoo only
 
 
locale.get_locale:
 
    Get the current system locale
 
    CLI Example:
 
        salt '*' locale.get_locale
 
 
locale.list_avail:
 
    Lists available (compiled) locales
 
    CLI Example:
 
        salt '*' locale.list_avail
 
 
locale.set_locale:
 
    Sets the current system locale
 
    CLI Example:
 
        salt '*' locale.set_locale 'en_US.UTF-8'
 
 
locate.locate:
 
    Performs a file lookup. Valid options (and their defaults) are::
 
        basename=False
        count=False
        existing=False
        follow=True
        ignore=False
        nofollow=False
        wholename=True
        regex=False
        database=<locate's default database>
        limit=<integer, not set by default>
 
    See the manpage for ``locate(1)`` for further explanation of these options.
 
    CLI Example:
 
        salt '*' locate.locate
 
 
locate.stats:
 
    Returns statistics about the locate database
 
    CLI Example:
 
        salt '*' locate.stats
 
 
locate.updatedb:
 
    Updates the locate database
 
    CLI Example:
 
        salt '*' locate.updatedb
 
 
locate.version:
 
    Returns the version of locate
 
    CLI Example:
 
        salt '*' locate.version
 
 
logrotate.set:
 
    Set a new value for a specific configuration line
 
    CLI Example:
 
        salt '*' logrotate.set rotate 2
 
    Can also be used to set a single value inside a multiline configuration
    block. For instance, to change rotate in the following block:
 
        /var/log/wtmp {
            monthly
            create 0664 root root
            rotate 1
        }
 
    Use the following command:
 
        salt '*' logrotate.set /var/log/wtmp rotate 2
 
    This module also has the ability to scan files inside an include directory,
    and make changes in the appropriate file.
 
 
logrotate.show_conf:
 
    Show parsed configuration
 
    CLI Example:
 
        salt '*' logrotate.show_conf
 
 
lowpkg.bin_pkg_info:
 
    New in version 2015.8.0
 
    Parses RPM metadata and returns a dictionary of information about the
    package (name, version, etc.).
 
    path
        Path to the file. Can either be an absolute path to a file on the
        minion, or a salt fileserver URL (e.g. ``salt://path/to/file.rpm``).
        If a salt fileserver URL is passed, the file will be cached to the
        minion so that it can be examined.
 
    saltenv : base
        Salt fileserver envrionment from which to retrieve the package. Ignored
        if ``path`` is a local file path on the minion.
 
    CLI Example:
 
        salt '*' lowpkg.bin_pkg_info /root/salt-2015.5.1-2.el7.noarch.rpm
        salt '*' lowpkg.bin_pkg_info salt://salt-2015.5.1-2.el7.noarch.rpm
 
 
lowpkg.diff:
 
    Return a formatted diff between current file and original in a package.
    NOTE: this function includes all files (configuration and not), but does
    not work on binary content.
 
    :param package: The name of the package
    :param path: Full path to the installed file
    :return: Difference or empty string. For binary files only a notification.
 
    CLI example:
 
        salt '*' lowpkg.diff apache2 /etc/apache2/httpd.conf
 
 
lowpkg.file_dict:
 
    List the files that belong to a package, sorted by group. Not specifying
    any packages will return a list of _every_ file on the system's rpm
    database (not generally recommended).
 
    CLI Examples:
 
        salt '*' lowpkg.file_dict httpd
        salt '*' lowpkg.file_dict httpd postfix
        salt '*' lowpkg.file_dict
 
 
lowpkg.file_list:
 
    List the files that belong to a package. Not specifying any packages will
    return a list of _every_ file on the system's rpm database (not generally
    recommended).
 
    CLI Examples:
 
        salt '*' lowpkg.file_list httpd
        salt '*' lowpkg.file_list httpd postfix
        salt '*' lowpkg.file_list
 
 
lowpkg.info:
 
    Return a detailed package(s) summary information.
    If no packages specified, all packages will be returned.
 
    :param packages:
 
    :param attr:
        Comma-separated package attributes. If no 'attr' is specified, all available attributes returned.
 
        Valid attributes are:
            version, vendor, release, build_date, build_date_time_t, install_date, install_date_time_t,
            build_host, group, source_rpm, arch, epoch, size, license, signature, packager, url, summary, description.
 
    :return:
 
    CLI example:
 
        salt '*' lowpkg.info apache2 bash
        salt '*' lowpkg.info apache2 bash attr=version
        salt '*' lowpkg.info apache2 bash attr=version,build_date_iso,size
 
 
lowpkg.list_pkgs:
 
    List the packages currently installed in a dict::
 
        {'<package_name>': '<version>'}
 
    CLI Example:
 
        salt '*' lowpkg.list_pkgs
 
 
lowpkg.modified:
 
    List the modified files that belong to a package. Not specifying any packages
    will return a list of _all_ modified files on the system's RPM database.
 
    New in version 2015.5.0
 
    CLI examples:
 
        salt '*' lowpkg.modified httpd
        salt '*' lowpkg.modified httpd postfix
        salt '*' lowpkg.modified
 
 
lowpkg.owner:
 
    Return the name of the package that owns the file. Multiple file paths can
    be passed. If a single path is passed, a string will be returned,
    and if multiple paths are passed, a dictionary of file/package name pairs
    will be returned.
 
    If the file is not owned by a package, or is not present on the minion,
    then an empty string will be returned for that path.
 
    CLI Examples:
 
        salt '*' lowpkg.owner /usr/bin/apachectl
        salt '*' lowpkg.owner /usr/bin/apachectl /etc/httpd/conf/httpd.conf
 
 
lowpkg.verify:
 
    Runs an rpm -Va on a system, and returns the results in a dict
 
    Files with an attribute of config, doc, ghost, license or readme in the
    package header can be ignored using the ``ignore_types`` keyword argument
 
    CLI Example:
 
        salt '*' lowpkg.verify
        salt '*' lowpkg.verify httpd
        salt '*' lowpkg.verify 'httpd postfix'
        salt '*' lowpkg.verify 'httpd postfix' ignore_types=['config','doc']
 
 
lvm.fullversion:
 
    Return all version info from lvm version
 
    CLI Example:
 
        salt '*' lvm.fullversion
 
 
lvm.lvcreate:
 
    Create a new logical volume, with option for which physical volume to be used
 
    CLI Examples:
 
        salt '*' lvm.lvcreate new_volume_name vg_name size=10G
        salt '*' lvm.lvcreate new_volume_name vg_name extents=100 pv=/dev/sdb
        salt '*' lvm.lvcreate new_snapshot    vg_name snapshot=volume_name size=3G
 
 
lvm.lvdisplay:
 
    Return information about the logical volume(s)
 
    CLI Examples:
 
        salt '*' lvm.lvdisplay
        salt '*' lvm.lvdisplay /dev/vg_myserver/root
 
 
lvm.lvremove:
 
    Remove a given existing logical volume from a named existing volume group
 
    CLI Example:
 
        salt '*' lvm.lvremove lvname vgname force=True
 
 
lvm.lvresize:
 
    Return information about the logical volume(s)
 
    CLI Examples:
 
 
        salt '*' lvm.lvresize +12M /dev/mapper/vg1-test
 
 
lvm.pvcreate:
 
    Set a physical device to be used as an LVM physical volume
 
    override
        Skip devices, if they are already an LVM physical volumes
 
    CLI Examples:
 
        salt mymachine lvm.pvcreate /dev/sdb1,/dev/sdb2
        salt mymachine lvm.pvcreate /dev/sdb1 dataalignmentoffset=7s
 
 
lvm.pvdisplay:
 
    Return information about the physical volume(s)
 
    CLI Examples:
 
        salt '*' lvm.pvdisplay
        salt '*' lvm.pvdisplay /dev/md0
 
 
lvm.pvremove:
 
    Remove a physical device being used as an LVM physical volume
 
    override
        Skip devices, if they are already not used as an LVM physical volumes
 
    CLI Examples:
 
        salt mymachine lvm.pvremove /dev/sdb1,/dev/sdb2
 
 
lvm.version:
 
    Return LVM version from lvm version
 
    CLI Example:
 
        salt '*' lvm.version
 
 
lvm.vgcreate:
 
    Create an LVM volume group
 
    CLI Examples:
 
        salt mymachine lvm.vgcreate my_vg /dev/sdb1,/dev/sdb2
        salt mymachine lvm.vgcreate my_vg /dev/sdb1 clustered=y
 
 
lvm.vgdisplay:
 
    Return information about the volume group(s)
 
    CLI Examples:
 
        salt '*' lvm.vgdisplay
        salt '*' lvm.vgdisplay nova-volumes
 
 
lvm.vgextend:
 
    Add physical volumes to an LVM volume group
 
    CLI Examples:
 
        salt mymachine lvm.vgextend my_vg /dev/sdb1,/dev/sdb2
        salt mymachine lvm.vgextend my_vg /dev/sdb1
 
 
lvm.vgremove:
 
    Remove an LVM volume group
 
    CLI Examples:
 
        salt mymachine lvm.vgremove vgname
        salt mymachine lvm.vgremove vgname force=True
 
 
match.compound:
 
    Return True if the minion ID matches the given compound target
 
    minion_id
        Specify the minion ID to match against the target expression
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' match.compound 'L@cheese,foo and *'
 
 
match.data:
 
    Return True if the minion matches the given data target
 
    CLI Example:
 
        salt '*' match.data 'spam:eggs'
 
 
match.filter_by:
 
    Return the first match in a dictionary of target patterns
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' match.filter_by '{foo*: Foo!, bar*: Bar!}' minion_id=bar03
 
    Pillar Example:
 
        {% set roles = salt['match.filter_by']({
            'web*': ['app', 'caching'],
            'db*': ['db'],
        }) %}
 
 
match.glob:
 
    Return True if the minion ID matches the given glob target
 
    minion_id
        Specify the minion ID to match against the target expression
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' match.glob '*'
 
 
match.grain:
 
    Return True if the minion matches the given grain target. The ``delimiter``
    argument can be used to specify a different delimiter.
 
    CLI Example:
 
        salt '*' match.grain 'os:Ubuntu'
        salt '*' match.grain 'ipv6|2001:db8::ff00:42:8329' delimiter='|'
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    delim
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 0.16.4
        .. deprecated:: 2015.8.0
 
 
match.grain_pcre:
 
    Return True if the minion matches the given grain_pcre target. The
    ``delimiter`` argument can be used to specify a different delimiter.
 
    CLI Example:
 
        salt '*' match.grain_pcre 'os:Fedo.*'
        salt '*' match.grain_pcre 'ipv6|2001:.*' delimiter='|'
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    delim
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 0.16.4
        .. deprecated:: 2015.8.0
 
 
match.ipcidr:
 
    Return True if the minion matches the given ipcidr target
 
    CLI Example:
 
        salt '*' match.ipcidr '192.168.44.0/24'
 
    delimiter
    Pillar Example:
 
       '172.16.0.0/12':
         - match: ipcidr
         - nodeclass: internal
 
 
 
match.list:
 
    Return True if the minion ID matches the given list target
 
    minion_id
        Specify the minion ID to match against the target expression
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' match.list 'server1,server2'
 
 
match.pcre:
 
    Return True if the minion ID matches the given pcre target
 
    minion_id
        Specify the minion ID to match against the target expression
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' match.pcre '.*'
 
 
match.pillar:
 
    Return True if the minion matches the given pillar target. The
    ``delimiter`` argument can be used to specify a different delimiter.
 
    CLI Example:
 
        salt '*' match.pillar 'cheese:foo'
        salt '*' match.pillar 'clone_url|https://github.com/saltstack/salt.git' delimiter='|'
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    delim
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 0.16.4
        .. deprecated:: 2015.8.0
 
 
match.pillar_pcre:
 
    Return True if the minion matches the given pillar_pcre target. The
    ``delimiter`` argument can be used to specify a different delimiter.
 
    CLI Example:
 
        salt '*' match.pillar_pcre 'cheese:(swiss|american)'
        salt '*' match.pillar_pcre 'clone_url|https://github\.com/.*\.git' delimiter='|'
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    delim
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 0.16.4
        .. deprecated:: 2015.8.0
 
 
mine.delete:
 
    Remove specific function contents of minion. Returns True on success.
 
    CLI Example:
 
        salt '*' mine.delete 'network.interfaces'
 
 
mine.flush:
 
    Remove all mine contents of minion. Returns True on success.
 
    CLI Example:
 
        salt '*' mine.flush
 
 
mine.get:
 
    Get data from the mine based on the target, function and expr_form
 
    Targets can be matched based on any standard matching system that can be
    matched on the master via these keywords::
 
        glob
        pcre
        grain
        grain_pcre
        compound
        pillar
        pillar_pcre
 
    Note that all pillar matches, whether using the compound matching system or
    the pillar matching system, will be exact matches, with globbing disabled.
 
    CLI Example:
 
        salt '*' mine.get '*' network.interfaces
        salt '*' mine.get 'os:Fedora' network.interfaces grain
        salt '*' mine.get 'os:Fedora and S@192.168.5.0/24' network.ipaddrs compound
 
 
mine.get_docker:
 
    Get all mine data for 'docker.get_containers' and run an aggregation
    routine. The "interfaces" parameter allows for specifying which network
    interfaces to select ip addresses from. The "cidrs" parameter allows for
    specifying a list of cidrs which the ip address must match.
 
    with_container_id
        Boolean, to expose container_id in the list of results
 
        New in version 2015.8.2
 
 
    CLI Example:
 
        salt '*' mine.get_docker
        salt '*' mine.get_docker interfaces='eth0'
        salt '*' mine.get_docker interfaces='["eth0", "eth1"]'
        salt '*' mine.get_docker cidrs='107.170.147.0/24'
        salt '*' mine.get_docker cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
        salt '*' mine.get_docker interfaces='["eth0", "eth1"]' cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
 
 
mine.send:
 
    Send a specific function to the mine.
 
    CLI Example:
 
        salt '*' mine.send network.ip_addrs eth0
        salt '*' mine.send eth0_ip_addrs mine_function=network.ip_addrs eth0
 
 
mine.update:
 
    Execute the configured functions and send the data back up to the master
    The functions to be executed are merged from the master config, pillar and
    minion config under the option "function_cache":
 
        mine_functions:
          network.ip_addrs:
            - eth0
          disk.usage: []
 
    The function cache will be populated with information from executing these
    functions
 
    CLI Example:
 
        salt '*' mine.update
 
 
modjk.bulk_activate:
 
    Activate all the given workers in the specific load balancer
 
    CLI Examples:
 
        salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1
        salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1 other-profile
 
        salt '*' modjk.bulk_activate ["node1","node2","node3"] loadbalancer1
        salt '*' modjk.bulk_activate ["node1","node2","node3"] loadbalancer1 other-profile
 
 
modjk.bulk_disable:
 
    Disable all the given workers in the specific load balancer
 
    CLI Examples:
 
        salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1
        salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1 other-profile
 
        salt '*' modjk.bulk_disable ["node1","node2","node3"] loadbalancer1
        salt '*' modjk.bulk_disable ["node1","node2","node3"] loadbalancer1 other-profile
 
 
modjk.bulk_recover:
 
    Recover all the given workers in the specific load balancer
 
    CLI Examples:
 
        salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1
        salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1 other-profile
 
        salt '*' modjk.bulk_recover ["node1","node2","node3"] loadbalancer1
        salt '*' modjk.bulk_recover ["node1","node2","node3"] loadbalancer1 other-profile
 
 
modjk.bulk_stop:
 
    Stop all the given workers in the specific load balancer
 
    CLI Examples:
 
        salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1
        salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1 other-profile
 
        salt '*' modjk.bulk_stop ["node1","node2","node3"] loadbalancer1
        salt '*' modjk.bulk_stop ["node1","node2","node3"] loadbalancer1 other-profile
 
 
modjk.dump_config:
 
    Dump the original configuration that was loaded from disk
 
    CLI Examples:
 
        salt '*' modjk.dump_config
        salt '*' modjk.dump_config other-profile
 
 
modjk.get_running:
 
    Get the current running config (not from disk)
 
    CLI Examples:
 
        salt '*' modjk.get_running
        salt '*' modjk.get_running other-profile
 
 
modjk.lb_edit:
 
    Edit the loadbalancer settings
 
    Note: http://tomcat.apache.org/connectors-doc/reference/status.html
    Data Parameters for the standard Update Action
 
    CLI Examples:
 
        salt '*' modjk.lb_edit loadbalancer1 "{'vlr': 1, 'vlt': 60}"
        salt '*' modjk.lb_edit loadbalancer1 "{'vlr': 1, 'vlt': 60}" other-profile
 
 
modjk.list_configured_members:
 
    Return a list of member workers from the configuration files
 
    CLI Examples:
 
        salt '*' modjk.list_configured_members loadbalancer1
        salt '*' modjk.list_configured_members loadbalancer1 other-profile
 
 
modjk.recover_all:
 
    Set the all the workers in lbn to recover and activate them if they are not
 
    CLI Examples:
 
        salt '*' modjk.recover_all loadbalancer1
        salt '*' modjk.recover_all loadbalancer1 other-profile
 
 
modjk.reset_stats:
 
    Reset all runtime statistics for the load balancer
 
    CLI Examples:
 
        salt '*' modjk.reset_stats loadbalancer1
        salt '*' modjk.reset_stats loadbalancer1 other-profile
 
 
modjk.version:
 
    Return the modjk version
 
    CLI Examples:
 
        salt '*' modjk.version
        salt '*' modjk.version other-profile
 
 
modjk.worker_activate:
 
    Set the worker to activate state in the lbn load balancer
 
    CLI Examples:
 
        salt '*' modjk.worker_activate node1 loadbalancer1
        salt '*' modjk.worker_activate node1 loadbalancer1 other-profile
 
 
modjk.worker_disable:
 
    Set the worker to disable state in the lbn load balancer
 
    CLI Examples:
 
        salt '*' modjk.worker_disable node1 loadbalancer1
        salt '*' modjk.worker_disable node1 loadbalancer1 other-profile
 
 
modjk.worker_edit:
 
    Edit the worker settings
 
    Note: http://tomcat.apache.org/connectors-doc/reference/status.html
    Data Parameters for the standard Update Action
 
    CLI Examples:
 
        salt '*' modjk.worker_edit node1 loadbalancer1 "{'vwf': 500, 'vwd': 60}"
        salt '*' modjk.worker_edit node1 loadbalancer1 "{'vwf': 500, 'vwd': 60}" other-profile
 
 
modjk.worker_recover:
 
    Set the worker to recover
    this module will fail if it is in OK state
 
    CLI Examples:
 
        salt '*' modjk.worker_recover node1 loadbalancer1
        salt '*' modjk.worker_recover node1 loadbalancer1 other-profile
 
 
modjk.worker_status:
 
    Return the state of the worker
 
    CLI Examples:
 
        salt '*' modjk.worker_status node1
        salt '*' modjk.worker_status node1 other-profile
 
 
modjk.worker_stop:
 
    Set the worker to stopped state in the lbn load balancer
 
    CLI Examples:
 
        salt '*' modjk.worker_activate node1 loadbalancer1
        salt '*' modjk.worker_activate node1 loadbalancer1 other-profile
 
 
modjk.workers:
 
    Return a list of member workers and their status
 
    CLI Examples:
 
        salt '*' modjk.workers
        salt '*' modjk.workers other-profile
 
 
mount.active:
 
    List the active mounts.
 
    CLI Example:
 
        salt '*' mount.active
 
 
mount.automaster:
 
    List the contents of the fstab
 
    CLI Example:
 
        salt '*' mount.fstab
 
 
mount.fstab:
 
    List the contents of the fstab
 
    CLI Example:
 
        salt '*' mount.fstab
 
 
mount.is_fuse_exec:
 
    Returns true if the command passed is a fuse mountable application.
 
    CLI Example:
 
        salt '*' mount.is_fuse_exec sshfs
 
 
mount.is_mounted:
 
    New in version 2014.7.0
 
    Provide information if the path is mounted
 
    CLI Example:
 
        salt '*' mount.is_mounted /mnt/share
 
 
mount.mount:
 
    Mount a device
 
    CLI Example:
 
        salt '*' mount.mount /mnt/foo /dev/sdz1 True
 
 
mount.remount:
 
    Attempt to remount a device, if the device is not already mounted, mount
    is called
 
    CLI Example:
 
        salt '*' mount.remount /mnt/foo /dev/sdz1 True
 
 
mount.rm_automaster:
 
    Remove the mount point from the auto_master
 
    CLI Example:
 
        salt '*' mount.rm_automaster /mnt/foo
 
 
mount.rm_fstab:
 
    Remove the mount point from the fstab
 
    CLI Example:
 
        salt '*' mount.rm_fstab /mnt/foo
 
 
mount.set_automaster:
 
    Verify that this mount is represented in the auto_salt, change the mount
    to match the data passed, or add the mount if it is not present.
 
    CLI Example:
 
        salt '*' mount.set_automaster /mnt/foo /dev/sdz1 ext4
 
 
mount.set_fstab:
 
    Verify that this mount is represented in the fstab, change the mount
    to match the data passed, or add the mount if it is not present.
 
    CLI Example:
 
        salt '*' mount.set_fstab /mnt/foo /dev/sdz1 ext4
 
 
mount.swapoff:
 
    Deactivate a named swap mount
 
    CLI Example:
 
        salt '*' mount.swapoff /root/swapfile
 
 
mount.swapon:
 
    Activate a swap disk
 
    CLI Example:
 
        salt '*' mount.swapon /root/swapfile
 
 
mount.swaps:
 
    Return a dict containing information on active swap
 
    CLI Example:
 
        salt '*' mount.swaps
 
 
mount.umount:
 
    Attempt to unmount a device by specifying the directory it is mounted on
 
    CLI Example:
 
        salt '*' mount.umount /mnt/foo
 
        New in version 2015.5.0
 
        salt '*' mount.umount /mnt/foo /dev/xvdc1
 
 
nagios_rpc.host_status:
 
    Check status of a particular host By default
    statuses are returned in a numeric format.
 
    Parameters:
 
    hostname
        The hostname to check the status of the service in Nagios.
 
    numeric
        Turn to false in order to return status in text format
        ('OK' instead of 0, 'Warning' instead of 1 etc)
 
    :return: status:     'OK', 'Warning', 'Critical' or 'Unknown'
 
    CLI Example:
 
        salt '*' nagios_rpc.host_status hostname=webserver.domain.com
        salt '*' nagios_rpc.host_status hostname=webserver.domain.com numeric=False
 
 
nagios_rpc.service_status:
 
    Check status of a particular service on a host on it in Nagios.
    By default statuses are returned in a numeric format.
 
    Parameters:
 
    hostname
        The hostname to check the status of the service in Nagios.
 
    service
        The service to check the status of in Nagios.
 
    numeric
        Turn to false in order to return status in text format
        ('OK' instead of 0, 'Warning' instead of 1 etc)
 
    :return: status:     'OK', 'Warning', 'Critical' or 'Unknown'
 
    CLI Example:
 
        salt '*' nagios_rpc.service_status hostname=webserver.domain.com service='HTTP'
        salt '*' nagios_rpc.service_status hostname=webserver.domain.com service='HTTP' numeric=False
 
 
network.active_tcp:
 
    Return a dict containing information on all of the running TCP connections (currently linux and solaris only)
 
    Changed in version 2015.8.4
 
        Added support for SunOS
 
    CLI Example:
 
        salt '*' network.active_tcp
 
 
network.arp:
 
    Return the arp table from the minion
 
    Changed in version 2015.8.0
        Added support for SunOS
 
    CLI Example:
 
        salt '*' network.arp
 
 
network.calc_net:
 
    Returns the CIDR of a subnet based on
    an IP address (CIDR notation supported)
    and optional netmask.
 
    CLI Example:
 
        salt '*' network.calc_net 172.17.0.5 255.255.255.240
        salt '*' network.calc_net 2a02:f6e:a000:80:84d8:8332:7866:4e07/64
 
    New in version 2015.8.0
 
 
network.connect:
 
    Test connectivity to a host using a particular
    port from the minion.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' network.connect archlinux.org 80
 
        salt '*' network.connect archlinux.org 80 timeout=3
 
        salt '*' network.connect archlinux.org 80 timeout=3 family=ipv4
 
        salt '*' network.connect google-public-dns-a.google.com port=53 proto=udp timeout=3
 
 
network.default_route:
 
    Return default route(s) from routing table
 
    Changed in version 2015.8.0
        Added support for SunOS (Solaris 10, Illumos, SmartOS)
 
    CLI Example:
 
        salt '*' network.default_route
 
 
network.dig:
 
    Performs a DNS lookup with dig
 
    CLI Example:
 
        salt '*' network.dig archlinux.org
 
 
network.get_bufsize:
 
    Return network buffer sizes as a dict (currently linux only)
 
    CLI Example:
 
        salt '*' network.get_bufsize
 
 
network.get_hostname:
 
    Get hostname
 
    CLI Example:
 
        salt '*' network.get_hostname
 
 
network.get_route:
 
    Return routing information for given destination ip
 
    New in version 2015.5.3
 
    Changed in version 2015.8.0
        Added support for SunOS (Solaris 10, Illumos, SmartOS)
        Added support for OpenBSD
 
    CLI Example::
 
        salt '*' network.get_route 10.10.10.10
 
 
network.hw_addr:
 
    Return the hardware address (a.k.a. MAC address) for a given interface
 
    CLI Example:
 
        salt '*' network.hw_addr eth0
 
 
network.hwaddr:
 
This function is an alias of ``hw_addr``.
 
    Return the hardware address (a.k.a. MAC address) for a given interface
 
    CLI Example:
 
        salt '*' network.hw_addr eth0
 
 
network.in_subnet:
 
    Returns True if host is within specified subnet, otherwise False.
 
    CLI Example:
 
        salt '*' network.in_subnet 10.0.0.0/16
 
 
network.interface:
 
    Return the inet address for a given interface
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' network.interface eth0
 
 
network.interface_ip:
 
    Return the inet address for a given interface
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' network.interface_ip eth0
 
 
network.interfaces:
 
    Return a dictionary of information about all the interfaces on the minion
 
    CLI Example:
 
        salt '*' network.interfaces
 
 
network.ip_addrs:
 
    Returns a list of IPv4 addresses assigned to the host. 127.0.0.1 is
    ignored, unless 'include_loopback=True' is indicated. If 'interface' is
    provided, then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr="10.0.0.0/8"' will return only the addresses
    which are within that subnet.
 
    CLI Example:
 
        salt '*' network.ip_addrs
 
 
network.ip_addrs6:
 
    Returns a list of IPv6 addresses assigned to the host. ::1 is ignored,
    unless 'include_loopback=True' is indicated. If 'interface' is provided,
    then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr="2000::/3"' will return only the addresses
    which are within that subnet.
 
    CLI Example:
 
        salt '*' network.ip_addrs6
 
 
network.ip_in_subnet:
 
    Returns True if given IP is within specified subnet, otherwise False.
 
    CLI Example:
 
        salt '*' network.ip_in_subnet 172.17.0.4 172.16.0.0/12
 
 
network.ipaddrs:
 
This function is an alias of ``ip_addrs``.
 
    Returns a list of IPv4 addresses assigned to the host. 127.0.0.1 is
    ignored, unless 'include_loopback=True' is indicated. If 'interface' is
    provided, then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr="10.0.0.0/8"' will return only the addresses
    which are within that subnet.
 
    CLI Example:
 
        salt '*' network.ip_addrs
 
 
network.ipaddrs6:
 
This function is an alias of ``ip_addrs6``.
 
    Returns a list of IPv6 addresses assigned to the host. ::1 is ignored,
    unless 'include_loopback=True' is indicated. If 'interface' is provided,
    then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr="2000::/3"' will return only the addresses
    which are within that subnet.
 
    CLI Example:
 
        salt '*' network.ip_addrs6
 
 
network.is_loopback:
 
    Check if the given IP address is a loopback address
 
    New in version 2014.7.0
    Changed in version 2015.8.0
        IPv6 support
 
    CLI Example:
 
        salt '*' network.is_loopback 127.0.0.1
 
 
network.is_private:
 
    Check if the given IP address is a private address
 
    New in version 2014.7.0
    Changed in version 2015.8.0
        IPv6 support
 
    CLI Example:
 
        salt '*' network.is_private 10.0.0.3
 
 
network.mod_bufsize:
 
    Modify network interface buffers (currently linux only)
 
    CLI Example:
 
        salt '*' network.mod_bufsize tx=<val> rx=<val> rx-mini=<val> rx-jumbo=<val>
 
 
network.mod_hostname:
 
    Modify hostname
 
    Changed in version 2015.8.0
        Added support for SunOS (Solaris 10, Illumos, SmartOS)
 
    CLI Example:
 
        salt '*' network.mod_hostname master.saltstack.com
 
 
network.netstat:
 
    Return information on open ports and states
 
    Note:
        On BSD minions, the output contains PID info (where available) for each
        netstat entry, fetched from sockstat/fstat output.
 
    Changed in version 2014.1.4
        Added support for OpenBSD, FreeBSD, and NetBSD
 
    Changed in version 2015.8.0
        Added support for SunOS
 
    CLI Example:
 
        salt '*' network.netstat
 
 
network.ping:
 
    Performs an ICMP ping to a host
 
    Changed in version 2015.8.0
        Added support for SunOS
 
    CLI Example:
 
        salt '*' network.ping archlinux.org
 
    New in version 2015.5.0
 
    Return a True or False instead of ping output.
 
        salt '*' network.ping archlinux.org return_boolean=True
 
    Set the time to wait for a response in seconds.
 
        salt '*' network.ping archlinux.org timeout=3
 
 
network.reverse_ip:
 
    Returns the reversed IP address
 
    Changed in version 2015.8.0
        IPv6 support
 
    CLI Example:
 
        salt '*' network.reverse_ip 172.17.0.4
 
 
network.routes:
 
    Return currently configured routes from routing table
 
    Changed in version 2015.8.0
        Added support for SunOS (Solaris 10, Illumos, SmartOS)
 
    CLI Example:
 
        salt '*' network.routes
 
 
network.subnets:
 
    Returns a list of IPv4 subnets to which the host belongs
 
    CLI Example:
 
        salt '*' network.subnets
        salt '*' network.subnets interfaces=eth1
 
 
network.subnets6:
 
    Returns a list of IPv6 subnets to which the host belongs
 
    CLI Example:
 
        salt '*' network.subnets
 
 
network.traceroute:
 
    Performs a traceroute to a 3rd party host
 
    Changed in version 2015.8.0
        Added support for SunOS
 
    CLI Example:
 
        salt '*' network.traceroute archlinux.org
 
 
network.wol:
 
    Send Wake On Lan packet to a host
 
    CLI Example:
 
        salt '*' network.wol 08-00-27-13-69-77
        salt '*' network.wol 080027136977 255.255.255.255 7
        salt '*' network.wol 08:00:27:13:69:77 255.255.255.255 7
 
 
nginx.build_info:
 
    Return server and build arguments
 
    CLI Example:
 
        salt '*' nginx.build_info
 
 
nginx.configtest:
 
    test configuration and exit
 
    CLI Example:
 
        salt '*' nginx.configtest
 
 
nginx.signal:
 
    Signals nginx to start, reload, reopen or stop.
 
    CLI Example:
 
        salt '*' nginx.signal reload
 
 
nginx.status:
 
    Return the data from an Nginx status page as a dictionary.
    http://wiki.nginx.org/HttpStubStatusModule
 
    url
        The URL of the status page. Defaults to 'http://127.0.0.1/status'
 
    CLI Example:
 
        salt '*' nginx.status
 
 
nginx.version:
 
    Return server version from nginx -v
 
    CLI Example:
 
        salt '*' nginx.version
 
 
node.inspect:
 
    Start node inspection and save the data to the database for further query.
 
    Parameters:
 
    * **mode**: Clarify inspection mode: configuration, payload, all (default)
 
      payload
        * **filter**: Comma-separated directories to track payload.
 
    * **priority**: (advanced) Set priority of the inspection. Default is low priority.
 
 
 
    CLI Example:
 
        salt '*' node.inspect
        salt '*' node.inspect configuration
        salt '*' node.inspect payload filter=/opt,/ext/oracle
 
 
node.query:
 
    Query the node for specific information.
 
    Parameters:
 
    * **scope**: Specify scope of the query.
 
       * **System**: Return system data.
 
       * **Software**: Return software information.
 
       * **Services**: Return known services.
 
       * **Identity**: Return user accounts information for this system.
          accounts
            Can be either 'local', 'remote' or 'all' (equal to "local,remote").
            Remote accounts cannot be resolved on all systems, but only
            those, which supports 'passwd -S -a'.
 
          disabled
            True (or False, default) to return only disabled accounts.
 
       * **payload**: Payload scope parameters:
          filter
            Include only results which path starts from the filter string.
 
          time
            Display time in Unix ticks or format according to the configured TZ (default)
            Values: ticks, tz (default)
 
          size
            Format size. Values: B, KB, MB, GB
 
          type
            Include payload type.
            Values (comma-separated): directory (or dir), link, file (default)
            Example (returns everything): type=directory,link,file
 
          owners
            Resolve UID/GID to an actual names or leave them numeric (default).
            Values: name (default), id
 
          brief
            Return just a list of payload elements, if True. Default: False.
 
       * **all**: Return all information (default).
 
    CLI Example:
 
        salt '*' node.query scope=os
        salt '*' node.query payload type=file,link filter=/etc size=Kb brief=False
 
 
nspawn.bootstrap_container:
 
    Bootstrap a container from package servers, if dist is None the os the
    minion is running as will be created, otherwise the needed bootstrapping
    tools will need to be available on the host.
 
    CLI Example:
 
        salt myminion nspawn.bootstrap_container <name>
 
 
nspawn.bootstrap_salt:
 
    Bootstrap a container from package servers, if dist is None the os the
    minion is running as will be created, otherwise the needed bootstrapping
    tools will need to be available on the host.
 
    CLI Example::
 
        salt '*' nspawn.bootstrap_salt arch1
 
 
nspawn.copy_to:
 
    Copy a file from the host into a container
 
    name
        Container name
 
    source
        File to be copied to the container
 
    dest
        Destination on the container. Must be an absolute path.
 
    overwrite : False
        Unless this option is set to ``True``, then if a file exists at the
        location specified by the ``dest`` argument, an error will be raised.
 
    makedirs : False
 
        Create the parent directory on the container if it does not already
        exist.
 
    CLI Example:
 
        salt 'minion' nspawn.copy_to /tmp/foo /root/foo
 
 
nspawn.cp:
 
This function is an alias of ``copy_to``.
 
    Copy a file from the host into a container
 
    name
        Container name
 
    source
        File to be copied to the container
 
    dest
        Destination on the container. Must be an absolute path.
 
    overwrite : False
        Unless this option is set to ``True``, then if a file exists at the
        location specified by the ``dest`` argument, an error will be raised.
 
    makedirs : False
 
        Create the parent directory on the container if it does not already
        exist.
 
    CLI Example:
 
        salt 'minion' nspawn.copy_to /tmp/foo /root/foo
 
 
nspawn.destroy:
 
This function is an alias of ``remove``.
 
    Remove the named container
 
    Warning:
 
        This function will remove all data associated with the container. It
        will not, however, remove the btrfs subvolumes created by pulling
        container images (:mod:`nspawn.pull_raw
        <salt.modules.nspawn.pull_raw>`, :mod:`nspawn.pull_tar
        <salt.modules.nspawn.pull_tar>`, :mod:`nspawn.pull_dkr
        <salt.modules.nspawn.pull_dkr>`).
 
    stop : False
        If ``True``, the container will be destroyed even if it is
        running/frozen.
 
    CLI Examples:
 
        salt '*' nspawn.remove foo
        salt '*' nspawn.remove foo stop=True
 
 
nspawn.disable:
 
    Set the named container to *not* be launched at boot
 
    CLI Example:
 
        salt myminion nspawn.enable <name>
 
 
nspawn.enable:
 
    Set the named container to be launched at boot
 
    CLI Example:
 
        salt myminion nspawn.enable <name>
 
 
nspawn.exists:
 
    Returns true if the named container exists
 
    CLI Example:
 
        salt myminion nspawn.exists <name>
 
 
nspawn.info:
 
    Return info about a container
 
    Note:
 
        The container must be running for ``machinectl`` to gather information
        about it. If the container is stopped, then this function will start
        it.
 
    start : False
        If ``True``, then the container will be started to retrieve the info. A
        ``Started`` key will be in the return data if the container was
        started.
 
    CLI Example:
 
        salt myminion nspawn.info arch1
        salt myminion nspawn.info arch1 force_start=False
 
 
nspawn.list:
 
This function is an alias of ``list_running``.
 
    Lists running nspawn containers
 
    Note:
 
        ``nspawn.list`` also works to list running containers
 
    CLI Example:
 
        salt myminion nspawn.list_running
        salt myminion nspawn.list
 
 
nspawn.list_all:
 
    Lists all nspawn containers
 
    CLI Example:
 
        salt myminion nspawn.list_all
 
 
nspawn.list_running:
 
    Lists running nspawn containers
 
    Note:
 
        ``nspawn.list`` also works to list running containers
 
    CLI Example:
 
        salt myminion nspawn.list_running
        salt myminion nspawn.list
 
 
nspawn.list_stopped:
 
    Lists stopped nspawn containers
 
    CLI Example:
 
        salt myminion nspawn.list_stopped
 
 
nspawn.pid:
 
    Returns the PID of a container
 
    name
        Container name
 
    CLI Example:
 
        salt myminion nspawn.pid arch1
 
 
nspawn.poweroff:
 
    Issue a clean shutdown to the container.  Equivalent to running
    ``machinectl poweroff`` on the named container.
 
    For convenience, running ``nspawn.stop``(as shown in the CLI examples
    below) is equivalent to running ``nspawn.poweroff``.
 
    Note:
 
        ``machinectl poweroff`` is only supported in systemd >= 219. On earlier
        systemd versions, running this function will simply issue a clean
        shutdown via ``systemctl``.
 
    CLI Examples:
 
        salt myminion nspawn.poweroff arch1
        salt myminion nspawn.stop arch1
 
 
nspawn.pull_dkr:
 
    Execute a ``machinectl pull-dkr`` to download a docker image and add it to
    /var/lib/machines as a new container.
 
    Note:
 
        **Requires systemd >= 219**
 
    url
        URL from which to download the container
 
    name
        Name for the new container
 
    index
        URL of the Docker index server from which to pull (must be an
        ``http://`` or ``https://`` URL).
 
    CLI Examples:
 
        salt myminion nspawn.pull_dkr centos/centos6 cent6 index=https://get.docker.com
        salt myminion nspawn.pull_docker centos/centos6 cent6 index=https://get.docker.com
 
 
nspawn.pull_docker:
 
This function is an alias of ``pull_dkr``.
 
    Execute a ``machinectl pull-dkr`` to download a docker image and add it to
    /var/lib/machines as a new container.
 
    Note:
 
        **Requires systemd >= 219**
 
    url
        URL from which to download the container
 
    name
        Name for the new container
 
    index
        URL of the Docker index server from which to pull (must be an
        ``http://`` or ``https://`` URL).
 
    CLI Examples:
 
        salt myminion nspawn.pull_dkr centos/centos6 cent6 index=https://get.docker.com
        salt myminion nspawn.pull_docker centos/centos6 cent6 index=https://get.docker.com
 
 
nspawn.pull_raw:
 
    Execute a ``machinectl pull-raw`` to download a .qcow2 or raw disk image,
    and add it to /var/lib/machines as a new container.
 
    Note:
 
        **Requires systemd >= 219**
 
    url
        URL from which to download the container
 
    name
        Name for the new container
 
    verify : False
        Perform signature or checksum verification on the container. See the
        ``machinectl(1)`` man page (section titled "Image Transfer Commands")
        for more information on requirements for image verification. To perform
        signature verification, use ``verify=signature``. For checksum
        verification, use ``verify=checksum``. By default, no verification will
        be performed.
 
    CLI Examples:
 
        salt myminion nspawn.pull_raw http://ftp.halifax.rwth-aachen.de/fedora/linux/releases/21/Cloud/Images/x86_64/Fedora-Cloud-Base-20141203-21.x86_64.raw.xz fedora21
 
 
nspawn.pull_tar:
 
    Execute a ``machinectl pull-raw`` to download a .tar container image,
    and add it to /var/lib/machines as a new container.
 
    Note:
 
        **Requires systemd >= 219**
 
    url
        URL from which to download the container
 
    name
        Name for the new container
 
    verify : False
        Perform signature or checksum verification on the container. See the
        ``machinectl(1)`` man page (section titled "Image Transfer Commands")
        for more information on requirements for image verification. To perform
        signature verification, use ``verify=signature``. For checksum
        verification, use ``verify=checksum``. By default, no verification will
        be performed.
 
    CLI Examples:
 
        salt myminion nspawn.pull_tar http://foo.domain.tld/containers/archlinux-2015.02.01.tar.gz arch2
 
 
nspawn.reboot:
 
    Reboot the container by sending a SIGINT to its init process. Equivalent
    to running ``machinectl reboot`` on the named container.
 
    For convenience, running ``nspawn.restart`` (as shown in the CLI examples
    below) is equivalent to running ``nspawn.reboot``.
 
    Note:
 
        ``machinectl reboot`` is only supported in systemd >= 219. On earlier
        systemd versions, running this function will instead restart the
        container via ``systemctl``.
 
    CLI Examples:
 
        salt myminion nspawn.reboot arch1
        salt myminion nspawn.restart arch1
 
 
nspawn.remove:
 
    Remove the named container
 
    Warning:
 
        This function will remove all data associated with the container. It
        will not, however, remove the btrfs subvolumes created by pulling
        container images (:mod:`nspawn.pull_raw
        <salt.modules.nspawn.pull_raw>`, :mod:`nspawn.pull_tar
        <salt.modules.nspawn.pull_tar>`, :mod:`nspawn.pull_dkr
        <salt.modules.nspawn.pull_dkr>`).
 
    stop : False
        If ``True``, the container will be destroyed even if it is
        running/frozen.
 
    CLI Examples:
 
        salt '*' nspawn.remove foo
        salt '*' nspawn.remove foo stop=True
 
 
nspawn.restart:
 
    This is a compatibility function which simply calls nspawn.reboot.
 
 
nspawn.retcode:
 
    Run :mod:`cmd.retcode <salt.modules.cmdmod.retcode>` within a container
 
    name
        Name of the container in which to run the command
 
    cmd
        Command to run
 
    no_start : False
        If the container is not running, don't start it
 
    preserve_state : True
        After running the command, return the container to its previous state
 
    stdin : None
        Standard input to be used for the command
 
    output_loglevel : debug
        Level at which to log the output from the command. Set to ``quiet`` to
        suppress logging.
 
    use_vt : False
        Use SaltStack's utils.vt to stream output to console. Assumes
        ``output=all``.
 
    keep_env : None
        If not passed, only a sane default PATH environment variable will be
        set. If ``True``, all environment variables from the container's host
        will be kept. Otherwise, a comma-separated list (or Python list) of
        environment variable names can be passed, and those environment
        variables will be kept.
 
 
    CLI Example:
 
        salt myminion nspawn.retcode mycontainer 'ip addr show'
 
 
nspawn.run:
 
    Run :mod:`cmd.run <salt.modules.cmdmod.run>` within a container
 
    name
        Name of the container in which to run the command
 
    cmd
        Command to run
 
    no_start : False
        If the container is not running, don't start it
 
    preserve_state : True
        After running the command, return the container to its previous state
 
    stdin : None
        Standard input to be used for the command
 
    output_loglevel : debug
        Level at which to log the output from the command. Set to ``quiet`` to
        suppress logging.
 
    use_vt : False
        Use SaltStack's utils.vt to stream output to console.
 
    keep_env : None
        If not passed, only a sane default PATH environment variable will be
        set. If ``True``, all environment variables from the container's host
        will be kept. Otherwise, a comma-separated list (or Python list) of
        environment variable names can be passed, and those environment
        variables will be kept.
 
    CLI Example:
 
        salt myminion nspawn.run mycontainer 'ifconfig -a'
 
 
nspawn.run_all:
 
    Run :mod:`cmd.run_all <salt.modules.cmdmod.run_all>` within a container
 
    Note:
 
        While the command is run within the container, it is initiated from the
        host. Therefore, the PID in the return dict is from the host, not from
        the container.
 
    name
        Name of the container in which to run the command
 
    cmd
        Command to run
 
    no_start : False
        If the container is not running, don't start it
 
    preserve_state : True
        After running the command, return the container to its previous state
 
    stdin : None
        Standard input to be used for the command
 
    output_loglevel : debug
        Level at which to log the output from the command. Set to ``quiet`` to
        suppress logging.
 
    use_vt : False
        Use SaltStack's utils.vt to stream output to console. Assumes
        ``output=all``.
 
    keep_env : None
        If not passed, only a sane default PATH environment variable will be
        set. If ``True``, all environment variables from the container's host
        will be kept. Otherwise, a comma-separated list (or Python list) of
        environment variable names can be passed, and those environment
        variables will be kept.
 
 
    CLI Example:
 
        salt myminion nspawn.run_all mycontainer 'ip addr show'
 
 
nspawn.run_stderr:
 
    Run :mod:`cmd.run_stderr <salt.modules.cmdmod.run_stderr>` within a container
 
    name
        Name of the container in which to run the command
 
    cmd
        Command to run
 
    no_start : False
        If the container is not running, don't start it
 
    preserve_state : True
        After running the command, return the container to its previous state
 
    stdin : None
        Standard input to be used for the command
 
    output_loglevel : debug
        Level at which to log the output from the command. Set to ``quiet`` to
        suppress logging.
 
    use_vt : False
        Use SaltStack's utils.vt to stream output to console. Assumes
        ``output=all``.
 
    keep_env : None
        If not passed, only a sane default PATH environment variable will be
        set. If ``True``, all environment variables from the container's host
        will be kept. Otherwise, a comma-separated list (or Python list) of
        environment variable names can be passed, and those environment
        variables will be kept.
 
 
    CLI Example:
 
        salt myminion nspawn.run_stderr mycontainer 'ip addr show'
 
 
nspawn.run_stdout:
 
    Run :mod:`cmd.run_stdout <salt.modules.cmdmod.run_stdout>` within a container
 
    name
        Name of the container in which to run the command
 
    cmd
        Command to run
 
    no_start : False
        If the container is not running, don't start it
 
    preserve_state : True
        After running the command, return the container to its previous state
 
    stdin : None
        Standard input to be used for the command
 
    output_loglevel : debug
        Level at which to log the output from the command. Set to ``quiet`` to
        suppress logging.
 
    use_vt : False
        Use SaltStack's utils.vt to stream output to console. Assumes
        ``output=all``.
 
    keep_env : None
        If not passed, only a sane default PATH environment variable will be
        set. If ``True``, all environment variables from the container's host
        will be kept. Otherwise, a comma-separated list (or Python list) of
        environment variable names can be passed, and those environment
        variables will be kept.
 
 
    CLI Example:
 
        salt myminion nspawn.run_stdout mycontainer 'ifconfig -a'
 
 
nspawn.start:
 
    Start the named container
 
    CLI Example:
 
        salt myminion nspawn.start <name>
 
 
nspawn.state:
 
    Return state of container (running or stopped)
 
    CLI Example:
 
        salt myminion nspawn.state <name>
 
 
nspawn.stop:
 
    This is a compatibility function which provides the logic for
    nspawn.poweroff and nspawn.terminate.
 
 
nspawn.terminate:
 
    Kill all processes in the container without issuing a clean shutdown.
    Equivalent to running ``machinectl terminate`` on the named container.
 
    For convenience, running ``nspawn.stop`` and passing ``kill=True`` (as
    shown in the CLI examples below) is equivalent to running
    ``nspawn.terminate``.
 
    Note:
 
        ``machinectl terminate`` is only supported in systemd >= 219. On
        earlier systemd versions, running this function will simply issue a
        clean shutdown via ``systemctl``.
 
    CLI Examples:
 
        salt myminion nspawn.terminate arch1
        salt myminion nspawn.stop arch1 kill=True
 
 
openstack_config.delete:
 
    Delete a value from an OpenStack configuration file.
 
    filename
        The full path to the configuration file
 
    section
        The section from which to delete the parameter
 
    parameter
        The parameter to delete
 
    CLI Example:
 
        salt-call openstack_config.delete /etc/keystone/keystone.conf sql connection
 
 
openstack_config.get:
 
    Get a value from an OpenStack configuration file.
 
    filename
        The full path to the configuration file
 
    section
        The section from which to search for the parameter
 
    parameter
        The parameter to return
 
    CLI Example:
 
        salt-call openstack_config.get /etc/keystone/keystone.conf sql connection
 
 
 
openstack_config.set:
 
    Set a value in an OpenStack configuration file.
 
    filename
        The full path to the configuration file
 
    section
        The section in which the parameter will be set
 
    parameter
        The parameter to change
 
    value
        The value to set
 
    CLI Example:
 
        salt-call openstack_config.set /etc/keystone/keystone.conf sql connection foo
 
 
pagerduty.create_event:
 
    Create an event in PagerDuty. Designed for use in states.
 
    CLI Example:
 
        salt myminion pagerduty.create_event <service_key> <description> <details>         profile=my-pagerduty-account
 
    The following parameters are required:
 
    service_key
        This key can be found by using pagerduty.list_services.
 
    description
        This is a short description of the event.
 
    details
        This can be a more detailed description of the event.
 
    profile
        This refers to the configuration profile to use to connect to the
        PagerDuty service.
 
 
pagerduty.list_escalation_policies:
 
This function is an alias of ``list_policies``.
 
    List escalation policies belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_policies my-pagerduty-account
        salt myminion pagerduty.list_escalation_policies my-pagerduty-account
 
 
pagerduty.list_incidents:
 
    List incidents belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_incidents my-pagerduty-account
 
 
pagerduty.list_maintenance_windows:
 
This function is an alias of ``list_windows``.
 
    List maintenance windows belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_windows my-pagerduty-account
        salt myminion pagerduty.list_maintenance_windows my-pagerduty-account
 
 
pagerduty.list_policies:
 
    List escalation policies belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_policies my-pagerduty-account
        salt myminion pagerduty.list_escalation_policies my-pagerduty-account
 
 
pagerduty.list_schedules:
 
    List schedules belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_schedules my-pagerduty-account
 
 
pagerduty.list_services:
 
    List services belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_services my-pagerduty-account
 
 
pagerduty.list_users:
 
    List users belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_users my-pagerduty-account
 
 
pagerduty.list_windows:
 
    List maintenance windows belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.list_windows my-pagerduty-account
        salt myminion pagerduty.list_maintenance_windows my-pagerduty-account
 
 
pagerduty_util.create_or_update_resource:
 
    create or update any pagerduty resource
    Helper method for present().
 
    Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
    The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
    should return a dict of data to pass to the PagerDuty update API method, or None if no update
    is to be performed.  If no diff method is provided, the default behavor is to scan the keys in the state_information,
    comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
 
    examples:
        create_or_update_resource("user", ["id","name","email"])
        create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
 
 
 
pagerduty_util.delete_resource:
 
    delete any pagerduty resource
 
    Helper method for absent()
 
    example:
            delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
 
 
 
pagerduty_util.get_escalation_policies:
 
    List escalation_policies belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.get_escalation_policies
 
 
pagerduty_util.get_resource:
 
    Get any single pagerduty resource by key.
 
    We allow flexible lookup by any of a list of identifier_fields.
    So, for example, you can look up users by email address or name by calling:
 
            get_resource('users', key, ['name', 'email'], ...)
 
    This method is mainly used to translate state sls into pagerduty id's for dependent objects.
    For example, a pagerduty escalation policy contains one or more schedules, which must be passed
    by their pagerduty id.  We look up the schedules by name (using this method), and then translate
    the names into id's.
 
    This method is implemented by getting all objects of the resource type (cached into __context__),
    then brute force searching through the list and trying to match any of the identifier_fields.
    The __context__ cache is purged after any create, update or delete to the resource.
 
 
pagerduty_util.get_schedules:
 
    List schedules belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.get_schedules
 
 
pagerduty_util.get_services:
 
    List services belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.get_services
 
 
pagerduty_util.get_users:
 
    List users belonging to this account
 
    CLI Example:
 
        salt myminion pagerduty.get_users
 
 
pagerduty_util.resource_absent:
 
    Generic resource.absent state method.   Pagerduty state modules should be a thin wrapper over this method,
    with a custom diff function.
 
    This method calls delete_resource() and formats the result as a salt state return value.
 
    example:
            resource_absent("users", ["id","name","email"])
 
 
pagerduty_util.resource_present:
 
    Generic resource.present state method.   Pagerduty state modules should be a thin wrapper over this method,
    with a custom diff function.
 
    This method calls create_or_update_resource() and formats the result as a salt state return value.
 
    example:
            resource_present("users", ["id","name","email"])
 
 
partition.align_check:
 
    Check if partition satisfies the alignment constraint of part_type.
    Type must be "minimal" or "optimal".
 
    CLI Example:
 
        salt '*' partition.align_check /dev/sda minimal 1
 
 
partition.check:
 
    Checks if the file system on partition <minor> has any errors.
 
    CLI Example:
 
        salt '*' partition.check 1
 
 
partition.cp:
 
    Copies the file system on the partition <from-minor> to partition
    <to-minor>, deleting the original contents of the destination
    partition.
 
    CLI Example:
 
        salt '*' partition.cp /dev/sda 2 3
 
 
partition.exists:
 
    Check to see if the partition exists
 
    CLI Example:
 
        salt '*' partition.exists /dev/sdb1
 
 
partition.get_block_device:
 
    Retrieve a list of disk devices
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' partition.get_block_device
 
 
partition.get_id:
 
    Prints the system ID for the partition. Some typical values are::
 
         b: FAT32 (vfat)
         7: HPFS/NTFS
        82: Linux Swap
        83: Linux
        8e: Linux LVM
        fd: Linux RAID Auto
 
    CLI Example:
 
        salt '*' partition.get_id /dev/sda 1
 
 
partition.list:
 
    Prints partition information of given <device>
 
    CLI Examples:
 
        salt '*' partition.list /dev/sda
        salt '*' partition.list /dev/sda unit=s
        salt '*' partition.list /dev/sda unit=kB
 
 
partition.mkfs:
 
    Makes a file system <fs_type> on partition <device>, destroying all data
    that resides on that partition. <fs_type> must be one of "ext2", "fat32",
    "fat16", "linux-swap" or "reiserfs" (if libreiserfs is installed)
 
    CLI Example:
 
        salt '*' partition.mkfs /dev/sda2 fat32
 
 
partition.mklabel:
 
    Create a new disklabel (partition table) of label_type.
 
    Type should be one of "aix", "amiga", "bsd", "dvh", "gpt", "loop", "mac",
    "msdos", "pc98", or "sun".
 
    CLI Example:
 
        salt '*' partition.mklabel /dev/sda msdos
 
 
partition.mkpart:
 
    Make a part_type partition for filesystem fs_type, beginning at start and
    ending at end (by default in megabytes).  part_type should be one of
    "primary", "logical", or "extended".
 
    CLI Examples:
 
        salt '*' partition.mkpart /dev/sda primary fs_type=fat32 start=0 end=639
        salt '*' partition.mkpart /dev/sda primary start=0 end=639
 
 
partition.mkpartfs:
 
    Make a <part_type> partition with a new filesystem of <fs_type>, beginning
    at <start> and ending at <end> (by default in megabytes).
 
    <part_type> should be one of "primary", "logical", or "extended". <fs_type>
    must be one of "ext2", "fat32", "fat16", "linux-swap" or "reiserfs" (if
    libreiserfs is installed)
 
    CLI Example:
 
        salt '*' partition.mkpartfs /dev/sda logical ext2 440 670
 
 
partition.name:
 
    Set the name of partition to name. This option works only on Mac, PC98, and
    GPT disklabels. The name can be placed in quotes, if necessary.
 
    CLI Example:
 
        salt '*' partition.name /dev/sda 1 'My Documents'
 
 
partition.probe:
 
    Ask the kernel to update its local partition data. When no args are
    specified all block devices are tried.
 
    Caution: Generally only works on devices with no mounted partitions and
    may take a long time to return if specified devices are in use.
 
    CLI Examples:
 
        salt '*' partition.probe
        salt '*' partition.probe /dev/sda
        salt '*' partition.probe /dev/sda /dev/sdb
 
 
partition.rescue:
 
    Rescue a lost partition that was located somewhere between start and end.
    If a partition is found, parted will ask if you want to create an
    entry for it in the partition table.
 
    CLI Example:
 
        salt '*' partition.rescue /dev/sda 0 8056
 
 
partition.resize:
 
    Resizes the partition with number <minor>.
 
    The partition will start <start> from the beginning of the disk, and end
    <end> from the beginning of the disk. resize never changes the minor number.
    Extended partitions can be resized, so long as the new extended partition
    completely contains all logical partitions.
 
    CLI Example:
 
        salt '*' partition.resize /dev/sda 3 200 850
 
 
partition.rm:
 
    Removes the partition with number <minor>.
 
    CLI Example:
 
        salt '*' partition.rm /dev/sda 5
 
 
partition.set:
 
    Changes a flag on the partition with number <minor>.
 
    A flag can be either "on" or "off". Some or all of these flags will be
    available, depending on what disk label you are using.
 
    CLI Example:
 
        salt '*' partition.set /dev/sda 1 boot on
 
 
partition.set_id:
 
    Sets the system ID for the partition. Some typical values are::
 
         b: FAT32 (vfat)
         7: HPFS/NTFS
        82: Linux Swap
        83: Linux
        8e: Linux LVM
        fd: Linux RAID Auto
 
    CLI Example:
 
        salt '*' partition.set_id /dev/sda 1 83
 
 
partition.system_types:
 
    List the system types that are supported by the installed version of sfdisk
 
    CLI Example:
 
        salt '*' partition.system_types
 
 
partition.toggle:
 
    Toggle the state of <flag> on <partition>
 
    CLI Example:
 
        salt '*' partition.name /dev/sda 1 boot
 
 
pillar.data:
 
This function is an alias of ``items``.
 
    Calls the master for a fresh pillar and generates the pillar data on the
    fly
 
    Contrast with :py:func:`raw` which returns the pillar data that is
    currently loaded into the minion.
 
    pillar : none
        if specified, allows for a dictionary of pillar data to be made
        available to pillar and ext_pillar rendering. these pillar variables
        will also override any variables of the same name in pillar or
        ext_pillar.
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' pillar.items
 
 
pillar.ext:
 
    Generate the pillar and apply an explicit external pillar
 
    CLI Example:
 
    pillar : None
        If specified, allows for a dictionary of pillar data to be made
        available to pillar and ext_pillar rendering. These pillar variables
        will also override any variables of the same name in pillar or
        ext_pillar.
 
        New in version 2015.5.0
 
        salt '*' pillar.ext '{libvirt: _}'
 
 
pillar.get:
 
    New in version 0.14
 
    Attempt to retrieve the named value from pillar, if the named value is not
    available return the passed default. The default return is an empty string
    except __opts__['pillar_raise_on_missing'] is set to True, in which case a
    KeyError will be raised.
 
    If the merge parameter is set to ``True``, the default will be recursively
    merged into the returned pillar data.
 
    The value can also represent a value in a nested dict using a ":" delimiter
    for the dict. This means that if a dict in pillar looks like this::
 
        {'pkg': {'apache': 'httpd'}}
 
    To retrieve the value associated with the apache key in the pkg dict this
    key can be passed::
 
        pkg:apache
 
    merge
        Specify whether or not the retrieved values should be recursively
        merged into the passed default.
 
        New in version 2014.7.0
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
        New in version 2014.7.0
 
    CLI Example:
 
        salt '*' pillar.get pkg:apache
 
 
pillar.item:
 
    New in version 0.16.2
 
    Return one or more pillar entries
 
    pillar : none
        if specified, allows for a dictionary of pillar data to be made
        available to pillar and ext_pillar rendering. these pillar variables
        will also override any variables of the same name in pillar or
        ext_pillar.
 
        New in version 2015.5.0
 
    CLI Examples:
 
        salt '*' pillar.item foo
        salt '*' pillar.item foo bar baz
 
 
pillar.items:
 
    Calls the master for a fresh pillar and generates the pillar data on the
    fly
 
    Contrast with :py:func:`raw` which returns the pillar data that is
    currently loaded into the minion.
 
    pillar : none
        if specified, allows for a dictionary of pillar data to be made
        available to pillar and ext_pillar rendering. these pillar variables
        will also override any variables of the same name in pillar or
        ext_pillar.
 
        New in version 2015.5.0
 
    CLI Example:
 
        salt '*' pillar.items
 
 
pillar.keys:
 
    New in version 2015.8.0
 
    Attempt to retrieve a list of keys from the named value from the pillar.
 
    The value can also represent a value in a nested dict using a ":" delimiter
    for the dict, similar to how pillar.get works.
 
    delimiter
        Specify an alternate delimiter to use when traversing a nested dict
 
    CLI Example:
 
        salt '*' pillar.keys web:sites
 
 
pillar.ls:
 
    New in version 2015.8.0
 
    Calls the master for a fresh pillar, generates the pillar data on the
    fly (same as :py:func:`items`), but only shows the available main keys.
 
    CLI Examples:
 
        salt '*' pillar.ls
 
 
pillar.obfuscate:
 
    New in version 2015.8.0
 
    Same as :py:func:`items`, but replace pillar values with a simple type indication.
 
    This is useful to avoid displaying sensitive information on console or
    flooding the console with long output, such as certificates.
    For many debug or control purposes, the stakes lie more in dispatching than in
    actual values.
 
    In case the value is itself a collection type, obfuscation occurs within the value.
    For mapping types, keys are not obfuscated.
    Here are some examples:
 
    * ``'secret password'`` becomes ``'<str>'``
    * ``['secret', 1]`` becomes ``['<str>', '<int>']``
    * ``{'login': 'somelogin', 'pwd': 'secret'}`` becomes
      ``{'login': '<str>', 'pwd': '<str>'}``
 
    CLI Examples:
 
        salt '*' pillar.obfuscate
 
 
 
pillar.raw:
 
    Return the raw pillar data that is currently loaded into the minion.
 
    Contrast with :py:func:`items` which calls the master to fetch the most
    up-to-date Pillar.
 
    CLI Example:
 
        salt '*' pillar.raw
 
    With the optional key argument, you can select a subtree of the
    pillar raw data.::
 
        salt '*' pillar.raw key='roles'
 
 
pip.freeze:
 
    Return a list of installed packages either globally or in the specified
    virtualenv
 
    bin_env
        path to pip bin or path to virtualenv. If doing an uninstall from
        the system python and want to use a specific pip bin (pip-2.7,
        pip-2.6, etc..) just specify the pip bin you want.
        If uninstalling from a virtualenv, just use the path to the virtualenv
        (/home/code/path/to/virtualenv/)
    user
        The user under which to run pip
    cwd
        Current working directory to run pip from
 
    CLI Example:
 
        salt '*' pip.freeze /home/code/path/to/virtualenv/
 
 
pip.install:
 
    Install packages with pip
 
    Install packages individually or from a pip requirements file. Install
    packages globally or to a virtualenv.
 
    pkgs
        Comma separated list of packages to install
 
    requirements
        Path to requirements
 
    bin_env
        Path to pip bin or path to virtualenv. If doing a system install,
        and want to use a specific pip bin (pip-2.7, pip-2.6, etc..) just
        specify the pip bin you want.
 
        Note:
            If installing into a virtualenv, just use the path to the
            virtualenv (e.g. ``/home/code/path/to/virtualenv/``)
 
    env
        Deprecated, use bin_env now
 
    use_wheel
        Prefer wheel archives (requires pip>=1.4)
 
    no_use_wheel
        Force to not use wheel archives (requires pip>=1.4)
 
    log
        Log file where a complete (maximum verbosity) record will be kept
 
    proxy
        Specify a proxy in the form ``user:passwd@proxy.server:port``. Note
        that the ``user:password@`` is optional and required only if you are
        behind an authenticated proxy. If you provide
        ``user@proxy.server:port`` then you will be prompted for a password.
 
    timeout
        Set the socket timeout (default 15 seconds)
 
    editable
        install something editable (e.g.
        ``git+https://github.com/worldcompany/djangoembed.git#egg=djangoembed``)
 
    find_links
        URL to search for packages
 
    index_url
        Base URL of Python Package Index
 
    extra_index_url
        Extra URLs of package indexes to use in addition to ``index_url``
 
    no_index
        Ignore package index
 
    mirrors
        Specific mirror URL(s) to query (automatically adds --use-mirrors)
 
    build
        Unpack packages into ``build`` dir
 
    target
        Install packages into ``target`` dir
 
    download
        Download packages into ``download`` instead of installing them
 
    download_cache
        Cache downloaded packages in ``download_cache`` dir
 
    source
        Check out ``editable`` packages into ``source`` dir
 
    upgrade
        Upgrade all packages to the newest available version
 
    force_reinstall
        When upgrading, reinstall all packages even if they are already
        up-to-date.
 
    ignore_installed
        Ignore the installed packages (reinstalling instead)
 
    exists_action
        Default action when a path already exists: (s)witch, (i)gnore, (w)ipe,
        (b)ackup
 
    no_deps
        Ignore package dependencies
 
    no_install
        Download and unpack all packages, but don't actually install them
 
    no_download
        Don't download any packages, just install the ones already downloaded
        (completes an install run with ``--no-install``)
 
    install_options
        Extra arguments to be supplied to the setup.py install command (e.g.
        like ``--install-option='--install-scripts=/usr/local/bin'``).  Use
        multiple --install-option options to pass multiple options to setup.py
        install. If you are using an option with a directory path, be sure to
        use absolute path.
 
    global_options
        Extra global options to be supplied to the setup.py call before the
        install command.
 
    user
        The user under which to run pip
 
    no_chown
        When user is given, do not attempt to copy and chown a requirements
        file
 
    cwd
        Current working directory to run pip from
 
    activate
        Activates the virtual environment, if given via bin_env, before running
        install.
 
        .. deprecated:: 2014.7.2
            If `bin_env` is given, pip will already be sourced from that
            virualenv, making `activate` effectively a noop.
 
    pre_releases
        Include pre-releases in the available versions
 
    cert
        Provide a path to an alternate CA bundle
 
    allow_all_external
        Allow the installation of all externally hosted files
 
    allow_external
        Allow the installation of externally hosted files (comma separated
        list)
 
    allow_unverified
        Allow the installation of insecure and unverifiable files (comma
        separated list)
 
    process_dependency_links
        Enable the processing of dependency links
 
    env_vars
        Set environment variables that some builds will depend on. For example,
        a Python C-module may have a Makefile that needs INCLUDE_PATH set to
        pick up a header file while compiling.  This must be in the form of a
        dictionary or a mapping.
 
        Example:
 
            salt '*' pip.install django_app env_vars="{'CUSTOM_PATH': '/opt/django_app'}"
 
    trusted_host
        Mark this host as trusted, even though it does not have valid or any
        HTTPS.
 
    use_vt
        Use VT terminal emulation (see ouptut while installing)
 
    CLI Example:
 
        salt '*' pip.install <package name>,<package2 name>
        salt '*' pip.install requirements=/path/to/requirements.txt
        salt '*' pip.install <package name> bin_env=/path/to/virtualenv
        salt '*' pip.install <package name> bin_env=/path/to/pip_bin
 
    Complicated CLI example::
 
        salt '*' pip.install markdown,django                 editable=git+https://github.com/worldcompany/djangoembed.git#egg=djangoembed upgrade=True no_deps=True
 
 
 
pip.list:
 
    Filter list of installed apps from ``freeze`` and check to see if
    ``prefix`` exists in the list of packages installed.
 
    CLI Example:
 
        salt '*' pip.list salt
 
 
pip.list_upgrades:
 
    Check whether or not an upgrade is available for all packages
 
    CLI Example:
 
        salt '*' pip.list_upgrades
 
 
pip.uninstall:
 
    Uninstall packages with pip
 
    Uninstall packages individually or from a pip requirements file. Uninstall
    packages globally or from a virtualenv.
 
    pkgs
        comma separated list of packages to install
    requirements
        path to requirements.
    bin_env
        path to pip bin or path to virtualenv. If doing an uninstall from
        the system python and want to use a specific pip bin (pip-2.7,
        pip-2.6, etc..) just specify the pip bin you want.
        If uninstalling from a virtualenv, just use the path to the virtualenv
        (/home/code/path/to/virtualenv/)
    log
        Log file where a complete (maximum verbosity) record will be kept
    proxy
        Specify a proxy in the form
        user:passwd@proxy.server:port. Note that the
        user:password@ is optional and required only if you
        are behind an authenticated proxy.  If you provide
        user@proxy.server:port then you will be prompted for a
        password.
    timeout
        Set the socket timeout (default 15 seconds)
    user
        The user under which to run pip
    no_chown
        When user is given, do not attempt to copy and chown
        a requirements file (needed if the requirements file refers to other
        files via relative paths, as the copy-and-chown procedure does not
        account for such files)
    cwd
        Current working directory to run pip from
    use_vt
        Use VT terminal emulation (see ouptut while installing)
 
    CLI Example:
 
        salt '*' pip.uninstall <package name>,<package2 name>
        salt '*' pip.uninstall requirements=/path/to/requirements.txt
        salt '*' pip.uninstall <package name> bin_env=/path/to/virtualenv
        salt '*' pip.uninstall <package name> bin_env=/path/to/pip_bin
 
 
 
pip.upgrade:
 
    New in version 2015.5.0
 
    Upgrades outdated pip packages
 
    Returns a dict containing the changes.
 
        {'<package>':  {'old': '<old-version>',
                        'new': '<new-version>'}}
 
 
    CLI Example:
 
        salt '*' pip.upgrade
 
 
pip.upgrade_available:
 
    New in version 2015.5.0
 
    Check whether or not an upgrade is available for a given package
 
    CLI Example:
 
        salt '*' pip.upgrade_available <package name>
 
 
pip.version:
 
    New in version 0.17.0
 
    Returns the version of pip. Use ``bin_env`` to specify the path to a
    virtualenv and get the version of pip in that virtualenv.
 
    If unable to detect the pip version, returns ``None``.
 
    CLI Example:
 
        salt '*' pip.version
 
 
pkg.available_version:
 
This function is an alias of ``latest_version``.
 
    Return the latest version of the named package available for upgrade or
    installation. If more than one package name is specified, a dict of
    name/version pairs is returned.
 
    If the latest version of a given package is already installed, an empty
    string will be returned for that package.
 
    A specific repo can be requested using the ``fromrepo`` keyword argument,
    and the ``disableexcludes`` option is also supported.
 
    New in version 2014.7.0
        Support for the ``disableexcludes`` option
 
    CLI Example:
 
        salt '*' pkg.latest_version <package name>
        salt '*' pkg.latest_version <package name> fromrepo=epel-testing
        salt '*' pkg.latest_version <package name> disableexcludes=main
        salt '*' pkg.latest_version <package1> <package2> <package3> ...
 
 
pkg.check_db:
 
    New in version 0.17.0
 
    Returns a dict containing the following information for each specified
    package:
 
    1. A key ``found``, which will be a boolean value denoting if a match was
       found in the package database.
    2. If ``found`` is ``False``, then a second key called ``suggestions`` will
       be present, which will contain a list of possible matches.
 
    The ``fromrepo``, ``enablerepo`` and ``disablerepo`` arguments are
    supported, as used in pkg states, and the ``disableexcludes`` option is
    also supported. However, in Fedora 22 and newer all of these but
    ``fromrepo`` is ignored.
 
    New in version 2014.7.0
        Support for the ``disableexcludes`` option
 
    CLI Examples:
 
        salt '*' pkg.check_db <package1> <package2> <package3>
        salt '*' pkg.check_db <package1> <package2> <package3> fromrepo=epel-testing
        salt '*' pkg.check_db <package1> <package2> <package3> disableexcludes=main
 
 
pkg.clean_metadata:
 
    New in version 2014.1.0
 
    Cleans local yum metadata. Functionally identical to :mod:`refresh_db()
    <salt.modules.yumpkg.refresh_db>`.
 
    CLI Example:
 
        salt '*' pkg.clean_metadata
 
 
pkg.del_repo:
 
    Delete a repo from <basedir> (default basedir: all dirs in `reposdir` yum option).
 
    If the .repo file that the repo exists in does not contain any other repo
    configuration, the file itself will be deleted.
 
    CLI Examples:
 
        salt '*' pkg.del_repo myrepo
        salt '*' pkg.del_repo myrepo basedir=/path/to/dir
        salt '*' pkg.del_repo myrepo basedir=/path/to/dir,/path/to/another/dir
 
 
pkg.diff:
 
    Return a formatted diff between current files and original in a package.
    NOTE: this function includes all files (configuration and not), but does
    not work on binary content.
 
    :param path: Full path to the installed file
    :return: Difference string or raises and exception if examined file is binary.
 
    CLI example:
 
        salt '*' pkg.diff /etc/apache2/httpd.conf /etc/sudoers
 
 
pkg.download:
 
    New in version 2015.5.0
 
    Download packages to the local disk. Requires ``yumdownloader`` from
    ``yum-utils`` package.
 
    Note:
 
        ``yum-utils`` will already be installed on the minion if the package
        was installed from the Fedora / EPEL repositories.
 
    CLI example:
 
        salt '*' pkg.download httpd
        salt '*' pkg.download httpd postfix
 
 
pkg.expand_repo_def:
 
    Take a repository definition and expand it to the full pkg repository dict
    that can be used for comparison. This is a helper function to make
    certain repo managers sane for comparison in the pkgrepo states.
 
    There is no use to calling this function via the CLI.
 
 
pkg.file_dict:
 
    New in version 2014.1.0
 
    List the files that belong to a package, grouped by package. Not
    specifying any packages will return a list of *every* file on the system's
    rpm database (not generally recommended).
 
    CLI Examples:
 
        salt '*' pkg.file_list httpd
        salt '*' pkg.file_list httpd postfix
        salt '*' pkg.file_list
 
 
pkg.file_list:
 
    New in version 2014.1.0
 
    List the files that belong to a package. Not specifying any packages will
    return a list of *every* file on the system's rpm database (not generally
    recommended).
 
    CLI Examples:
 
        salt '*' pkg.file_list httpd
        salt '*' pkg.file_list httpd postfix
        salt '*' pkg.file_list
 
 
pkg.get_locked_packages:
 
This function is an alias of ``list_holds``.
 
    Changed in version Boron,2015.8.4,2015.5.10
        Function renamed from ``pkg.get_locked_pkgs`` to ``pkg.list_holds``.
 
    List information on locked packages
 
    Note:
        Requires the appropriate ``versionlock`` plugin package to be installed:
 
        - On RHEL 5: ``yum-versionlock``
        - On RHEL 6 & 7: ``yum-plugin-versionlock``
        - On Fedora: ``python-dnf-plugins-extras-versionlock``
 
    pattern : \w+(?:[.-][^-]+)*
        Regular expression used to match the package name
 
    full : True
        Show the full hold definition including version and epoch. Set to
        ``False`` to return just the name of the package(s) being held.
 
 
    CLI Example:
 
        salt '*' pkg.list_holds
        salt '*' pkg.list_holds full=False
 
 
pkg.get_repo:
 
    Display a repo from <basedir> (default basedir: all dirs in ``reposdir``
    yum option).
 
    CLI Examples:
 
        salt '*' pkg.get_repo myrepo
        salt '*' pkg.get_repo myrepo basedir=/path/to/dir
        salt '*' pkg.get_repo myrepo basedir=/path/to/dir,/path/to/another/dir
 
 
pkg.group_diff:
 
    New in version 2014.1.0
    Changed in version Boron,2015.8.4,2015.5.10
        Environment groups are now supported. The key names have been renamed,
        similar to the changes made in :py:func:`pkg.group_info
        <salt.modules.yumpkg.group_info>`.
 
    Lists packages belonging to a certain group, and which are installed
 
    CLI Example:
 
        salt '*' pkg.group_diff 'Perl Support'
 
 
pkg.group_info:
 
    New in version 2014.1.0
    Changed in version Boron,2015.8.4,2015.5.10
        The return data has changed. A new key ``type`` has been added to
        distinguish environment groups from package groups. Also, keys for the
        group name and group ID have been added. The ``mandatory packages``,
        ``optional packages``, and ``default packages`` keys have been renamed
        to ``mandatory``, ``optional``, and ``default`` for accuracy, as
        environment groups include other groups, and not packages. Finally,
        this function now properly identifies conditional packages.
 
    Lists packages belonging to a certain group
 
    CLI Example:
 
        salt '*' pkg.group_info 'Perl Support'
 
 
pkg.group_install:
 
    New in version 2014.1.0
 
    Install the passed package group(s). This is basically a wrapper around
    :py:func:`pkg.install <salt.modules.yumpkg.install>`, which performs
    package group resolution for the user. This function is currently
    considered experimental, and should be expected to undergo changes.
 
    name
        Package group to install. To install more than one group, either use a
        comma-separated list or pass the value as a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'Group 1'
            salt '*' pkg.group_install 'Group 1,Group 2'
            salt '*' pkg.group_install '["Group 1", "Group 2"]'
 
    skip
        Packages that would normally be installed by the package group
        ("default" packages), which should not be installed. Can be passed
        either as a comma-separated list or a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'My Group' skip='foo,bar'
            salt '*' pkg.group_install 'My Group' skip='["foo", "bar"]'
 
    include
        Packages which are included in a group, which would not normally be
        installed by a ``yum groupinstall`` ("optional" packages). Note that
        this will not enforce group membership; if you include packages which
        are not members of the specified groups, they will still be installed.
        Can be passed either as a comma-separated list or a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'My Group' include='foo,bar'
            salt '*' pkg.group_install 'My Group' include='["foo", "bar"]'
 
    Note:
 
        Because this is essentially a wrapper around pkg.install, any argument
        which can be passed to pkg.install may also be included here, and it
        will be passed along wholesale.
 
 
pkg.group_list:
 
    New in version 2014.1.0
 
    Lists all groups known by yum on this system
 
    CLI Example:
 
        salt '*' pkg.group_list
 
 
pkg.groupinstall:
 
This function is an alias of ``group_install``.
 
    New in version 2014.1.0
 
    Install the passed package group(s). This is basically a wrapper around
    :py:func:`pkg.install <salt.modules.yumpkg.install>`, which performs
    package group resolution for the user. This function is currently
    considered experimental, and should be expected to undergo changes.
 
    name
        Package group to install. To install more than one group, either use a
        comma-separated list or pass the value as a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'Group 1'
            salt '*' pkg.group_install 'Group 1,Group 2'
            salt '*' pkg.group_install '["Group 1", "Group 2"]'
 
    skip
        Packages that would normally be installed by the package group
        ("default" packages), which should not be installed. Can be passed
        either as a comma-separated list or a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'My Group' skip='foo,bar'
            salt '*' pkg.group_install 'My Group' skip='["foo", "bar"]'
 
    include
        Packages which are included in a group, which would not normally be
        installed by a ``yum groupinstall`` ("optional" packages). Note that
        this will not enforce group membership; if you include packages which
        are not members of the specified groups, they will still be installed.
        Can be passed either as a comma-separated list or a python list.
 
        CLI Examples:
 
            salt '*' pkg.group_install 'My Group' include='foo,bar'
            salt '*' pkg.group_install 'My Group' include='["foo", "bar"]'
 
    Note:
 
        Because this is essentially a wrapper around pkg.install, any argument
        which can be passed to pkg.install may also be included here, and it
        will be passed along wholesale.
 
 
pkg.hold:
 
    New in version 2014.7.0
 
    Version-lock packages
 
    Note:
        Requires the appropriate ``versionlock`` plugin package to be installed:
 
        - On RHEL 5: ``yum-versionlock``
        - On RHEL 6 & 7: ``yum-plugin-versionlock``
        - On Fedora: ``python-dnf-plugins-extras-versionlock``
 
 
    name
        The name of the package to be held.
 
    Multiple Package Options:
 
    pkgs
        A list of packages to hold. Must be passed as a python list. The
        ``name`` parameter will be ignored if this option is passed.
 
    Returns a dict containing the changes.
 
    CLI Example:
 
        salt '*' pkg.hold <package name>
        salt '*' pkg.hold pkgs='["foo", "bar"]'
 
 
pkg.info_installed:
 
    Return the information of the named package(s), installed on the system.
 
    CLI example:
 
        salt '*' pkg.info_installed <package1>
        salt '*' pkg.info_installed <package1> <package2> <package3> ...
 
 
pkg.install:
 
    Install the passed package(s), add refresh=True to clean the yum database
    before package is installed.
 
    name
        The name of the package to be installed. Note that this parameter is
        ignored if either "pkgs" or "sources" is passed. Additionally, please
        note that this option can only be used to install packages from a
        software repository. To install a package file manually, use the
        "sources" option.
 
        32-bit packages can be installed on 64-bit systems by appending the
        architecture designation (``.i686``, ``.i586``, etc.) to the end of the
        package name.
 
        CLI Example:
 
            salt '*' pkg.install <package name>
 
    refresh
        Whether or not to update the yum database before executing.
 
    reinstall
        Specifying reinstall=True will use ``yum reinstall`` rather than
        ``yum install`` for requested packages that are already installed.
 
        If a version is specified with the requested package, then
        ``yum reinstall`` will only be used if the installed version
        matches the requested version.
 
        Works with ``sources`` when the package header of the source can be
        matched to the name and version of an installed package.
 
        New in version 2014.7.0
 
    skip_verify
        Skip the GPG verification check (e.g., ``--nogpgcheck``)
 
    version
        Install a specific version of the package, e.g. 1.2.3-4.el5. Ignored
        if "pkgs" or "sources" is passed.
 
 
    Repository Options:
 
    fromrepo
        Specify a package repository (or repositories) from which to install.
        (e.g., ``yum --disablerepo='*' --enablerepo='somerepo'``)
 
    enablerepo (ignored if ``fromrepo`` is specified)
        Specify a disabled package repository (or repositories) to enable.
        (e.g., ``yum --enablerepo='somerepo'``)
 
    disablerepo (ignored if ``fromrepo`` is specified)
        Specify an enabled package repository (or repositories) to disable.
        (e.g., ``yum --disablerepo='somerepo'``)
 
    disableexcludes
        Disable exclude from main, for a repo or for everything.
        (e.g., ``yum --disableexcludes='main'``)
 
        New in version 2014.7.0
 
 
    Multiple Package Installation Options:
 
    pkgs
        A list of packages to install from a software repository. Must be
        passed as a python list. A specific version number can be specified
        by using a single-element dict representing the package and its
        version.
 
        CLI Examples:
 
            salt '*' pkg.install pkgs='["foo", "bar"]'
            salt '*' pkg.install pkgs='["foo", {"bar": "1.2.3-4.el5"}]'
 
    sources
        A list of RPM packages to install. Must be passed as a list of dicts,
        with the keys being package names, and the values being the source URI
        or local path to the package.
 
        CLI Example:
 
            salt '*' pkg.install sources='[{"foo": "salt://foo.rpm"}, {"bar": "salt://bar.rpm"}]'
 
    normalize : True
        Normalize the package name by removing the architecture. This is useful
        for poorly created packages which might include the architecture as an
        actual part of the name such as kernel modules which match a specific
        kernel version.
 
            salt -G role:nsd pkg.install gpfs.gplbin-2.6.32-279.31.1.el6.x86_64 normalize=False
 
        New in version 2014.7.0
 
 
    Returns a dict containing the new package names and versions::
 
        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}
 
 
pkg.latest_version:
 
    Return the latest version of the named package available for upgrade or
    installation. If more than one package name is specified, a dict of
    name/version pairs is returned.
 
    If the latest version of a given package is already installed, an empty
    string will be returned for that package.
 
    A specific repo can be requested using the ``fromrepo`` keyword argument,
    and the ``disableexcludes`` option is also supported.
 
    New in version 2014.7.0
        Support for the ``disableexcludes`` option
 
    CLI Example:
 
        salt '*' pkg.latest_version <package name>
        salt '*' pkg.latest_version <package name> fromrepo=epel-testing
        salt '*' pkg.latest_version <package name> disableexcludes=main
        salt '*' pkg.latest_version <package1> <package2> <package3> ...
 
 
pkg.list_holds:
 
    Changed in version Boron,2015.8.4,2015.5.10
        Function renamed from ``pkg.get_locked_pkgs`` to ``pkg.list_holds``.
 
    List information on locked packages
 
    Note:
        Requires the appropriate ``versionlock`` plugin package to be installed:
 
        - On RHEL 5: ``yum-versionlock``
        - On RHEL 6 & 7: ``yum-plugin-versionlock``
        - On Fedora: ``python-dnf-plugins-extras-versionlock``
 
    pattern : \w+(?:[.-][^-]+)*
        Regular expression used to match the package name
 
    full : True
        Show the full hold definition including version and epoch. Set to
        ``False`` to return just the name of the package(s) being held.
 
 
    CLI Example:
 
        salt '*' pkg.list_holds
        salt '*' pkg.list_holds full=False
 
 
pkg.list_pkgs:
 
    List the packages currently installed in a dict::
 
        {'<package_name>': '<version>'}
 
    CLI Example:
 
        salt '*' pkg.list_pkgs
 
 
pkg.list_repo_pkgs:
 
    New in version 2014.1.0
    Changed in version 2014.7.0
        All available versions of each package are now returned. This required
        a slight modification to the structure of the return dict. The return
        data shown below reflects the updated return dict structure.
 
    Returns all available packages. Optionally, package names (and name globs)
    can be passed and the results will be filtered to packages matching those
    names. This is recommended as it speeds up the function considerably.
 
    This function can be helpful in discovering the version or repo to specify
    in a :mod:`pkg.installed <salt.states.pkg.installed>` state.
 
    The return data is a dictionary of repo names, with each repo containing a
    dictionary in which the keys are package names, and the values are a list
    of version numbers. Here is an example of the return data:
 
        {
            'base': {
                'bash': ['4.1.2-15.el6_4'],
                'kernel': ['2.6.32-431.el6']
            },
            'updates': {
                'bash': ['4.1.2-15.el6_5.2', '4.1.2-15.el6_5.1'],
                'kernel': ['2.6.32-431.29.2.el6',
                           '2.6.32-431.23.3.el6',
                           '2.6.32-431.20.5.el6',
                           '2.6.32-431.20.3.el6',
                           '2.6.32-431.17.1.el6',
                           '2.6.32-431.11.2.el6',
                           '2.6.32-431.5.1.el6',
                           '2.6.32-431.3.1.el6',
                           '2.6.32-431.1.2.0.1.el6']
            }
        }
 
    fromrepo : None
        Only include results from the specified repo(s). Multiple repos can be
        specified, comma-separated.
 
    CLI Example:
 
        salt '*' pkg.list_repo_pkgs
        salt '*' pkg.list_repo_pkgs foo bar baz
        salt '*' pkg.list_repo_pkgs 'samba4*' fromrepo=base,updates
 
 
pkg.list_repos:
 
    Lists all repos in <basedir> (default: all dirs in `reposdir` yum option).
 
    CLI Example:
 
        salt '*' pkg.list_repos
        salt '*' pkg.list_repos basedir=/path/to/dir
        salt '*' pkg.list_repos basedir=/path/to/dir,/path/to/another/dir
 
 
pkg.list_upgrades:
 
    Check whether or not an upgrade is available for all packages
 
    The ``fromrepo``, ``enablerepo``, and ``disablerepo`` arguments are
    supported, as used in pkg states, and the ``disableexcludes`` option is
    also supported. However, in Fedora 22 and newer all of these but
    ``fromrepo`` is ignored.
 
    New in version 2014.7.0
        Support for the ``disableexcludes`` option
 
    CLI Example:
 
        salt '*' pkg.list_upgrades
 
 
pkg.mod_repo:
 
    Modify one or more values for a repo. If the repo does not exist, it will
    be created, so long as the following values are specified:
 
    repo
        name by which the yum refers to the repo
    name
        a human-readable name for the repo
    baseurl
        the URL for yum to reference
    mirrorlist
        the URL for yum to reference
 
    Key/Value pairs may also be removed from a repo's configuration by setting
    a key to a blank value. Bear in mind that a name cannot be deleted, and a
    baseurl can only be deleted if a mirrorlist is specified (or vice versa).
 
    CLI Examples:
 
        salt '*' pkg.mod_repo reponame enabled=1 gpgcheck=1
        salt '*' pkg.mod_repo reponame basedir=/path/to/dir enabled=1
        salt '*' pkg.mod_repo reponame baseurl= mirrorlist=http://host.com/
 
 
pkg.modified:
 
    List the modified files that belong to a package. Not specifying any packages
    will return a list of _all_ modified files on the system's RPM database.
 
    New in version 2015.5.0
 
    Filtering by flags (True or False):
 
    size
        Include only files where size changed.
 
    mode
        Include only files which file's mode has been changed.
 
    checksum
        Include only files which MD5 checksum has been changed.
 
    device
        Include only files which major and minor numbers has been changed.
 
    symlink
        Include only files which are symbolic link contents.
 
    owner
        Include only files where owner has been changed.
 
    group
        Include only files where group has been changed.
 
    time
        Include only files where modification time of the file has been
        changed.
 
    capabilities
        Include only files where capabilities differ or not. Note: supported
        only on newer RPM versions.
 
    CLI Examples:
 
        salt '*' pkg.modified
        salt '*' pkg.modified httpd
        salt '*' pkg.modified httpd postfix
        salt '*' pkg.modified httpd owner=True group=False
 
 
pkg.normalize_name:
 
    Strips the architecture from the specified package name, if necessary.
    Circumstances where this would be done include:
 
    * If the arch is 32 bit and the package name ends in a 32-bit arch.
    * If the arch matches the OS arch, or is ``noarch``.
 
    CLI Example:
 
        salt '*' pkg.normalize_name zsh.x86_64
 
 
pkg.owner:
 
    New in version 2014.7.0
 
    Return the name of the package that owns the file. Multiple file paths can
    be passed. Like :mod:`pkg.version <salt.modules.yumpkg.version`, if a
    single path is passed, a string will be returned, and if multiple paths are
    passed, a dictionary of file/package name pairs will be returned.
 
    If the file is not owned by a package, or is not present on the minion,
    then an empty string will be returned for that path.
 
    CLI Examples:
 
        salt '*' pkg.owner /usr/bin/apachectl
        salt '*' pkg.owner /usr/bin/apachectl /etc/httpd/conf/httpd.conf
 
 
pkg.purge:
 
    Package purges are not supported by yum, this function is identical to
    :mod:`pkg.remove <salt.modules.yumpkg.remove>`.
 
    name
        The name of the package to be purged
 
 
    Multiple Package Options:
 
    pkgs
        A list of packages to delete. Must be passed as a python list. The
        ``name`` parameter will be ignored if this option is passed.
 
    New in version 0.16.0
 
 
    Returns a dict containing the changes.
 
    CLI Example:
 
        salt '*' pkg.purge <package name>
        salt '*' pkg.purge <package1>,<package2>,<package3>
        salt '*' pkg.purge pkgs='["foo", "bar"]'
 
 
pkg.refresh_db:
 
    Check the yum repos for updated packages
 
    Returns:
 
    - ``True``: Updates are available
    - ``False``: An error occurred
    - ``None``: No updates are available
 
    repo
        Refresh just the specified repo
 
    disablerepo
        Do not refresh the specified repo
 
    enablerepo
        Refesh a disabled repo using this option
 
    branch
        Add the specified branch when refreshing
 
    disableexcludes
        Disable the excludes defined in your config files. Takes one of three
        options:
        - ``all`` - disable all excludes
        - ``main`` - disable excludes defined in [main] in yum.conf
        - ``repoid`` - disable excludes defined for that repo
 
 
    CLI Example:
 
        salt '*' pkg.refresh_db
 
 
pkg.remove:
 
    Remove packages
 
    name
        The name of the package to be removed
 
 
    Multiple Package Options:
 
    pkgs
        A list of packages to delete. Must be passed as a python list. The
        ``name`` parameter will be ignored if this option is passed.
 
    New in version 0.16.0
 
 
    Returns a dict containing the changes.
 
    CLI Example:
 
        salt '*' pkg.remove <package name>
        salt '*' pkg.remove <package1>,<package2>,<package3>
        salt '*' pkg.remove pkgs='["foo", "bar"]'
 
 
pkg.unhold:
 
    New in version 2014.7.0
 
    Remove version locks
 
    Note:
        Requires the appropriate ``versionlock`` plugin package to be installed:
 
        - On RHEL 5: ``yum-versionlock``
        - On RHEL 6 & 7: ``yum-plugin-versionlock``
        - On Fedora: ``python-dnf-plugins-extras-versionlock``
 
 
    name
        The name of the package to be unheld
 
    Multiple Package Options:
 
    pkgs
        A list of packages to unhold. Must be passed as a python list. The
        ``name`` parameter will be ignored if this option is passed.
 
    Returns a dict containing the changes.
 
    CLI Example:
 
        salt '*' pkg.unhold <package name>
        salt '*' pkg.unhold pkgs='["foo", "bar"]'
 
 
pkg.upgrade:
 
    Run a full system upgrade, a yum upgrade
 
    Changed in version 2014.7.0
 
    Return a dict containing the new package names and versions::
 
        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}
 
    CLI Example:
 
        salt '*' pkg.upgrade
 
    Repository Options:
 
    fromrepo
        Specify a package repository (or repositories) from which to install.
        (e.g., ``yum --disablerepo='*' --enablerepo='somerepo'``)
 
    enablerepo (ignored if ``fromrepo`` is specified)
        Specify a disabled package repository (or repositories) to enable.
        (e.g., ``yum --enablerepo='somerepo'``)
 
    disablerepo (ignored if ``fromrepo`` is specified)
        Specify an enabled package repository (or repositories) to disable.
        (e.g., ``yum --disablerepo='somerepo'``)
 
    disableexcludes
        Disable exclude from main, for a repo or for everything.
        (e.g., ``yum --disableexcludes='main'``)
 
        New in version 2014.7.0
 
 
pkg.upgrade_available:
 
    Check whether or not an upgrade is available for a given package
 
    CLI Example:
 
        salt '*' pkg.upgrade_available <package name>
 
 
pkg.verify:
 
    New in version 2014.1.0
 
    Runs an rpm -Va on a system, and returns the results in a dict
 
    Files with an attribute of config, doc, ghost, license or readme in the
    package header can be ignored using the ``ignore_types`` keyword argument
 
    CLI Example:
 
        salt '*' pkg.verify
        salt '*' pkg.verify httpd
        salt '*' pkg.verify 'httpd postfix'
        salt '*' pkg.verify 'httpd postfix' ignore_types=['config','doc']
 
 
pkg.version:
 
    Returns a string representing the package version or an empty string if not
    installed. If more than one package name is specified, a dict of
    name/version pairs is returned.
 
    CLI Example:
 
        salt '*' pkg.version <package name>
        salt '*' pkg.version <package1> <package2> <package3> ...
 
 
pkg.version_cmp:
 
    New in version 2015.5.4
 
    Do a cmp-style comparison on two packages. Return -1 if pkg1 < pkg2, 0 if
    pkg1 == pkg2, and 1 if pkg1 > pkg2. Return None if there was a problem
    making the comparison.
 
    CLI Example:
 
        salt '*' pkg.version_cmp '0.2-001' '0.2.0.1-002'
 
 
pkg_resource.add_pkg:
 
    Add a package to a dict of installed packages.
 
    CLI Example:
 
        salt '*' pkg_resource.add_pkg '{}' bind 9
 
 
pkg_resource.check_extra_requirements:
 
    Check if the installed package already has the given requirements.
    This function will return the result of ``pkg.check_extra_requirements`` if
    this function exists for the minion, otherwise it will return True.
 
    CLI Example:
 
        salt '*' pkg_resource.check_extra_requirements <pkgname> <extra_requirements>
 
 
pkg_resource.pack_sources:
 
    Accepts list of dicts (or a string representing a list of dicts) and packs
    the key/value pairs into a single dict.
 
    ``'[{"foo": "salt://foo.rpm"}, {"bar": "salt://bar.rpm"}]'`` would become
    ``{"foo": "salt://foo.rpm", "bar": "salt://bar.rpm"}``
 
    normalize : True
        Normalize the package name by removing the architecture, if the
        architecture of the package is different from the architecture of the
        operating system. The ability to disable this behavior is useful for
        poorly-created packages which include the architecture as an actual
        part of the name, such as kernel modules which match a specific kernel
        version.
 
        New in version 2015.8.0
 
    CLI Example:
 
        salt '*' pkg_resource.pack_sources '[{"foo": "salt://foo.rpm"}, {"bar": "salt://bar.rpm"}]'
 
 
pkg_resource.parse_targets:
 
    Parses the input to pkg.install and returns back the package(s) to be
    installed. Returns a list of packages, as well as a string noting whether
    the packages are to come from a repository or a binary package.
 
    CLI Example:
 
        salt '*' pkg_resource.parse_targets
 
 
pkg_resource.sort_pkglist:
 
    Accepts a dict obtained from pkg.list_pkgs() and sorts in place the list of
    versions for any packages that have multiple versions installed, so that
    two package lists can be compared to one another.
 
    CLI Example:
 
        salt '*' pkg_resource.sort_pkglist '["3.45", "2.13"]'
 
 
pkg_resource.stringify:
 
    Takes a dict of package name/version information and joins each list of
    installed versions into a string.
 
    CLI Example:
 
        salt '*' pkg_resource.stringify 'vim: 7.127'
 
 
pkg_resource.version:
 
    Common interface for obtaining the version of installed packages.
 
    CLI Example:
 
        salt '*' pkg_resource.version vim
        salt '*' pkg_resource.version foo bar baz
        salt '*' pkg_resource.version 'python*'
 
 
pkg_resource.version_clean:
 
    Clean the version string removing extra data.
    This function will simply try to call ``pkg.version_clean``.
 
    CLI Example:
 
        salt '*' pkg_resource.version_clean <version_string>
 
 
postfix.delete:
 
    Delete message(s) from the mail queue
 
    CLI Example:
 
        salt '*' postfix.delete 5C33CA0DEA
 
        salt '*' postfix.delete ALL
 
 
 
postfix.hold:
 
    Put message(s) on hold from the mail queue
 
    CLI Example:
 
        salt '*' postfix.hold 5C33CA0DEA
 
        salt '*' postfix.hold ALL
 
 
 
postfix.requeue:
 
    Requeue message(s) in the mail queue
 
    CLI Example:
 
        salt '*' postfix.requeue 5C33CA0DEA
 
        salt '*' postfix.requeue ALL
 
 
 
postfix.set_main:
 
    Set a single config value in the main.cf file. If the value does not already
    exist, it will be appended to the end.
 
    CLI Example:
 
        salt <minion> postfix.set_main mailq_path /usr/bin/mailq
 
 
postfix.set_master:
 
    Set a single config value in the master.cf file. If the value does not
    already exist, it will be appended to the end.
 
    Because of shell parsing issues, '-' cannot be set as a value, as is normal
    in the master.cf file; either 'y', 'n' or a number should be used when
    calling this function from the command line. If the value used matches the
    default, it will internally be converted to a '-'. Calling this function
    from the Python API is not affected by this limitation
 
    The settings and their default values, in order, are: service (required),
    conn_type (required), private (y), unpriv (y), chroot (y), wakeup (n),
    maxproc (100), command (required).
 
    By default, this function will write out the changes to the master.cf file,
    and then returns the full contents of the file. By setting the
    ``write_conf`` option to ``False``, it will skip writing the file.
 
    CLI Example:
 
        salt <minion> postfix.set_master smtp inet n y n n 100 smtpd
 
 
postfix.show_main:
 
    Return a dict of active config values. This does not include comments,
    spacing or order. Bear in mind that order is functionally important in the
    main.cf file, since keys can be referred to as variables. This means that
    the data returned from this function should not be used for direct
    modification of the main.cf file; other functions are available for that.
 
    CLI Examples:
 
        salt <minion> postfix.show_main
        salt <minion> postfix.show_main path=/path/to/main.cf
 
 
postfix.show_master:
 
    Return a dict of active config values. This does not include comments,
    spacing or order.
 
    The data returned from this function should not be used for direct
    modification of the main.cf file; other functions are available for that.
 
    CLI Examples:
 
        salt <minion> postfix.show_master
        salt <minion> postfix.show_master path=/path/to/master.cf
 
 
postfix.show_queue:
 
    Show contents of the mail queue
 
    CLI Example:
 
        salt '*' postfix.show_queue
 
 
 
postfix.unhold:
 
    Set held message(s) in the mail queue to unheld
 
    CLI Example:
 
        salt '*' postfix.unhold 5C33CA0DEA
 
        salt '*' postfix.unhold ALL
 
 
 
publish.full_data:
 
    Return the full data about the publication, this is invoked in the same
    way as the publish function
 
    CLI Example:
 
        salt system.example.com publish.full_data '*' cmd.run 'ls -la /tmp'
 
    .. admonition:: Attention
 
        If you need to pass a value to a function argument and that value
        contains an equal sign, you **must** include the argument name.
        For example:
 
            salt '*' publish.full_data test.kwarg arg='cheese=spam'
 
 
 
publish.publish:
 
    Publish a command from the minion out to other minions.
 
    Publications need to be enabled on the Salt master and the minion
    needs to have permission to publish the command. The Salt master
    will also prevent a recursive publication loop, this means that a
    minion cannot command another minion to command another minion as
    that would create an infinite command loop.
 
    The expr_form argument is used to pass a target other than a glob into
    the execution, the available options are:
 
    - glob
    - pcre
    - grain
    - grain_pcre
    - pillar
    - pillar_pcre
    - ipcidr
    - range
    - compound
 
    Note that for pillar matches must be exact, both in the pillar matcher
    and the compound matcher. No globbing is supported.
 
    The arguments sent to the minion publish function are separated with
    commas. This means that for a minion executing a command with multiple
    args it will look like this:
 
        salt system.example.com publish.publish '*' user.add 'foo,1020,1020'
        salt system.example.com publish.publish 'os:Fedora' network.interfaces '' grain
 
    CLI Example:
 
        salt system.example.com publish.publish '*' cmd.run 'ls -la /tmp'
 
 
    .. admonition:: Attention
 
        If you need to pass a value to a function argument and that value
        contains an equal sign, you **must** include the argument name.
        For example:
 
            salt '*' publish.publish test.kwarg arg='cheese=spam'
 
        Multiple keyword arguments should be passed as a list.
 
            salt '*' publish.publish test.kwarg arg="['cheese=spam','spam=cheese']"
 
 
 
 
 
publish.runner:
 
    Execute a runner on the master and return the data from the runner
    function
 
    CLI Example:
 
        salt publish.runner manage.down
 
 
pushover.post_message:
 
    Send a message to a Pushover user or group.
 
    :param user:        The user or group to send to, must be key of user or group not email address.
    :param message:     The message to send to the PushOver user or group.
    :param title:       Specify who the message is from.
    :param priority:    The priority of the message, defaults to 0.
    :param expire:      The message should expire after N number of seconds.
    :param retry:       The number of times the message should be retried.
    :param sound:       The sound to associate with the message.
    :param api_version: The PushOver API version, if not specified in the configuration.
    :param token:       The PushOver token, if not specified in the configuration.
    :return:            Boolean if message was sent successfully.
 
    CLI Example:
 
        salt '*' pushover.post_message user='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' title='Message from Salt' message='Build is done'
 
        salt '*' pushover.post_message user='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' title='Message from Salt' message='Build is done' priority='2' expire='720' retry='5'
 
 
 
pyenv.default:
 
    Returns or sets the currently defined default python.
 
    python=None
        The version to set as the default. Should match one of the versions
        listed by :mod:`pyenv.versions <salt.modules.pyenv.versions>`. Leave
        blank to return the current default.
 
    CLI Example:
 
        salt '*' pyenv.default
        salt '*' pyenv.default 2.0.0-p0
 
 
pyenv.do:
 
    Execute a python command with pyenv's shims from the user or the system.
 
    CLI Example:
 
        salt '*' pyenv.do 'gem list bundler'
        salt '*' pyenv.do 'gem list bundler' deploy
 
 
pyenv.do_with_python:
 
    Execute a python command with pyenv's shims using a specific python version.
 
    CLI Example:
 
        salt '*' pyenv.do_with_python 2.0.0-p0 'gem list bundler'
        salt '*' pyenv.do_with_python 2.0.0-p0 'gem list bundler' deploy
 
 
pyenv.install:
 
    Install pyenv systemwide
 
    CLI Example:
 
        salt '*' pyenv.install
 
 
pyenv.install_python:
 
    Install a python implementation.
 
    python
        The version of python to install, should match one of the
        versions listed by pyenv.list
 
    CLI Example:
 
        salt '*' pyenv.install_python 2.0.0-p0
 
 
pyenv.is_installed:
 
    Check if pyenv is installed.
 
    CLI Example:
 
        salt '*' pyenv.is_installed
 
 
pyenv.list:
 
    List the installable versions of python.
 
    CLI Example:
 
        salt '*' pyenv.list
 
 
pyenv.rehash:
 
    Run pyenv rehash to update the installed shims.
 
    CLI Example:
 
        salt '*' pyenv.rehash
 
 
pyenv.uninstall_python:
 
    Uninstall a python implementation.
 
    python
        The version of python to uninstall. Should match one of the versions
        listed by :mod:`pyenv.versions <salt.modules.pyenv.versions>`
 
    CLI Example:
 
        salt '*' pyenv.uninstall_python 2.0.0-p0
 
 
pyenv.update:
 
    Updates the current versions of pyenv and python-Build
 
    CLI Example:
 
        salt '*' pyenv.update
 
 
pyenv.versions:
 
    List the installed versions of python.
 
    CLI Example:
 
        salt '*' pyenv.versions
 
 
random.get_str:
 
    New in version 2014.7.0
 
    Returns a random string of the specified length.
 
    length : 20
        Any valid number of bytes.
 
    CLI Example:
 
        salt '*' random.get_str 128
 
 
random.hash:
 
    New in version 2014.7.0
 
    Encodes a value with the specified encoder.
 
    value
        The value to be hashed.
 
    algorithm : sha512
        The algorithm to use. May be any valid algorithm supported by
        hashlib.
 
    CLI Example:
 
        salt '*' random.hash 'I am a string' md5
 
 
random.rand_int:
 
    Returns a random integer number between the start and end number.
 
    .. versionadded: 2015.5.3
 
    start : 1
        Any valid integer number
 
    end : 10
        Any valid integer number
 
    CLI Example:
 
        salt '*' random.rand_int 1 10
 
 
random.seed:
 
    Returns a random number within a range. Optional hash argument can
    be any hashable object. If hash is omitted or None, the id of the minion is used.
 
    .. versionadded: 2015.8.0
 
    hash: None
        Any hashable object.
 
    range: 10
        Any valid integer number
 
    CLI Example:
 
        salt '*' random.seed 10 hash=None
 
 
random.shadow_hash:
 
    Generates a salted hash suitable for /etc/shadow.
 
    crypt_salt : None
        Salt to be used in the generation of the hash. If one is not
        provided, a random salt will be generated.
 
    password : None
        Value to be salted and hashed. If one is not provided, a random
        password will be generated.
 
    algorithm : sha512
        Hash algorithm to use.
 
    CLI Example:
 
        salt '*' random.shadow_hash 'My5alT' 'MyP@asswd' md5
 
 
random.str_encode:
 
    New in version 2014.7.0
 
    value
        The value to be encoded.
 
    encoder : base64
        The encoder to use on the subsequent string.
 
    CLI Example:
 
        salt '*' random.str_encode 'I am a new string' base64
 
 
random_org.generateBlobs:
 
    List all Slack users.
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param format: Specifies the format in which the
                   blobs will be returned. Values
                   allowed are base64 and hex.
    :return: The user list.
 
    CLI Example:
 
        salt '*' get_integers number=5 min=1 max=6
 
        salt '*' get_integers number=5 min=1 max=6
 
 
random_org.generateDecimalFractions:
 
    Generates true random decimal fractions
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param number: How many random decimal fractions
                   you need. Must be within the [1,1e4] range.
    :param decimalPlaces: The number of decimal places
                          to use. Must be within the [1,20] range.
    :param replacement: Specifies whether the random numbers should
                        be picked with replacement. The default (true)
                        will cause the numbers to be picked with replacement,
                        i.e., the resulting numbers may contain duplicate
                        values (like a series of dice rolls). If you want the
                        numbers picked to be unique (like raffle tickets drawn
                        from a container), set this value to false.
    :return: A list of decimal fraction
 
    CLI Example:
 
        salt '*' random_org.generateDecimalFractions number=10 decimalPlaces=4
 
        salt '*' random_org.generateDecimalFractions number=10 decimalPlaces=4 replacement=True
 
 
 
random_org.generateGaussians:
 
    This method generates true random numbers from a
    Gaussian distribution (also known as a normal distribution).
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param number: How many random numbers you need.
                   Must be within the [1,1e4] range.
    :param mean: The distribution's mean. Must be
                 within the [-1e6,1e6] range.
    :param standardDeviation: The distribution's standard
                              deviation. Must be within
                              the [-1e6,1e6] range.
    :param significantDigits: The number of significant digits
                              to use. Must be within the [2,20] range.
    :return: The user list.
 
    CLI Example:
 
        salt '*' random_org.generateGaussians number=10 mean=0.0 standardDeviation=1.0 significantDigits=8
 
 
 
random_org.generateIntegers:
 
    Generate random integers
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param number: The number of integers to generate
    :param minimum: The lower boundary for the range from which the
                    random numbers will be picked. Must be within
                    the [-1e9,1e9] range.
    :param maximum: The upper boundary for the range from which the
                    random numbers will be picked. Must be within
                    the [-1e9,1e9] range.
    :param replacement: Specifies whether the random numbers should
                        be picked with replacement. The default (true)
                        will cause the numbers to be picked with replacement,
                        i.e., the resulting numbers may contain duplicate
                        values (like a series of dice rolls). If you want the
                        numbers picked to be unique (like raffle tickets drawn
                        from a container), set this value to false.
    :param base: Specifies the base that will be used to display the numbers.
                 Values allowed are 2, 8, 10 and 16. This affects the JSON
                 types and formatting of the resulting data as discussed below.
    :return: A list of integers.
 
    CLI Example:
 
        salt '*' random_org.generateIntegers number=5 minimum=1 maximum=6
 
        salt '*' random_org.generateIntegers number=5 minimum=2 maximum=255 base=2
 
 
 
random_org.generateStrings:
 
    Generate random strings.
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param number: The number of strings to generate.
    :param length: The length of each string. Must be
                   within the [1,20] range. All strings
                   will be of the same length
    :param characters: A string that contains the set of
                       characters that are allowed to occur
                       in the random strings. The maximum number
                       of characters is 80.
    :param replacement: Specifies whether the random strings should be picked
                        with replacement. The default (true) will cause the
                        strings to be picked with replacement, i.e., the
                        resulting list of strings may contain duplicates (like
                        a series of dice rolls). If you want the strings to be
                        unique (like raffle tickets drawn from a container), set
                        this value to false.
    :return: A list of strings.
 
    CLI Example:
 
        salt '*' random_org.generateStrings number=5 length=8 characters='abcdefghijklmnopqrstuvwxyz'
 
        salt '*' random_org.generateStrings number=10 length=16 characters'abcdefghijklmnopqrstuvwxyz'
 
 
 
random_org.generateUUIDs:
 
    Generate a list of random UUIDs
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :param number: How many random UUIDs you need.
                   Must be within the [1,1e3] range.
    :return: A list of UUIDs
 
    CLI Example:
 
        salt '*' random_org.generateUUIDs number=5
 
 
 
random_org.getUsage:
 
    Show current usages statistics
 
    :param api_key: The Random.org api key.
    :param api_version: The Random.org api version.
    :return: The current usage statistics.
 
    CLI Example:
 
        salt '*' random_org.getUsage
 
        salt '*' random_org.getUsage api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15 api_version=1
 
 
rbenv.default:
 
    Returns or sets the currently defined default ruby.
 
    ruby=None
        The version to set as the default. Should match one of the versions
        listed by :mod:`rbenv.versions <salt.modules.rbenv.versions>`. Leave
        blank to return the current default.
 
    CLI Example:
 
        salt '*' rbenv.default
        salt '*' rbenv.default 2.0.0-p0
 
 
rbenv.do:
 
    Execute a ruby command with rbenv's shims from the user or the system.
 
    CLI Example:
 
        salt '*' rbenv.do 'gem list bundler'
        salt '*' rbenv.do 'gem list bundler' deploy
 
 
rbenv.do_with_ruby:
 
    Execute a ruby command with rbenv's shims using a specific ruby version.
 
    CLI Example:
 
        salt '*' rbenv.do_with_ruby 2.0.0-p0 'gem list bundler'
        salt '*' rbenv.do_with_ruby 2.0.0-p0 'gem list bundler' deploy
 
 
rbenv.install:
 
    Install Rbenv systemwide
 
    CLI Example:
 
        salt '*' rbenv.install
 
 
rbenv.install_ruby:
 
    Install a ruby implementation.
 
    ruby
        The version of Ruby to install, should match one of the
        versions listed by rbenv.list
 
    Additional environment variables can be configured in pillar /
    grains / master:
 
        rbenv:
          build_env: 'CONFIGURE_OPTS="--no-tcmalloc" CFLAGS="-fno-tree-dce"'
 
    CLI Example:
 
        salt '*' rbenv.install_ruby 2.0.0-p0
 
 
rbenv.is_installed:
 
    Check if Rbenv is installed.
 
    CLI Example:
 
        salt '*' rbenv.is_installed
 
 
rbenv.list:
 
    List the installable versions of ruby.
 
    CLI Example:
 
        salt '*' rbenv.list
 
 
rbenv.rehash:
 
    Run rbenv rehash to update the installed shims.
 
    CLI Example:
 
        salt '*' rbenv.rehash
 
 
rbenv.uninstall_ruby:
 
    Uninstall a ruby implementation.
 
    ruby
        The version of ruby to uninstall. Should match one of the versions
        listed by :mod:`rbenv.versions <salt.modules.rbenv.versions>`
 
    CLI Example:
 
        salt '*' rbenv.uninstall_ruby 2.0.0-p0
 
 
rbenv.update:
 
    Updates the current versions of Rbenv and Ruby-Build
 
    CLI Example:
 
        salt '*' rbenv.update
 
 
rbenv.versions:
 
    List the installed versions of ruby.
 
    CLI Example:
 
        salt '*' rbenv.versions
 
 
ret.get_fun:
 
    Return info about last time fun was called on each minion
 
    CLI Example:
 
        salt '*' ret.get_fun mysql network.interfaces
 
 
ret.get_jid:
 
    Return the information for a specified job id
 
    CLI Example:
 
        salt '*' ret.get_jid redis 20421104181954700505
 
 
ret.get_jids:
 
    Return a list of all job ids
 
    CLI Example:
 
        salt '*' ret.get_jids mysql
 
 
ret.get_minions:
 
    Return a list of all minions
 
    CLI Example:
 
        salt '*' ret.get_minions mysql
 
 
rsync.config:
 
    Return rsync config
 
    CLI Example:
 
        salt '*' rsync.config
 
 
rsync.rsync:
 
    Rsync files from src to dst
 
    CLI Example:
 
        salt '*' rsync.rsync {src} {dst} {delete=True} {update=True} {passwordfile=/etc/pass.crt} {exclude=xx}
        salt '*' rsync.rsync {src} {dst} {delete=True} {excludefrom=/xx.ini}
 
 
rsync.version:
 
    Return rsync version
 
    CLI Example:
 
        salt '*' rsync.version
 
 
runit.available:
 
    Returns ``True`` if the specified service is available, otherwise returns
    ``False``.
 
    CLI Example:
 
        salt '*' runit.available foo
 
 
runit.full_restart:
 
    Calls runit.restart() function
 
    CLI Example:
 
        salt '*' runit.full_restart <service name>
 
 
runit.get_all:
 
    Return a list of all available services
 
    CLI Example:
 
        salt '*' runit.get_all
 
 
runit.missing:
 
    The inverse of runit.available.
    Returns ``True`` if the specified service is not available, otherwise returns
    ``False``.
 
    CLI Example:
 
        salt '*' runit.missing foo
 
 
runit.reload:
 
    Send a HUP to service via runit
 
    CLI Example:
 
        salt '*' runit.reload <service name>
 
 
runit.restart:
 
    Restart service via runit. This will stop/start service
 
    CLI Example:
 
        salt '*' runit.restart <service name>
 
 
runit.start:
 
    Starts service via runit
 
    CLI Example:
 
        salt '*' runit.start <service name>
 
 
runit.status:
 
    Return the status for a service via runit, return pid if running
 
    CLI Example:
 
        salt '*' runit.status <service name>
 
 
runit.stop:
 
    Stops service via runit
 
    CLI Example:
 
        salt '*' runit.stop <service name>
 
 
runit.term:
 
    Send a TERM to service via runit
 
    CLI Example:
 
        salt '*' runit.term <service name>
 
 
rvm.do:
 
    Execute a command in an RVM controlled environment.
 
    ruby:
        The ruby to use.
    command:
        The command to execute.
    runas : None
        The user to run rvm as.
    cwd : None
        The current working directory.
 
    CLI Example:
 
        salt '*' rvm.do 2.0.0 <command>
 
 
rvm.gemset_copy:
 
    Copy all gems from one gemset to another.
 
    source
        The name of the gemset to copy, complete with ruby version.
    destination
        The destination gemset.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_copy foobar bazquo
 
 
rvm.gemset_create:
 
    Creates a gemset.
 
    ruby
        The ruby version to create the gemset for.
    gemset
        The name of the gemset to create.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_create 2.0.0 foobar
 
 
rvm.gemset_delete:
 
    Deletes a gemset.
 
    ruby
        The ruby version the gemset belongs to.
    gemset
        The gemset to delete.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_delete 2.0.0 foobar
 
 
rvm.gemset_empty:
 
    Remove all gems from a gemset.
 
    ruby
        The ruby version the gemset belongs to.
    gemset
        The gemset to empty.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_empty 2.0.0 foobar
 
 
rvm.gemset_list:
 
    List all gemsets for the given ruby.
 
    ruby : default
        The ruby version to list the gemsets for
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_list
 
 
rvm.gemset_list_all:
 
    List all gemsets for all installed rubies.
 
    Note that you must have set a default ruby before this can work.
 
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.gemset_list_all
 
 
rvm.get:
 
    Update RVM.
 
    version : stable
        Which version of RVM to install, e.g. stable or head.
    ruby
        The version of ruby to reinstall.
 
    CLI Example:
 
        salt '*' rvm.get
 
 
rvm.install:
 
    Install RVM system wide.
 
    CLI Example:
 
        salt '*' rvm.install
 
 
rvm.install_ruby:
 
    Install a ruby implementation.
 
    ruby
        The version of ruby to install.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.install_ruby 1.9.3-p385
 
 
rvm.is_installed:
 
    Check if RVM is installed.
 
    CLI Example:
 
        salt '*' rvm.is_installed
 
 
rvm.list:
 
    List all rvm installed rubies.
 
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.list
 
 
rvm.reinstall_ruby:
 
    Reinstall a ruby implementation.
 
    ruby
        The version of ruby to reinstall.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.reinstall_ruby 1.9.3-p385
 
 
rvm.rubygems:
 
    Installs a specific rubygems version in the given ruby.
 
    ruby
        The ruby to install rubygems for.
    version
        The version of rubygems to install or 'remove' to use the version that
        ships with 1.9
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.rubygems 2.0.0 1.8.24
 
 
rvm.set_default:
 
    Set the default ruby.
 
    ruby
        The version of ruby to make the default.
    runas : None
        The user to run rvm as.
 
    CLI Example:
 
        salt '*' rvm.set_default 2.0.0
 
 
rvm.wrapper:
 
    Install RVM wrapper scripts.
 
    ruby_string
        Ruby/gemset to install wrappers for.
    wrapper_prefix
        What to prepend to the name of the generated wrapper binaries.
    runas : None
        The user to run rvm as.
    binaries : None
        The names of the binaries to create wrappers for. When nothing is
        given, wrappers for ruby, gem, rake, irb, rdoc, ri and testrb are
        generated.
 
    CLI Example:
 
        salt '*' rvm.wrapper <ruby_string> <wrapper_prefix>
 
 
s3.delete:
 
    Delete a bucket, or delete an object from a bucket.
 
    CLI Example to delete a bucket::
 
        salt myminion s3.delete mybucket
 
    CLI Example to delete an object from a bucket::
 
        salt myminion s3.delete mybucket remoteobject
 
 
s3.get:
 
    List the contents of a bucket, or return an object from a bucket. Set
    return_bin to True in order to retrieve an object wholesale. Otherwise,
    Salt will attempt to parse an XML response.
 
    CLI Example to list buckets:
 
        salt myminion s3.get
 
    CLI Example to list the contents of a bucket:
 
        salt myminion s3.get mybucket
 
    CLI Example to return the binary contents of an object:
 
        salt myminion s3.get mybucket myfile.png return_bin=True
 
    CLI Example to save the binary contents of an object to a local file:
 
        salt myminion s3.get mybucket myfile.png local_file=/tmp/myfile.png
 
    It is also possible to perform an action on a bucket. Currently, S3
    supports the following actions::
 
        acl
        cors
        lifecycle
        policy
        location
        logging
        notification
        tagging
        versions
        requestPayment
        versioning
        website
 
    To perform an action on a bucket:
 
        salt myminion s3.get mybucket myfile.png action=acl
 
 
s3.head:
 
    Return the metadata for a bucket, or an object in a bucket.
 
    CLI Examples:
 
        salt myminion s3.head mybucket
        salt myminion s3.head mybucket myfile.png
 
 
s3.put:
 
    Create a new bucket, or upload an object to a bucket.
 
    CLI Example to create a bucket:
 
        salt myminion s3.put mybucket
 
    CLI Example to upload an object to a bucket:
 
        salt myminion s3.put mybucket remotepath local_file=/path/to/file
 
 
saltutil.clear_cache:
 
    Forcibly removes all caches on a minion.
 
    New in version 2014.7.0
 
    WARNING: The safest way to clear a minion cache is by first stopping
    the minion and then deleting the cache files before restarting it.
 
    CLI Example:
 
        salt '*' saltutil.clear_cache
 
 
saltutil.cmd:
 
    Assuming this minion is a master, execute a salt command
 
    CLI Example:
 
        salt '*' saltutil.cmd
 
 
saltutil.cmd_iter:
 
    Assuming this minion is a master, execute a salt command
 
    CLI Example:
 
        salt '*' saltutil.cmd_iter
 
 
saltutil.find_cached_job:
 
    Return the data for a specific cached job id
 
    CLI Example:
 
        salt '*' saltutil.find_cached_job <job id>
 
 
saltutil.find_job:
 
    Return the data for a specific job id
 
    CLI Example:
 
        salt '*' saltutil.find_job <job id>
 
 
saltutil.is_running:
 
    If the named function is running return the data associated with it/them.
    The argument can be a glob
 
    CLI Example:
 
        salt '*' saltutil.is_running state.highstate
 
 
saltutil.kill_job:
 
    Sends a kill signal (SIGKILL 9) to the named salt job's process
 
    CLI Example:
 
        salt '*' saltutil.kill_job <job id>
 
 
saltutil.mmodule:
 
    Loads minion modules from an environment so that they can be used in pillars
    for that environment
 
    CLI Example:
 
        salt '*' saltutil.mmodule base test.ping
 
 
saltutil.pillar_refresh:
 
This function is an alias of ``refresh_pillar``.
 
    Signal the minion to refresh the pillar data.
 
    CLI Example:
 
        salt '*' saltutil.refresh_pillar
 
 
saltutil.refresh_beacons:
 
    Signal the minion to refresh the beacons.
 
    CLI Example:
 
        salt '*' saltutil.refresh_beacons
 
 
saltutil.refresh_modules:
 
    Signal the minion to refresh the module and grain data
 
    The default is to refresh module asynchronously. To block
    until the module refresh is complete, set the 'async' flag
    to False.
 
    CLI Example:
 
        salt '*' saltutil.refresh_modules
 
 
saltutil.refresh_pillar:
 
    Signal the minion to refresh the pillar data.
 
    CLI Example:
 
        salt '*' saltutil.refresh_pillar
 
 
saltutil.regen_keys:
 
    Used to regenerate the minion keys.
 
    CLI Example:
 
        salt '*' saltutil.regen_keys
 
 
saltutil.revoke_auth:
 
    The minion sends a request to the master to revoke its own key.
    Note that the minion session will be revoked and the minion may
    not be able to return the result of this command back to the master.
 
    If the 'preserve_minion_cache' flag is set to True, the master
    cache for this minion will not be removed.
 
    CLI Example:
 
        salt '*' saltutil.revoke_auth
 
 
saltutil.runner:
 
    Execute a runner module (this function must be run on the master)
 
    New in version 2014.7.0
 
    name
        The name of the function to run
    kwargs
        Any keyword arguments to pass to the runner function
 
    CLI Example:
 
        salt '*' saltutil.runner jobs.list_jobs
 
 
saltutil.running:
 
    Return the data on all running salt processes on the minion
 
    CLI Example:
 
        salt '*' saltutil.running
 
 
saltutil.signal_job:
 
    Sends a signal to the named salt job's process
 
    CLI Example:
 
        salt '*' saltutil.signal_job <job id> 15
 
 
saltutil.sync_all:
 
    Sync down all of the dynamic modules from the file server for a specific
    environment. This function synchronizes custom modules, states, beacons,
    grains, returners, output modules, renderers, and utils.
 
    refresh : True
        Also refresh the execution modules available to the minion.
 
    .. important::
 
        If this function is executed using a :py:func:`module.run
        <salt.states.module.run>` state, the SLS file will not have access to
        newly synced execution modules unless a ``refresh`` argument is
        added to the state, like so:
 
            load_my_custom_module:
              module.run:
                - name: saltutil.sync_all
                - refresh: True
 
        See :ref:`here <reloading-modules>` for a more detailed explanation of
        why this is necessary.
 
    CLI Example:
 
        salt '*' saltutil.sync_all
 
 
saltutil.sync_beacons:
 
    Sync the beacons from the _beacons directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _beacons directory, base is the default
    environment.
 
    New in version 2015.5.1
 
    CLI Example:
 
        salt '*' saltutil.sync_beacons
 
 
saltutil.sync_grains:
 
    Sync the grains from the _grains directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _grains directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_grains
 
 
saltutil.sync_log_handlers:
 
    New in version 2015.8.0
 
    Sync utility source files from the _log_handlers directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _log_handlers directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_log_handlers
 
 
saltutil.sync_modules:
 
    Sync the modules from the _modules directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _modules directory, base is the default
    environment.
 
    .. important::
 
        If this function is executed using a :py:func:`module.run
        <salt.states.module.run>` state, the SLS file will not have access to
        newly synced execution modules unless a ``refresh`` argument is
        added to the state, like so:
 
            load_my_custom_module:
              module.run:
                - name: saltutil.sync_modules
                - refresh: True
 
        See :ref:`here <reloading-modules>` for a more detailed explanation of
        why this is necessary.
 
    New in version 2015.5.1
 
    CLI Example:
 
        salt '*' saltutil.sync_modules
 
 
saltutil.sync_output:
 
    Sync the output modules from the _output directory on the salt master file
    server. This function is environment aware. Pass the desired environment
    to grab the contents of the _output directory. Base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_output
 
 
saltutil.sync_outputters:
 
This function is an alias of ``sync_output``.
 
    Sync the output modules from the _output directory on the salt master file
    server. This function is environment aware. Pass the desired environment
    to grab the contents of the _output directory. Base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_output
 
 
saltutil.sync_proxymodules:
 
    Sync the proxy modules from the _proxy directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _returners directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_proxymodules
 
 
saltutil.sync_renderers:
 
    Sync the renderers from the _renderers directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _renderers directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_renderers
 
 
saltutil.sync_returners:
 
    Sync the returners from the _returners directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _returners directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_returners
 
 
saltutil.sync_sdb:
 
    Sync sdb modules from the _sdb directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _sdb directory, base is the default
    environment.
 
    New in version 2015.5.7
 
    CLI Example:
 
        salt '*' saltutil.sync_sdb
 
 
saltutil.sync_states:
 
    Sync the states from the _states directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _states directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_states
 
 
saltutil.sync_utils:
 
    Sync utility source files from the _utils directory on the salt master file
    server. This function is environment aware, pass the desired environment
    to grab the contents of the _utils directory, base is the default
    environment.
 
    CLI Example:
 
        salt '*' saltutil.sync_utils
 
 
saltutil.term_job:
 
    Sends a termination signal (SIGTERM 15) to the named salt job's process
 
    CLI Example:
 
        salt '*' saltutil.term_job <job id>
 
 
saltutil.update:
 
    Update the salt minion from the URL defined in opts['update_url']
    SaltStack, Inc provides the latest builds here:
    update_url: https://repo.saltstack.com/windows/
 
    Be aware that as of 2014-8-11 there's a bug in esky such that only the
    latest version available in the update_url can be downloaded and installed.
 
    This feature requires the minion to be running a bdist_esky build.
 
    The version number is optional and will default to the most recent version
    available at opts['update_url'].
 
    Returns details about the transaction upon completion.
 
    CLI Example:
 
        salt '*' saltutil.update
        salt '*' saltutil.update 0.10.3
 
 
saltutil.wheel:
 
    Execute a wheel module (this function must be run on the master)
 
    New in version 2014.7.0
 
    name
        The name of the function to run
    kwargs
        Any keyword arguments to pass to the wheel function
 
    CLI Example:
 
        salt '*' saltutil.wheel key.accept match=jerry
 
 
schedule.add:
 
    Add a job to the schedule
 
    CLI Example:
 
        salt '*' schedule.add job1 function='test.ping' seconds=3600
        # If function have some arguments, use job_args
        salt '*' schedule.add job2 function='cmd.run' job_args="['date >> /tmp/date.log']" seconds=60
 
 
schedule.build_schedule_item:
 
    Build a schedule job
 
    CLI Example:
 
        salt '*' schedule.build_schedule_item job1 function='test.ping' seconds=3600
 
 
schedule.copy:
 
    Copy scheduled job to another minion or minions.
 
    CLI Example:
 
        salt '*' schedule.copy jobname target
 
 
schedule.delete:
 
    Delete a job from the minion's schedule
 
    CLI Example:
 
        salt '*' schedule.delete job1
 
 
schedule.disable:
 
    Disable all scheduled jobs on the minion
 
    CLI Example:
 
        salt '*' schedule.disable
 
 
schedule.disable_job:
 
    Disable a job in the minion's schedule
 
    CLI Example:
 
        salt '*' schedule.disable_job job1
 
 
schedule.enable:
 
    Enable all scheduled jobs on the minion
 
    CLI Example:
 
        salt '*' schedule.enable
 
 
schedule.enable_job:
 
    Enable a job in the minion's schedule
 
    CLI Example:
 
        salt '*' schedule.enable_job job1
 
 
schedule.is_enabled:
 
    List a Job only if its enabled
 
    New in version 2015.5.3
 
    CLI Example:
 
        salt '*' schedule.is_enabled name=job_name
 
 
schedule.list:
 
    List the jobs currently scheduled on the minion
 
    CLI Example:
 
        salt '*' schedule.list
 
        salt '*' schedule.list show_all=True
 
 
schedule.modify:
 
    Modify an existing job in the schedule
 
    CLI Example:
 
        salt '*' schedule.modify job1 function='test.ping' seconds=3600
 
 
schedule.move:
 
    Move scheduled job to another minion or minions.
 
    CLI Example:
 
        salt '*' schedule.move jobname target
 
 
schedule.purge:
 
    Purge all the jobs currently scheduled on the minion
 
    CLI Example:
 
        salt '*' schedule.purge
 
 
schedule.reload:
 
    Reload saved scheduled jobs on the minion
 
    CLI Example:
 
        salt '*' schedule.reload
 
 
schedule.run_job:
 
    Run a scheduled job on the minion immediately
 
    CLI Example:
 
        salt '*' schedule.run_job job1
 
        salt '*' schedule.run_job job1 force=True
        Force the job to run even if it is disabled.
 
 
schedule.save:
 
    Save all scheduled jobs on the minion
 
    CLI Example:
 
        salt '*' schedule.save
 
 
scsi.ls:
 
    List SCSI devices, with details
 
    CLI Example:
 
        salt '*' scsi.ls
 
 
scsi.rescan_all:
 
    List scsi devices
 
    CLI Example:
 
        salt '*' scsi.rescan_all(0)
 
 
sdb.get:
 
    Get a value from a db, using a uri in the form of sdb://<profile>/<key>. If
    the uri provided does not start with sdb://, then it will be returned as-is.
 
    CLI Example:
 
        salt '*' sdb.get sdb://mymemcached/foo
 
 
sdb.set:
 
    Set a value in a db, using a uri in the form of ``sdb://<profile>/<key>``.
    If the uri provided does not start with ``sdb://`` or the value is not
    successfully set, return ``False``.
 
    CLI Example:
 
        salt '*' sdb.set sdb://mymemcached/foo bar
 
 
seed.apply:
 
    Seed a location (disk image, directory, or block device) with the
    minion config, approve the minion's key, and/or install salt-minion.
 
    CLI Example:
 
        salt 'minion' seed.apply path id [config=config_data] \
                [gen_key=(true|false)] [approve_key=(true|false)] \
                [install=(true|false)]
 
    path
        Full path to the directory, device, or disk image  on the target
        minion's file system.
 
    id
        Minion id with which to seed the path.
 
    config
        Minion configuration options. By default, the 'master' option is set to
        the target host's 'master'.
 
    approve_key
        Request a pre-approval of the generated minion key. Requires
        that the salt-master be configured to either auto-accept all keys or
        expect a signing request from the target host. Default: true.
 
    install
        Install salt-minion, if absent. Default: true.
 
    prep_install
        Prepare the bootstrap script, but don't run it. Default: false
 
 
seed.mkconfig:
 
    Generate keys and config and put them in a tmp directory.
 
    pub_key
        absolute path or file content of an optional preseeded salt key
 
    priv_key
        absolute path or file content of an optional preseeded salt key
 
    CLI Example:
 
        salt 'minion' seed.mkconfig [config=config_data] [tmp=tmp_dir] \
                [id_=minion_id] [approve_key=(true|false)]
 
 
seed.prep_bootstrap:
 
    Update and get the random script to a random place
 
    CLI Example:
 
        salt '*' seed.prep_bootstrap /tmp
 
 
 
serverdensity_device.create:
 
    Function to create device in Server Density. For more info, see the `API
    docs`__.
 
    .. __: https://apidocs.serverdensity.com/Inventory/Devices/Creating
 
    CLI Example:
 
        salt '*' serverdensity_device.create lama
        salt '*' serverdensity_device.create rich_lama group=lama_band installedRAM=32768
 
 
serverdensity_device.delete:
 
    Delete a device from Server Density. For more information, see the `API
    docs`__.
 
    .. __: https://apidocs.serverdensity.com/Inventory/Devices/Deleting
 
    CLI Example:
 
        salt '*' serverdensity_device.delete 51f7eafcdba4bb235e000ae4
 
 
serverdensity_device.get_sd_auth:
 
    Returns requested Server Density authentication value from pillar.
 
    CLI Example:
 
        salt '*' serverdensity_device.get_sd_auth <val>
 
 
serverdensity_device.install_agent:
 
    Function downloads Server Density installation agent, and installs sd-agent
    with agent_key.
 
    CLI Example:
 
        salt '*' serverdensity_device.install_agent c2bbdd6689ff46282bdaa07555641498
 
 
serverdensity_device.ls:
 
    List devices in Server Density
 
    Results will be filtered by any params passed to this function. For more
    information, see the API docs on listing_ and searching_.
 
    .. _listing: https://apidocs.serverdensity.com/Inventory/Devices/Listing
    .. _searching: https://apidocs.serverdensity.com/Inventory/Devices/Searching
 
    CLI Example:
 
        salt '*' serverdensity_device.ls
        salt '*' serverdensity_device.ls name=lama
        salt '*' serverdensity_device.ls name=lama group=lama_band installedRAM=32768
 
 
serverdensity_device.update:
 
    Updates device information in Server Density. For more information see the
    `API docs`__.
 
    .. __: https://apidocs.serverdensity.com/Inventory/Devices/Updating
 
    CLI Example:
 
        salt '*' serverdensity_device.update 51f7eafcdba4bb235e000ae4 name=lama group=lama_band
        salt '*' serverdensity_device.update 51f7eafcdba4bb235e000ae4 name=better_lama group=rock_lamas swapSpace=512
 
 
service.available:
 
    Check that the given service is available taking into account
    template units.
 
    CLI Example:
 
        salt '*' service.available sshd
 
 
service.disable:
 
    Disable the named service to not start when the system boots
 
    CLI Example:
 
        salt '*' service.disable <service name>
 
 
service.disabled:
 
    Return if the named service is disabled to start on boot
 
    CLI Example:
 
        salt '*' service.disabled <service name>
 
 
service.enable:
 
    Enable the named service to start when the system boots
 
    CLI Example:
 
        salt '*' service.enable <service name>
 
 
service.enabled:
 
    Return if the named service is enabled to start on boot
 
    CLI Example:
 
        salt '*' service.enabled <service name>
 
 
service.execs:
 
    Return a list of all files specified as ``ExecStart`` for all services.
 
    CLI Example:
 
        salt '*' service.execs
 
 
service.force_reload:
 
    Force-reload the specified service with systemd
 
    CLI Example:
 
        salt '*' service.force_reload <service name>
 
 
service.get_all:
 
    Return a list of all available services
 
    CLI Example:
 
        salt '*' service.get_all
 
 
service.get_disabled:
 
    Return a list of all disabled services
 
    CLI Example:
 
        salt '*' service.get_disabled
 
 
service.get_enabled:
 
    Return a list of all enabled services
 
    CLI Example:
 
        salt '*' service.get_enabled
 
 
service.mask:
 
    Mask the specified service with systemd
 
    CLI Example:
 
        salt '*' service.mask <service name>
 
 
service.masked:
 
    Return if the named service is masked.
 
    New in version 2015.8.0
 
    CLI Example:
 
        salt '*' service.masked <service name>
 
 
service.missing:
 
    The inverse of service.available.
    Returns ``True`` if the specified service is not available, otherwise returns
    ``False``.
 
    CLI Example:
 
        salt '*' service.missing sshd
 
 
service.reload:
 
    Reload the specified service with systemd
 
    CLI Example:
 
        salt '*' service.reload <service name>
 
 
service.restart:
 
    Restart the specified service with systemd
 
    CLI Example:
 
        salt '*' service.restart <service name>
 
 
service.show:
 
    Show properties of one or more units/jobs or the manager
 
    CLI Example:
 
        salt '*' service.show <service name>
 
 
service.start:
 
    Start the specified service with systemd
 
    CLI Example:
 
        salt '*' service.start <service name>
 
 
service.status:
 
    Return the status for a service via systemd, returns a bool
    whether the service is running.
 
    CLI Example:
 
        salt '*' service.status <service name>
 
 
service.stop:
 
    Stop the specified service with systemd
 
    CLI Example:
 
        salt '*' service.stop <service name>
 
 
service.systemctl_reload:
 
    Reloads systemctl, an action needed whenever unit files are updated.
 
    CLI Example:
 
        salt '*' service.systemctl_reload
 
 
service.unmask:
 
    Unmask the specified service with systemd
 
    CLI Example:
 
        salt '*' service.unmask <service name>
 
 
shadow.default_hash:
 
    Returns the default hash used for unset passwords
 
    CLI Example:
 
        salt '*' shadow.default_hash
 
 
shadow.del_password:
 
    New in version 2014.7.0
 
    Delete the password from name user
 
    CLI Example:
 
        salt '*' shadow.del_password username
 
 
shadow.gen_password:
 
    New in version 2014.7.0
 
    Generate hashed password
 
    Note:
 
        When called this function is called directly via remote-execution,
        the password argument may be displayed in the system's process list.
        This may be a security risk on certain systems.
 
    password
        Plaintext password to be hashed.
 
    crypt_salt
        Crpytographic salt. If not given, a random 8-character salt will be
        generated.
 
    algorithm
        The following hash algorithms are supported:
 
        * md5
        * blowfish (not in mainline glibc, only available in distros that add it)
        * sha256
        * sha512 (default)
 
    CLI Example:
 
        salt '*' shadow.gen_password 'I_am_password'
        salt '*' shadow.gen_password 'I_am_password' crypt_salt='I_am_salt' algorithm=sha256
 
 
shadow.info:
 
    Return information for the specified user
 
    CLI Example:
 
        salt '*' shadow.info root
 
 
shadow.set_date:
 
    Sets the value for the date the password was last changed to days since the
    epoch (January 1, 1970). See man chage.
 
    CLI Example:
 
        salt '*' shadow.set_date username 0
 
 
shadow.set_expire:
 
    Changed in version 2014.7.0
 
    Sets the value for the date the account expires as days since the epoch
    (January 1, 1970). Using a value of -1 will clear expiration. See man
    chage.
 
    CLI Example:
 
        salt '*' shadow.set_expire username -1
 
 
shadow.set_inactdays:
 
    Set the number of days of inactivity after a password has expired before
    the account is locked. See man chage.
 
    CLI Example:
 
        salt '*' shadow.set_inactdays username 7
 
 
shadow.set_maxdays:
 
    Set the maximum number of days during which a password is valid.
    See man chage.
 
    CLI Example:
 
        salt '*' shadow.set_maxdays username 90
 
 
shadow.set_mindays:
 
    Set the minimum number of days between password changes. See man chage.
 
    CLI Example:
 
        salt '*' shadow.set_mindays username 7
 
 
shadow.set_password:
 
    Set the password for a named user. The password must be a properly defined
    hash. The password hash can be generated with this command:
 
    ``python -c "import crypt; print crypt.crypt('password',
    '\$6\$SALTsalt')"``
 
    ``SALTsalt`` is the 8-character crpytographic salt. Valid characters in the
    salt are ``.``, ``/``, and any alphanumeric character.
 
    Keep in mind that the $6 represents a sha512 hash, if your OS is using a
    different hashing algorithm this needs to be changed accordingly
 
    CLI Example:
 
        salt '*' shadow.set_password root '$1$UYCIxa628.9qXjpQCjM4a..'
 
 
shadow.set_warndays:
 
    Set the number of days of warning before a password change is required.
    See man chage.
 
    CLI Example:
 
        salt '*' shadow.set_warndays username 7
 
 
slack.find_room:
 
    Find a room by name and return it.
 
    :param name:    The room name.
    :param api_key: The Slack admin api key.
    :return:        The room object.
 
    CLI Example:
 
        salt '*' slack.find_room name="random"
 
        salt '*' slack.find_room name="random" api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15
 
 
slack.find_user:
 
    Find a user by name and return it.
 
    :param name:        The user name.
    :param api_key:     The Slack admin api key.
    :return:            The user object.
 
    CLI Example:
 
        salt '*' slack.find_user name="ThomasHatch"
 
        salt '*' slack.find_user name="ThomasHatch" api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15
 
 
slack.list_rooms:
 
    List all Slack rooms.
 
    :param api_key: The Slack admin api key.
    :return: The room list.
 
    CLI Example:
 
        salt '*' slack.list_rooms
 
        salt '*' slack.list_rooms api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15
 
 
slack.list_users:
 
    List all Slack users.
 
    :param api_key: The Slack admin api key.
    :return: The user list.
 
    CLI Example:
 
        salt '*' slack.list_users
 
        salt '*' slack.list_users api_key=peWcBiMOS9HrZG15peWcBiMOS9HrZG15
 
 
slack.post_message:
 
    Send a message to a Slack channel.
 
    :param channel:     The channel name, either will work.
    :param message:     The message to send to the Slack channel.
    :param from_name:   Specify who the message is from.
    :param api_key:     The Slack api key, if not specified in the configuration.
    :return:            Boolean if message was sent successfully.
 
    CLI Example:
 
        salt '*' slack.post_message channel="Development Room" message="Build is done" from_name="Build Server"
 
 
 
slsutil.merge:
Merge a data structure into another by choosing a merge strategy
 
Strategies:
 
* aggregate
* list
* overwrite
* recurse
* smart
 
CLI Example:
 
    salt '*' slsutil.merge '{foo: Foo}' '{bar: Bar}'
 
 
slsutil.update:
 
    Recursive version of the default dict.update
 
    Merges upd recursively into dest
 
    If recursive_update=False, will use the classic dict.update, or fall back
    on a manual merge (helpful for non-dict types like FunctionWrapper)
 
    If merge_lists=True, will aggregate list object types instead of replace.
    This behavior is only activated when recursive_update=True. By default
    merge_lists=False.
 
CLI Example:
 
    salt '*' slsutil.update '{foo: Foo}' '{bar: Bar}'
 
 
 
smbios.get:
 
    Get an individual DMI string from SMBIOS info
 
    string
        The string to fetch. DMIdecode supports:
          - ``bios-vendor``
          - ``bios-version``
          - ``bios-release-date``
          - ``system-manufacturer``
          - ``system-product-name``
          - ``system-version``
          - ``system-serial-number``
          - ``system-uuid``
          - ``baseboard-manufacturer``
          - ``baseboard-product-name``
          - ``baseboard-version``
          - ``baseboard-serial-number``
          - ``baseboard-asset-tag``
          - ``chassis-manufacturer``
          - ``chassis-type``
          - ``chassis-version``
          - ``chassis-serial-number``
          - ``chassis-asset-tag``
          - ``processor-family``
          - ``processor-manufacturer``
          - ``processor-version``
          - ``processor-frequency``
 
    clean
      | Don't return well-known false information
      | (invalid UUID's, serial 000000000's, etcetera)
      | Defaults to ``True``
 
    CLI Example:
 
        salt '*' smbios.get system-uuid clean=False
 
 
smbios.records:
 
    Return DMI records from SMBIOS
 
    type
        Return only records of type(s)
        The SMBIOS specification defines the following DMI types:
 
        ====  ======================================
        Type  Information
        ====  ======================================
         0    BIOS
         1    System
         2    Baseboard
         3    Chassis
         4    Processor
         5    Memory Controller
         6    Memory Module
         7    Cache
         8    Port Connector
         9    System Slots
        10    On Board Devices
        11    OEM Strings
        12    System Configuration Options
        13    BIOS Language
        14    Group Associations
        15    System Event Log
        16    Physical Memory Array
        17    Memory Device
        18    32-bit Memory Error
        19    Memory Array Mapped Address
        20    Memory Device Mapped Address
        21    Built-in Pointing Device
        22    Portable Battery
        23    System Reset
        24    Hardware Security
        25    System Power Controls
        26    Voltage Probe
        27    Cooling Device
        28    Temperature Probe
        29    Electrical Current Probe
        30    Out-of-band Remote Access
        31    Boot Integrity Services
        32    System Boot
        33    64-bit Memory Error
        34    Management Device
        35    Management Device Component
        36    Management Device Threshold Data
        37    Memory Channel
        38    IPMI Device
        39    Power Supply
        40    Additional Information
        41    Onboard Devices Extended Information
        42    Management Controller Host Interface
        ====  ======================================
 
    clean
      | Don't return well-known false information
      | (invalid UUID's, serial 000000000's, etcetera)
      | Defaults to ``True``
 
    CLI Example:
 
        salt '*' smbios.records clean=False
        salt '*' smbios.records 14
        salt '*' smbios.records 4 core_count,thread_count,current_speed
 
 
 
smtp.send_msg:
 
    Send a message to an SMTP recipient. Designed for use in states.
 
    CLI Examples:
 
        smtp.send_msg 'admin@example.com' 'This is a salt module test'             profile='my-smtp-account'
        smtp.send_msg 'admin@example.com' 'This is a salt module test'             username='myuser' password='verybadpass' sender="admin@example.com'             server='smtp.domain.com'
 
 
splay.show:
 
    Show calculated splaytime for this minion
    Will use default value of 600 (seconds) if splaytime value not provided
 
 
    CLI Example:
        salt example-host splay.show
        salt example-host splay.show 60
 
 
splay.splay:
 
    Splay a salt function call execution time across minions over
    a number of seconds (default: 600)
 
    Note:
        You *probably* want to use --async here and look up the job results later.
        If you're dead set on getting the output from the CLI command, then make
        sure to set the timeout (with the -t flag) to something greater than the
        splaytime (max splaytime + time to execute job).
        Otherwise, it's very likely that the cli will time out before the job returns.
 
 
    CLI Examples:
 
        salt --async '*' splay.splay pkg.install cowsay version=3.03-8.el6
 
      # With specified splaytime (5 minutes) and timeout with 10 second buffer
      salt -t 310 '*' splay.splay 300 pkg.version cowsay
 
 
sqlite3.fetch:
 
    Retrieve data from an sqlite3 db (returns all rows, be careful!)
 
    CLI Example:
 
        salt '*' sqlite3.fetch /root/test.db 'SELECT * FROM test;'
 
 
sqlite3.indexes:
 
    Show all indices in the database, for people with poor spelling skills
 
    CLI Example:
 
        salt '*' sqlite3.indexes /root/test.db
 
 
sqlite3.indices:
 
    Show all indices in the database
 
    CLI Example:
 
        salt '*' sqlite3.indices /root/test.db
 
 
sqlite3.modify:
 
    Issue an SQL query to sqlite3 (with no return data), usually used
    to modify the database in some way (insert, delete, create, etc)
 
    CLI Example:
 
        salt '*' sqlite3.modify /root/test.db 'CREATE TABLE test(id INT, testdata TEXT);'
 
 
sqlite3.sqlite_version:
 
    Return version of sqlite
 
    CLI Example:
 
        salt '*' sqlite3.sqlite_version
 
 
sqlite3.tables:
 
    Show all tables in the database
 
    CLI Example:
 
        salt '*' sqlite3.tables /root/test.db
 
 
sqlite3.version:
 
    Return version of pysqlite
 
    CLI Example:
 
        salt '*' sqlite3.version
 
 
ssh.auth_keys:
 
    Return the authorized keys for users
 
    CLI Example:
 
        salt '*' ssh.auth_keys
        salt '*' ssh.auth_keys root
        salt '*' ssh.auth_keys user=root
        salt '*' ssh.auth_keys user="[user1, user2]"
 
 
ssh.check_key:
 
    Check to see if a key needs updating, returns "update", "add" or "exists"
 
    CLI Example:
 
        salt '*' ssh.check_key <user> <key> <enc> <comment> <options>
 
 
ssh.check_key_file:
 
    Check a keyfile from a source destination against the local keys and
    return the keys to change
 
    CLI Example:
 
        salt '*' ssh.check_key_file root salt://ssh/keyfile
 
 
ssh.check_known_host:
 
    Check the record in known_hosts file, either by its value or by fingerprint
    (it's enough to set up either key or fingerprint, you don't need to set up
    both).
 
    If provided key or fingerprint doesn't match with stored value, return
    "update", if no value is found for a given host, return "add", otherwise
    return "exists".
 
    If neither key, nor fingerprint is defined, then additional validation is
    not performed.
 
    CLI Example:
 
        salt '*' ssh.check_known_host <user> <hostname> key='AAAA...FAaQ=='
 
 
ssh.get_known_host:
 
    Return information about known host from the configfile, if any.
    If there is no such key, return None.
 
    CLI Example:
 
        salt '*' ssh.get_known_host <user> <hostname>
 
 
ssh.hash_known_hosts:
 
 
    Hash all the hostnames in the known hosts file.
 
    New in version 2014.7.0
 
    user
        hash known hosts of this user
 
    config
        path to known hosts file: can be absolute or relative to user's home
        directory
 
    CLI Example:
 
        salt '*' ssh.hash_known_hosts
 
 
 
ssh.host_keys:
 
    Return the minion's host keys
 
    CLI Example:
 
        salt '*' ssh.host_keys
        salt '*' ssh.host_keys keydir=/etc/ssh
        salt '*' ssh.host_keys keydir=/etc/ssh private=False
 
 
ssh.recv_known_host:
 
    Retrieve information about host public key from remote server
 
    hostname
        The name of the remote host (e.g. "github.com")
 
    enc
        Defines what type of key is being used, can be ed25519, ecdsa ssh-rsa
        or ssh-dss
 
    port
        optional parameter, denoting the port of the remote host, which will be
        used in case, if the public key will be requested from it. By default
        the port 22 is used.
 
    hash_hostname : True
        Hash all hostnames and addresses in the known hosts file.
 
        .. deprecated:: Carbon
 
            Please use hash_known_hosts instead.
 
    hash_known_hosts : True
        Hash all hostnames and addresses in the known hosts file.
 
    CLI Example:
 
        salt '*' ssh.recv_known_host <hostname> enc=<enc> port=<port>
 
 
ssh.rm_auth_key:
 
    Remove an authorized key from the specified user's authorized key file
 
    CLI Example:
 
        salt '*' ssh.rm_auth_key <user> <key>
 
 
ssh.rm_auth_key_from_file:
 
    Remove an authorized key from the specified user's authorized key file, using a file as source
 
    CLI Example:
 
        salt '*' ssh.rm_auth_key_from_file <user> salt://ssh_keys/<user>.id_rsa.pub
 
 
ssh.rm_known_host:
 
    Remove all keys belonging to hostname from a known_hosts file.
 
    CLI Example:
 
        salt '*' ssh.rm_known_host <user> <hostname>
 
 
ssh.set_auth_key:
 
    Add a key to the authorized_keys file. The "key" parameter must only be the
    string of text that is the encoded key. If the key begins with "ssh-rsa"
    or ends with user@host, remove those from the key before passing it to this
    function.
 
    CLI Example:
 
        salt '*' ssh.set_auth_key <user> '<key>' enc='dsa'
 
 
ssh.set_auth_key_from_file:
 
    Add a key to the authorized_keys file, using a file as the source.
 
    CLI Example:
 
        salt '*' ssh.set_auth_key_from_file <user> salt://ssh_keys/<user>.id_rsa.pub
 
 
ssh.set_known_host:
 
    Download SSH public key from remote host "hostname", optionally validate
    its fingerprint against "fingerprint" variable and save the record in the
    known_hosts file.
 
    If such a record does already exists in there, do nothing.
 
    user
        The user who owns the ssh authorized keys file to modify
 
    hostname
        The name of the remote host (e.g. "github.com")
 
    fingerprint
        The fingerprint of the key which must be presented in the known_hosts
        file (optional if key specified)
 
    key
        The public key which must be presented in the known_hosts file
        (optional if fingerprint specified)
 
    port
        optional parameter, denoting the port of the remote host, which will be
        used in case, if the public key will be requested from it. By default
        the port 22 is used.
 
    enc
        Defines what type of key is being used, can be ed25519, ecdsa ssh-rsa
        or ssh-dss
 
    hash_hostname : True
        Hash all hostnames and addresses in the known hosts file.
 
        .. deprecated:: Carbon
 
            Please use hash_known_hosts instead.
 
    config
        The location of the authorized keys file relative to the user's home
        directory, defaults to ".ssh/known_hosts". If no user is specified,
        defaults to "/etc/ssh/ssh_known_hosts". If present, must be an
        absolute path when a user is not specified.
 
    hash_known_hosts : True
        Hash all hostnames and addresses in the known hosts file.
 
    CLI Example:
 
        salt '*' ssh.set_known_host <user> fingerprint='xx:xx:..:xx' enc='ssh-rsa' config='.ssh/known_hosts'
 
 
ssh.user_keys:
 
 
    Return the user's ssh keys on the minion
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' ssh.user_keys
        salt '*' ssh.user_keys user=user1
        salt '*' ssh.user_keys user=user1 pubfile=/home/user1/.ssh/id_rsa.pub prvfile=/home/user1/.ssh/id_rsa
        salt '*' ssh.user_keys user=user1 prvfile=False
        salt '*' ssh.user_keys user="['user1','user2'] pubfile=id_rsa.pub prvfile=id_rsa
 
    As you can see you can tell Salt not to read from the user's private (or public) key file by setting the
    file path to ``False``. This can be useful to prevent Salt from publishing private data via Salt Mine or
    others.
 
 
state.apply:
 
    New in version 2015.5.0
 
    Apply states! This function will call highstate or state.sls based on the
    arguments passed in, state.apply is intended to be the main gateway for
    all state executions.
 
    CLI Example:
 
        salt '*' state.apply
        salt '*' state.apply test
        salt '*' state.apply test,pkgs
 
 
state.check_request:
 
    New in version 2015.5.0
 
    Return the state request information, if any
 
    CLI Example:
 
        salt '*' state.check_request
 
 
state.clear_cache:
 
    Clear out cached state files, forcing even cache runs to refresh the cache
    on the next state execution.
 
    Remember that the state cache is completely disabled by default, this
    execution only applies if cache=True is used in states
 
    CLI Example:
 
        salt '*' state.clear_cache
 
 
state.clear_request:
 
    New in version 2015.5.0
 
    Clear out the state execution request without executing it
 
    CLI Example:
 
        salt '*' state.clear_request
 
 
state.disable:
 
    Disable state runs.
 
    CLI Example:
 
        salt '*' state.disable highstate
 
        salt '*' state.disable highstate,test.succeed_without_changes
 
    Note:
        To disable a state file from running provide the same name that would
        be passed in a state.sls call.
 
        salt '*' state.disable bind.config
 
 
 
state.enable:
 
    Enable state function or sls run
 
    CLI Example:
 
        salt '*' state.enable highstate
 
        salt '*' state.enable test.succeed_without_changes
 
    Note:
        To enable a state file from running provide the same name that would
        be passed in a state.sls call.
 
        salt '*' state.disable bind.config
 
 
 
state.high:
 
    Execute the compound calls stored in a single set of high data
    This function is mostly intended for testing the state system
 
    CLI Example:
 
        salt '*' state.high '{"vim": {"pkg": ["installed"]}}'
 
 
state.highstate:
 
    Retrieve the state data from the salt master for this minion and execute it
 
    test
        Notify states to execute in test-only (dry-run) mode.
 
        Sets the ``test`` variable in the minion ``opts`` for the duration of
        the state run.
    pillar
        Custom Pillar data can be passed with the ``pillar`` kwarg. Values
        passed here will override hard-coded Pillar values.
    queue : ``False``
        Instead of failing immediately when another state run is in progress,
        queue the new state run to begin running once the other has finished.
 
        This option starts a new thread for each queued state run so use this
        option sparingly.
    localconfig:
        Instead of using running minion opts, load ``localconfig`` and merge that
        with the running minion opts. This functionality is intended for using
        "roots" of salt directories (with their own minion config, pillars,
        file_roots) to run highstate out of.
 
    mock:
        The mock option allows for the state run to execute without actually
        calling any states. This then returns a mocked return which will show
        the requisite ordering as well as fully validate the state run.
 
        New in version 2015.8.4
 
    CLI Example:
 
        salt '*' state.highstate
 
        salt '*' state.highstate whitelist=sls1_to_run,sls2_to_run
        salt '*' state.highstate exclude=sls_to_exclude
        salt '*' state.highstate exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
 
        salt '*' state.highstate pillar="{foo: 'Foo!', bar: 'Bar!'}"
 
 
state.list_disabled:
 
    List the states which are currently disabled
 
    CLI Example:
 
        salt '*' state.list_disabled
 
 
state.low:
 
    Execute a single low data call
    This function is mostly intended for testing the state system
 
    CLI Example:
 
        salt '*' state.low '{"state": "pkg", "fun": "installed", "name": "vi"}'
 
 
state.pkg:
 
    Execute a packaged state run, the packaged state run will exist in a
    tarball available locally. This packaged state
    can be generated using salt-ssh.
 
    CLI Example:
 
        salt '*' state.pkg /tmp/state_pkg.tgz
 
 
state.request:
 
    New in version 2015.5.0
 
    Request that the local admin execute a state run via
    `salt-call state.run_request`
    All arguments match state.apply
 
    CLI Example:
 
        salt '*' state.request
        salt '*' state.request test
        salt '*' state.request test,pkgs
 
 
state.run_request:
 
    New in version 2015.5.0
 
    Execute the pending state request
 
    CLI Example:
 
        salt '*' state.run_request
 
 
state.running:
 
    Return a list of strings that contain state return data if a state function is
    already running. This function is used to prevent multiple state calls from being
    run at the same time.
 
    CLI Example:
 
        salt '*' state.running
 
 
state.show_highstate:
 
    Retrieve the highstate data from the salt master and display it
 
    Custom Pillar data can be passed with the ``pillar`` kwarg.
 
    CLI Example:
 
        salt '*' state.show_highstate
 
 
state.show_low_sls:
 
    Display the low data from a specific sls. The default environment is
    ``base``, use ``saltenv`` (``env`` in Salt 0.17.x and older) to specify a
    different environment.
 
    CLI Example:
 
        salt '*' state.show_low_sls foo
 
 
state.show_lowstate:
 
    List out the low data that will be applied to this minion
 
    CLI Example:
 
        salt '*' state.show_lowstate
 
 
state.show_sls:
 
    Display the state data from a specific sls or list of sls files on the
    master. The default environment is ``base``, use ``saltenv`` (``env`` in
    Salt 0.17.x and older) to specify a different environment.
 
    This function does not support topfiles.  For ``top.sls`` please use
    ``show_top`` instead.
 
    Custom Pillar data can be passed with the ``pillar`` kwarg.
 
    CLI Example:
 
        salt '*' state.show_sls core,edit.vim dev
 
 
state.show_top:
 
    Return the top data that the minion will use for a highstate
 
    CLI Example:
 
        salt '*' state.show_top
 
 
state.single:
 
    Execute a single state function with the named kwargs, returns False if
    insufficient data is sent to the command
 
    By default, the values of the kwargs will be parsed as YAML. So, you can
    specify lists values, or lists of single entry key-value maps, as you
    would in a YAML salt file. Alternatively, JSON format of keyword values
    is also supported.
 
    CLI Example:
 
        salt '*' state.single pkg.installed name=vim
 
 
 
state.sls:
 
    Execute a set list of state files from an environment.
 
    test
        Notify states to execute in test-only (dry-run) mode.
 
        Sets the ``test`` variable in the minion ``opts`` for the duration of
        the state run.
    pillar
        Custom Pillar data can be passed with the ``pillar`` kwarg. Values
        passed here will override hard-coded Pillar values.
    queue : ``False``
        Instead of failing immediately when another state run is in progress,
        queue the new state run to begin running once the other has finished.
 
        This option starts a new thread for each queued state run so use this
        option sparingly.
    saltenv : None
        Specify a ``file_roots`` environment.
 
        Changed in version 0.17.0
            Argument name changed from ``env`` to ``saltenv``.
        Changed in version 2014.7
            Defaults to None. If no saltenv is specified, the minion config will
            be checked for a saltenv and if found, it will be used. If none is found,
            base will be used.
    pillarenv : None
        Specify a ``pillar_roots`` environment. By default all pillar environments
        merged together will be used.
    concurrent:
        WARNING: This flag is potentially dangerous. It is designed
        for use when multiple state runs can safely be run at the same
        Do not use this flag for performance optimization.
    localconfig:
        Instead of using running minion opts, load ``localconfig`` and merge that
        with the running minion opts. This functionality is intended for using
        "roots" of salt directories (with their own minion config, pillars,
        file_roots) to run highstate out of.
 
    mock:
        The mock option allows for the state run to execute without actually
        calling any states. This then returns a mocked return which will show
        the requisite ordering as well as fully validate the state run.
 
        New in version 2015.8.4
 
    CLI Example:
 
        salt '*' state.sls core,edit.vim dev
        salt '*' state.sls core exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
 
        salt '*' state.sls myslsfile pillar="{foo: 'Foo!', bar: 'Bar!'}"
 
 
state.sls_id:
 
    Call a single ID from the named module(s) and handle all requisites
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' state.sls_id apache http
 
 
state.template:
 
    Execute the information stored in a template file on the minion.
 
    This function does not ask a master for a SLS file to render but
    instead directly processes the file at the provided path on the minion.
 
    CLI Example:
 
        salt '*' state.template '<Path to template on the minion>'
 
 
state.template_str:
 
    Execute the information stored in a string from an sls template
 
    CLI Example:
 
        salt '*' state.template_str '<Template String>'
 
 
state.top:
 
    Execute a specific top file instead of the default. This is useful to apply
    configurations from a different environment (for example, dev or prod), without
    modifying the default top file.
 
    CLI Example:
 
        salt '*' state.top reverse_top.sls
        salt '*' state.top prod_top.sls exclude=sls_to_exclude
        salt '*' state.top dev_top.sls exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
 
 
status.all_status:
 
    Return a composite of all status data and info for this minion.
    Warning: There is a LOT here!
 
    CLI Example:
 
        salt '*' status.all_status
 
 
status.cpuinfo:
 
    Return the CPU info for this minion
 
    CLI Example:
 
        salt '*' status.cpuinfo
 
 
status.cpustats:
 
    Return the CPU stats for this minion
 
    CLI Example:
 
        salt '*' status.cpustats
 
 
status.custom:
 
    Return a custom composite of status data and info for this minion,
    based on the minion config file. An example config like might be::
 
        status.cpustats.custom: [ 'cpu', 'ctxt', 'btime', 'processes' ]
 
    Where status refers to status.py, cpustats is the function
    where we get our data, and custom is this function It is followed
    by a list of keys that we want returned.
 
    This function is meant to replace all_status(), which returns
    anything and everything, which we probably don't want.
 
    By default, nothing is returned. Warning: Depending on what you
    include, there can be a LOT here!
 
    CLI Example:
 
        salt '*' status.custom
 
 
status.diskstats:
 
    Return the disk stats for this minion
 
    CLI Example:
 
        salt '*' status.diskstats
 
 
status.diskusage:
 
    Return the disk usage for this minion
 
    Usage::
 
        salt '*' status.diskusage [paths and/or filesystem types]
 
    CLI Example:
 
        salt '*' status.diskusage         # usage for all filesystems
        salt '*' status.diskusage / /tmp  # usage for / and /tmp
        salt '*' status.diskusage ext?    # usage for ext[234] filesystems
        salt '*' status.diskusage / ext?  # usage for / and all ext filesystems
 
 
status.loadavg:
 
    Return the load averages for this minion
 
    CLI Example:
 
        salt '*' status.loadavg
 
 
status.master:
 
    New in version 2014.7.0
 
    Fire an event if the minion gets disconnected from its master. This
    function is meant to be run via a scheduled job from the minion. If
    master_ip is an FQDN/Hostname, is must be resolvable to a valid IPv4
    address.
 
    CLI Example:
 
        salt '*' status.master
 
 
status.meminfo:
 
    Return the memory info for this minion
 
    CLI Example:
 
        salt '*' status.meminfo
 
 
status.netdev:
 
    Return the network device stats for this minion
 
    CLI Example:
 
        salt '*' status.netdev
 
 
status.netstats:
 
    Return the network stats for this minion
 
    CLI Example:
 
        salt '*' status.netstats
 
 
status.nproc:
 
    Return the number of processing units available on this system
 
    CLI Example:
 
        salt '*' status.nproc
 
 
status.pid:
 
    Return the PID or an empty string if the process is running or not.
    Pass a signature to use to find the process via ps.  Note you can pass
    a Python-compatible regular expression to return all pids of
    processes matching the regexp.
 
    CLI Example:
 
        salt '*' status.pid <sig>
 
 
status.procs:
 
    Return the process data
 
    CLI Example:
 
        salt '*' status.procs
 
 
status.uptime:
 
    Return the uptime for this minion
 
    human_readable: True
        If ``True`` return the output provided by the system.  If ``False``
        return the output in seconds.
 
        New in version 2015.8.4
 
    CLI Example:
 
        salt '*' status.uptime
 
 
status.version:
 
    Return the system version for this minion
 
    CLI Example:
 
        salt '*' status.version
 
 
status.vmstats:
 
    Return the virtual memory stats for this minion
 
    CLI Example:
 
        salt '*' status.vmstats
 
 
status.w:
 
    Return a list of logged in users for this minion, using the w command
 
    CLI Example:
 
        salt '*' status.w
 
 
supervisord.add:
 
    Activates any updates in config for process/group.
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.add <name>
 
 
supervisord.custom:
 
    Run any custom supervisord command
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.custom "mstop '*gunicorn*'"
 
 
supervisord.options:
 
    New in version 2014.1.0
 
    Read the config file and return the config options for a given process
 
    name
        Name of the configured process
    conf_file
        path to supervisord config file
 
    CLI Example:
 
        salt '*' supervisord.options foo
 
 
supervisord.remove:
 
    Removes process/group from active config
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.remove <name>
 
 
supervisord.reread:
 
    Reload the daemon's configuration files
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.reread
 
 
supervisord.restart:
 
    Restart the named service.
    Process group names should not include a trailing asterisk.
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.restart <service>
        salt '*' supervisord.restart <group>:
 
 
supervisord.start:
 
    Start the named service.
    Process group names should not include a trailing asterisk.
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.start <service>
        salt '*' supervisord.start <group>:
 
 
supervisord.status:
 
    List programs and its state
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.status
 
 
supervisord.status_raw:
 
    Display the raw output of status
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.status_raw
 
 
supervisord.stop:
 
    Stop the named service.
    Process group names should not include a trailing asterisk.
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.stop <service>
        salt '*' supervisord.stop <group>:
 
 
supervisord.update:
 
    Reload config and add/remove as necessary
 
    user
        user to run supervisorctl as
    conf_file
        path to supervisord config file
    bin_env
        path to supervisorctl bin or path to virtualenv with supervisor
        installed
 
    CLI Example:
 
        salt '*' supervisord.update
 
 
sys.argspec:
 
    Return the argument specification of functions in Salt execution
    modules.
 
    CLI Example:
 
        salt '*' sys.argspec pkg.install
        salt '*' sys.argspec sys
        salt '*' sys.argspec
 
    Module names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.argspec 'pkg.*'
 
 
 
sys.doc:
 
    Return the docstrings for all modules. Optionally, specify a module or a
    function to narrow the selection.
 
    The strings are aggregated into a single document on the master for easy
    reading.
 
    Multiple modules/functions can be specified.
 
    CLI Example:
 
        salt '*' sys.doc
        salt '*' sys.doc sys
        salt '*' sys.doc sys.doc
        salt '*' sys.doc network.traceroute user.info
 
    Modules can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.doc 'sys.*'
        salt '*' sys.doc 'sys.list_*'
 
 
sys.list_functions:
 
    List the functions for all modules. Optionally, specify a module or modules
    from which to list.
 
    CLI Example:
 
        salt '*' sys.list_functions
        salt '*' sys.list_functions sys
        salt '*' sys.list_functions sys user
 
    Function names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_functions 'sys.list_*'
 
 
 
sys.list_modules:
 
    List the modules loaded on the minion
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.list_modules
 
    Module names can be specified as globs.
 
        salt '*' sys.list_modules 's*'
 
 
 
sys.list_renderers:
 
    List the renderers loaded on the minion
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.list_renderers
 
    Render names can be specified as globs.
 
        salt '*' sys.list_renderers 'yaml*'
 
 
 
sys.list_returner_functions:
 
    List the functions for all returner modules. Optionally, specify a returner
    module or modules from which to list.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_returner_functions
        salt '*' sys.list_returner_functions mysql
        salt '*' sys.list_returner_functions mysql etcd
 
    Returner names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_returner_functions 'sqlite3.get_*'
 
 
 
sys.list_returners:
 
    List the returners loaded on the minion
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_returners
 
    Returner names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_returners 's*'
 
 
 
sys.list_runner_functions:
 
    List the functions for all runner modules. Optionally, specify a runner
    module or modules from which to list.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_runner_functions
        salt '*' sys.list_runner_functions state
        salt '*' sys.list_runner_functions state virt
 
    Runner function names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_runner_functions 'state.*' 'virt.*'
 
 
 
sys.list_runners:
 
    List the runners loaded on the minion
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_runners
 
    Runner names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_runners 'm*'
 
 
 
sys.list_state_functions:
 
    List the functions for all state modules. Optionally, specify a state
    module or modules from which to list.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_state_functions
        salt '*' sys.list_state_functions file
        salt '*' sys.list_state_functions pkg user
 
    State function names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_state_functions 'file.*'
        salt '*' sys.list_state_functions 'file.s*'
 
 
 
sys.list_state_modules:
 
    List the modules loaded on the minion
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.list_state_modules
 
    State module names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.list_state_modules 'mysql_*'
 
 
 
sys.reload_modules:
 
    Tell the minion to reload the execution modules
 
    CLI Example:
 
        salt '*' sys.reload_modules
 
 
sys.renderer_doc:
 
    Return the docstrings for all renderers. Optionally, specify a renderer or a
    function to narrow the selection.
 
    The strings are aggregated into a single document on the master for easy
    reading.
 
    Multiple renderers can be specified.
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.renderer_doc
        salt '*' sys.renderer_doc cheetah
        salt '*' sys.renderer_doc jinja json
 
    Renderer names can be specified as globs.
 
        salt '*' sys.renderer_doc 'c*' 'j*'
 
 
 
sys.returner_argspec:
 
    Return the argument specification of functions in Salt returner
    modules.
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.returner_argspec xmpp
        salt '*' sys.returner_argspec xmpp smtp
        salt '*' sys.returner_argspec
 
    Returner names can be specified as globs.
 
        salt '*' sys.returner_argspec 'sqlite3.*'
 
 
 
sys.returner_doc:
 
    Return the docstrings for all returners. Optionally, specify a returner or a
    function to narrow the selection.
 
    The strings are aggregated into a single document on the master for easy
    reading.
 
    Multiple returners/functions can be specified.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.returner_doc
        salt '*' sys.returner_doc sqlite3
        salt '*' sys.returner_doc sqlite3.get_fun
        salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
 
    Returner names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.returner_doc 'sqlite3.get_*'
 
 
 
sys.runner_argspec:
 
    Return the argument specification of functions in Salt runner
    modules.
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.runner_argspec state
        salt '*' sys.runner_argspec http
        salt '*' sys.runner_argspec
 
    Runner names can be specified as globs.
 
        salt '*' sys.runner_argspec 'winrepo.*'
 
 
sys.runner_doc:
 
    Return the docstrings for all runners. Optionally, specify a runner or a
    function to narrow the selection.
 
    The strings are aggregated into a single document on the master for easy
    reading.
 
    Multiple runners/functions can be specified.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.runner_doc
        salt '*' sys.runner_doc cache
        salt '*' sys.runner_doc cache.grains
        salt '*' sys.runner_doc cache.grains mine.get
 
    Runner names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.runner_doc 'cache.clear_*'
 
 
 
sys.state_argspec:
 
    Return the argument specification of functions in Salt state
    modules.
 
    New in version 2015.5.0
 
    CLI Example:
 
        salt '*' sys.state_argspec pkg.installed
        salt '*' sys.state_argspec file
        salt '*' sys.state_argspec
 
    State names can be specified as globs.
 
        salt '*' sys.state_argspec 'pkg.*'
 
 
 
sys.state_doc:
 
    Return the docstrings for all states. Optionally, specify a state or a
    function to narrow the selection.
 
    The strings are aggregated into a single document on the master for easy
    reading.
 
    Multiple states/functions can be specified.
 
    New in version 2014.7.0
 
    CLI Example:
 
        salt '*' sys.state_doc
        salt '*' sys.state_doc service
        salt '*' sys.state_doc service.running
        salt '*' sys.state_doc service.running ipables.append
 
    State names can be specified as globs.
 
    New in version 2015.5.0
 
        salt '*' sys.state_doc 'service.*' 'iptables.*'
 
 
 
sysctl.assign:
 
    Assign a single sysctl parameter for this minion
 
    CLI Example:
 
        salt '*' sysctl.assign net.ipv4.ip_forward 1
 
 
sysctl.default_config:
 
    Linux hosts using systemd 207 or later ignore ``/etc/sysctl.conf`` and only
    load from ``/etc/sysctl.d/*.conf``. This function will do the proper checks
    and return a default config file which will be valid for the Minion. Hosts
    running systemd >= 207 will use ``/etc/sysctl.d/99-salt.conf``.
 
    CLI Example:
 
        salt -G 'kernel:Linux' sysctl.default_config
 
 
sysctl.get:
 
    Return a single sysctl parameter for this minion
 
    CLI Example:
 
        salt '*' sysctl.get net.ipv4.ip_forward
 
 
sysctl.persist:
 
    Assign and persist a simple sysctl parameter for this minion. If ``config``
    is not specified, a sensible default will be chosen using
    :mod:`sysctl.default_config <salt.modules.linux_sysctl.default_config>`.
 
    CLI Example:
 
        salt '*' sysctl.persist net.ipv4.ip_forward 1
 
 
sysctl.show:
 
    Return a list of sysctl parameters for this minion
 
    config: Pull the data from the system configuration file
        instead of the live data.
 
    CLI Example:
 
        salt '*' sysctl.show
 
 
syslog_ng.config:
 
    Builds syslog-ng configuration. This function is intended to be used from
    the state module, users should not use it directly!
 
    name : the id of the Salt document or it is the format of <statement name>.id
    config : the parsed YAML code
    write : if True, it writes  the config into the configuration file,
    otherwise just returns it
 
    CLI Example:
 
        salt '*' syslog_ng.config name="s_local" config="[{'tcp':[{'ip':'127.0.0.1'},{'port':1233}]}]"
 
 
 
syslog_ng.config_test:
 
    Runs syntax check against cfgfile. If syslog_ng_sbin_dir is specified, it
    is added to the PATH during the test.
 
    CLI Example:
 
        salt '*' syslog_ng.config_test
        salt '*' syslog_ng.config_test /home/user/install/syslog-ng/sbin
        salt '*' syslog_ng.config_test /home/user/install/syslog-ng/sbin /etc/syslog-ng/syslog-ng.conf
 
 
syslog_ng.get_config_file:
 
    Returns the configuration directory, which contains syslog-ng.conf.
 
    CLI Example:
 
        salt '*' syslog_ng.get_config_file
 
 
 
syslog_ng.modules:
 
    Returns the available modules. If syslog_ng_sbin_dir is specified, it
    is added to the PATH during the execution of the command syslog-ng.
 
    CLI Example:
 
        salt '*' syslog_ng.modules
        salt '*' syslog_ng.modules /home/user/install/syslog-ng/sbin
 
 
syslog_ng.reload:
 
    Reloads syslog-ng. This function is intended to be used from states.
 
    If :mod:`syslog_ng.set_config_file <salt.modules.syslog_ng.set_binary_path>`,
    is called before, this function will use the set binary path.
 
    CLI Example:
 
        salt '*' syslog_ng.reload
 
 
 
syslog_ng.set_binary_path:
 
    Sets the path, where the syslog-ng binary can be found. This function is
    intended to be used from states.
 
    If syslog-ng is installed via a package manager, users don't need to use
    this function.
 
    CLI Example:
 
        salt '*' syslog_ng.set_binary_path name="/usr/sbin"
 
 
 
syslog_ng.set_config_file:
 
    Sets the configuration's name. This function is intended to be used from states.
 
    CLI Example:
 
        salt '*' syslog_ng.set_config_file name="/etc/syslog-ng"
 
 
 
syslog_ng.set_parameters:
 
    Sets variables.
 
    CLI Example:
 
        salt '*' syslog_ng.set_parameters version="3.6"
        salt '*' syslog_ng.set_parameters  binary_path="/home/user/install/syslog-ng/sbin" config_file="/home/user/install/syslog-ng/etc/syslog-ng.conf"
 
 
 
syslog_ng.start:
 
    Ensures, that syslog-ng is started via the given parameters. This function
    is intended to be used from the state module.
 
    Users shouldn't use this function, if the service module is available on
    their system.  If :mod:`syslog_ng.set_config_file <salt.modules.syslog_ng.set_binary_path>`,
    is called before, this function will use the set binary path.
 
    CLI Example:
 
        salt '*' syslog_ng.start
 
 
 
syslog_ng.stats:
 
    Returns statistics from the running syslog-ng instance. If syslog_ng_sbin_dir is specified, it
    is added to the PATH during the execution of the command syslog-ng-ctl.
 
    CLI Example:
 
        salt '*' syslog_ng.stats
        salt '*' syslog_ng.stats /home/user/install/syslog-ng/sbin
 
 
syslog_ng.stop:
 
    Kills syslog-ng. This function is intended to be used from the state module.
 
    Users shouldn't use this function, if the service module is available on
    their system.  If :mod:`syslog_ng.set_config_file <salt.modules.syslog_ng.set_binary_path>`
    is called before, this function will use the set binary path.
 
    CLI Example:
 
        salt '*' syslog_ng.stop
 
 
 
syslog_ng.version:
 
    Returns the version of the installed syslog-ng. If syslog_ng_sbin_dir is specified, it
    is added to the PATH during the execution of the command syslog-ng.
 
    CLI Example:
 
        salt '*' syslog_ng.version
        salt '*' syslog_ng.version /home/user/install/syslog-ng/sbin
 
 
syslog_ng.write_config:
 
    Writes the given parameter config into the config file. This function is
    intended to be used from states.
 
    If :mod:`syslog_ng.set_config_file <salt.modules.syslog_ng.set_config_file>`,
    is called before, this function will use the set config file.
 
    CLI Example:
 
        salt '*' syslog_ng.write_config config="# comment"
 
 
 
syslog_ng.write_version:
 
    Removes the previous configuration file, then creates a new one and writes the name line.
    This function is intended to be used from states.
 
    If :mod:`syslog_ng.set_config_file <salt.modules.syslog_ng.set_config_file>`,
    is called before, this function will use the set config file.
 
    CLI Example:
 
        salt '*' syslog_ng.write_version name="3.6"
 
 
 
system.halt:
 
    Halt a running system
 
    CLI Example:
 
        salt '*' system.halt
 
 
system.init:
 
    Change the system runlevel on sysV compatible systems
 
    CLI Example:
 
        salt '*' system.init 3
 
 
system.poweroff:
 
    Poweroff a running system
 
    CLI Example:
 
        salt '*' system.poweroff
 
 
system.reboot:
 
    Reboot the system
 
    at_time
        The wait time in minutes before the system will be shutdown.
 
    CLI Example:
 
        salt '*' system.reboot
 
 
system.shutdown:
 
    Shutdown a running system
 
    at_time
        The wait time in minutes before the system will be shutdown.
 
    CLI Example:
 
        salt '*' system.shutdown 5
 
 
temp.dir:
 
    Create a temporary directory
 
    CLI Example:
 
        salt '*' temp.dir
        salt '*' temp.dir prefix='mytemp-' parent='/var/run/'
 
 
temp.file:
 
    Create a temporary file
 
    CLI Example:
 
        salt '*' temp.file
        salt '*' temp.file prefix='mytemp-' parent='/var/run/'
 
 
test.arg:
 
    Print out the data passed into the function ``*args`` and ```kwargs``, this
    is used to both test the publication data and cli argument passing, but
    also to display the information available within the publication data.
    Returns {"args": args, "kwargs": kwargs}.
 
    CLI Example:
 
        salt '*' test.arg 1 "two" 3.1 txt="hello" wow='{a: 1, b: "hello"}'
 
 
test.arg_repr:
 
    Print out the data passed into the function ``*args`` and ```kwargs``, this
    is used to both test the publication data and cli argument passing, but
    also to display the information available within the publication data.
    Returns {"args": repr(args), "kwargs": repr(kwargs)}.
 
    CLI Example:
 
        salt '*' test.arg_repr 1 "two" 3.1 txt="hello" wow='{a: 1, b: "hello"}'
 
 
test.arg_type:
 
    Print out the types of the args and kwargs. This is used to test the types
    of the args and kwargs passed down to the minion
 
    CLI Example:
 
           salt '*' test.arg_type 1 'int'
 
 
test.assertion:
 
    Assert the given argument
 
    CLI Example:
 
        salt '*' test.assert False
 
 
test.attr_call:
 
    Call grains.items via the attribute
 
    CLI Example::
 
        salt '*' test.attr_call
 
 
test.collatz:
 
    Execute the collatz conjecture from the passed starting number,
    returns the sequence and the time it took to compute. Used for
    performance tests.
 
    CLI Example:
 
        salt '*' test.collatz 3
 
 
test.conf_test:
 
    Return the value for test.foo in the minion configuration file, or return
    the default value
 
    CLI Example:
 
        salt '*' test.conf_test
 
 
test.cross_test:
 
    Execute a minion function via the __salt__ object in the test
    module, used to verify that the minion functions can be called
    via the __salt__ module.
 
    CLI Example:
 
        salt '*' test.cross_test file.gid_to_group 0
 
 
test.echo:
 
    Return a string - used for testing the connection
 
    CLI Example:
 
        salt '*' test.echo 'foo bar baz quo qux'
 
 
test.exception:
 
    Raise an exception
 
    Optionally provide an error message or output the full stack.
 
    CLI Example:
 
        salt '*' test.exception 'Oh noes!'
 
 
test.false:
 
    Always return False
 
    CLI Example:
 
        salt '*' test.false
 
 
test.fib:
 
    Return the num-th Fibonacci number, and the time it took to compute in
    seconds. Used for performance tests.
 
    This function is designed to have terrible performance.
 
    CLI Example:
 
        salt '*' test.fib 3
 
 
test.get_opts:
 
    Return the configuration options passed to this minion
 
    CLI Example:
 
        salt '*' test.get_opts
 
 
test.kwarg:
 
    Print out the data passed into the function ``**kwargs``, this is used to
    both test the publication data and cli kwarg passing, but also to display
    the information available within the publication data.
 
    CLI Example:
 
        salt '*' test.kwarg num=1 txt="two" env='{a: 1, b: "hello"}'
 
 
test.module_report:
 
    Return a dict containing all of the exeution modules with a report on
    the overall availability via different references
 
    CLI Example::
 
        salt '*' test.module_report
 
 
test.not_loaded:
 
    List the modules that were not loaded by the salt loader system
 
    CLI Example:
 
        salt '*' test.not_loaded
 
 
test.opts_pkg:
 
    Return an opts package with the grains and opts for this minion.
    This is primarily used to create the options used for master side
    state compiling routines
 
    CLI Example:
 
        salt '*' test.opts_pkg
 
 
test.outputter:
 
    Test the outputter, pass in data to return
 
    CLI Example:
 
        salt '*' test.outputter foobar
 
 
test.ping:
 
    Used to make sure the minion is up and responding. Not an ICMP ping.
 
    Returns ``True``.
 
    CLI Example:
 
        salt '*' test.ping
 
 
test.provider:
 
    Pass in a function name to discover what provider is being used
 
    CLI Example:
 
        salt '*' test.provider service
 
 
test.providers:
 
    Return a dict of the provider names and the files that provided them
 
    CLI Example:
 
        salt '*' test.providers
 
 
test.rand_sleep:
 
    Sleep for a random number of seconds, used to test long-running commands
    and minions returning at differing intervals
 
    CLI Example:
 
        salt '*' test.rand_sleep 60
 
 
test.rand_str:
 
    Return a random string
 
        size
            size of the string to generate
        hash_type
            hash type to use
 
            New in version 2015.5.2
 
    CLI Example:
 
        salt '*' test.rand_str
 
 
test.retcode:
 
    Test that the returncode system is functioning correctly
 
    CLI Example:
 
        salt '*' test.retcode 42
 
 
test.sleep:
 
    Instruct the minion to initiate a process that will sleep for a given
    period of time.
 
    CLI Example:
 
        salt '*' test.sleep 20
 
 
test.stack:
 
    Return the current stack trace
 
    CLI Example:
 
        salt '*' test.stack
 
 
test.true:
 
    Always return True
 
    CLI Example:
 
        salt '*' test.true
 
 
test.try_:
 
    Try to run a module command. On an exception return None.
    If `return_try_exception` is set True return the exception.
    This can be helpful in templates where running a module might fail as expected.
 
    CLI Example:
 
        <pre>
        {% for i in range(0,230) %}
            {{ salt['test.try'](module='ipmi.get_users', bmc_host='172.2.2.'+i)|yaml(False) }}
        {% endfor %}
        </pre>
 
 
test.tty:
 
    Deprecated! Moved to cmdmod.
 
    CLI Example:
 
        salt '*' test.tty tty0 'This is a test'
        salt '*' test.tty pts3 'This is a test'
 
 
test.version:
 
    Return the version of salt on the minion
 
    CLI Example:
 
        salt '*' test.version
 
 
test.versions:
 
This function is an alias of ``versions_report``.
 
    Returns versions of components used by salt
 
    CLI Example:
 
        salt '*' test.versions_report
 
 
test.versions_information:
 
    Report the versions of dependent and system software
 
    CLI Example:
 
        salt '*' test.versions_information
 
 
test.versions_report:
 
    Returns versions of components used by salt
 
    CLI Example:
 
        salt '*' test.versions_report
 
 
timezone.get_hwclock:
 
    Get current hardware clock setting (UTC or localtime)
 
    CLI Example:
 
        salt '*' timezone.get_hwclock
 
 
timezone.get_offset:
 
    Get current numeric timezone offset from UCT (i.e. -0700)
 
    CLI Example:
 
        salt '*' timezone.get_offset
 
 
timezone.get_zone:
 
    Get current timezone (i.e. America/Denver)
 
    CLI Example:
 
        salt '*' timezone.get_zone
 
 
timezone.get_zonecode:
 
    Get current timezone (i.e. PST, MDT, etc)
 
    CLI Example:
 
        salt '*' timezone.get_zonecode
 
 
timezone.set_hwclock:
 
    Sets the hardware clock to be either UTC or localtime
 
    CLI Example:
 
        salt '*' timezone.set_hwclock UTC
 
 
timezone.set_zone:
 
    Unlinks, then symlinks /etc/localtime to the set timezone.
 
    The timezone is crucial to several system processes, each of which SHOULD
    be restarted (for instance, whatever you system uses as its cron and
    syslog daemons). This will not be automagically done and must be done
    manually!
 
    CLI Example:
 
        salt '*' timezone.set_zone 'America/Denver'
 
 
timezone.zone_compare:
 
    Checks the hash sum between the given timezone, and the one set in
    /etc/localtime. Returns True if they match, and False if not. Mostly useful
    for running state checks.
 
    CLI Example:
 
        salt '*' timezone.zone_compare 'America/Denver'
 
 
tuned.active:
 
    Return current active profile
 
    CLI Example:
 
        salt '*' tuned.active
 
 
tuned.list:
 
    List the profiles available
 
    CLI Example:
 
        salt '*' tuned.list
 
 
tuned.off:
 
    Turn off all profiles
 
    CLI Example:
 
        salt '*' tuned.off
 
 
tuned.profile:
 
    Activate specified profile
 
    CLI Example:
 
        salt '*' tuned.profile virtual-guest
 
 
udev.env:
 
    Return all environment variables udev has for dev
 
    CLI Example:
 
        salt '*' udev.env /dev/sda
        salt '*' udev.env /sys/class/net/eth0
 
 
udev.info:
 
    Extract all info delivered by udevadm
 
    CLI Example:
 
        salt '*' udev.info /dev/sda
        salt '*' udev.info /sys/class/net/eth0
 
 
udev.links:
 
    Return all udev-created device symlinks
 
    CLI Example:
 
        salt '*' udev.links /dev/sda
        salt '*' udev.links /sys/class/net/eth0
 
 
udev.name:
 
    Return the actual dev name(s?) according to udev for dev
 
    CLI Example:
 
        salt '*' udev.dev /dev/sda
        salt '*' udev.dev /sys/class/net/eth0
 
 
udev.path:
 
    Return the physical device path(s?) according to udev for dev
 
    CLI Example:
 
        salt '*' udev.path /dev/sda
        salt '*' udev.path /sys/class/net/eth0
 
 
uptime.check_exists:
 
    Check if a given URL is in being monitored by uptime
 
    CLI Example:
 
        salt '*' uptime.check_exists http://example.org
 
 
uptime.checks_list:
 
    List URL checked by uptime
 
    CLI Example:
 
        salt '*' uptime.checks_list
 
 
uptime.create:
Create a check on a given URL.
 
    Additional parameters can be used and are passed to API (for
    example interval, maxTime, etc). See the documentation
    https://github.com/fzaninotto/uptime for a full list of the
    parameters.
 
    CLI Example:
 
        salt '*' uptime.create http://example.org
 
 
 
uptime.delete:
 
    Delete a check on a given URL
 
    CLI Example:
 
        salt '*' uptime.delete http://example.org
 
 
user.add:
 
    Add a user to the minion
 
    CLI Example:
 
        salt '*' user.add name <uid> <gid> <groups> <home> <shell>
 
 
user.chfullname:
 
    Change the user's Full Name
 
    CLI Example:
 
        salt '*' user.chfullname foo "Foo Bar"
 
 
user.chgid:
 
    Change the default group of the user
 
    CLI Example:
 
        salt '*' user.chgid foo 4376
 
 
user.chgroups:
 
    Change the groups to which this user belongs
 
    name
        User to modify
 
    groups
        Groups to set for the user
 
    append : False
        If ``True``, append the specified group(s). Otherwise, this function
        will replace the user's groups with the specified group(s).
 
    CLI Examples:
 
        salt '*' user.chgroups foo wheel,root
        salt '*' user.chgroups foo wheel,root append=True
 
 
user.chhome:
 
    Change the home directory of the user, pass True for persist to move files
    to the new home directory if the old home directory exist.
 
    CLI Example:
 
        salt '*' user.chhome foo /home/users/foo True
 
 
user.chhomephone:
 
    Change the user's Home Phone
 
    CLI Example:
 
        salt '*' user.chhomephone foo 7735551234
 
 
user.chloginclass:
 
    Change the default login class of the user
 
    Note:
        This function only applies to OpenBSD systems.
 
    CLI Example:
 
        salt '*' user.chloginclass foo staff
 
 
user.chroomnumber:
 
    Change the user's Room Number
 
    CLI Example:
 
        salt '*' user.chroomnumber foo 123
 
 
user.chshell:
 
    Change the default shell of the user
 
    CLI Example:
 
        salt '*' user.chshell foo /bin/zsh
 
 
user.chuid:
 
    Change the uid for a named user
 
    CLI Example:
 
        salt '*' user.chuid foo 4376
 
 
user.chworkphone:
 
    Change the user's Work Phone
 
    CLI Example:
 
        salt '*' user.chworkphone foo 7735550123
 
 
user.delete:
 
    Remove a user from the minion
 
    CLI Example:
 
        salt '*' user.delete name remove=True force=True
 
 
user.get_loginclass:
 
    Get the login class of the user
 
    Note:
        This function only applies to OpenBSD systems.
 
    CLI Example:
 
        salt '*' user.get_loginclass foo
 
 
user.getent:
 
    Return the list of all info for all users
 
    CLI Example:
 
        salt '*' user.getent
 
 
user.info:
 
    Return user information
 
    CLI Example:
 
        salt '*' user.info root
 
 
user.list_groups:
 
    Return a list of groups the named user belongs to
 
    CLI Example:
 
        salt '*' user.list_groups foo
 
 
user.list_users:
 
    Return a list of all users
 
    CLI Example:
 
        salt '*' user.list_users
 
 
user.rename:
 
    Change the username for a named user
 
    CLI Example:
 
        salt '*' user.rename name new_name
 
 
vbox_guest.additions_install:
 
    Install VirtualBox Guest Additions. Uses the CD, connected by VirtualBox.
 
    To connect VirtualBox Guest Additions via VirtualBox graphical interface
    press 'Host+D' ('Host' is usually 'Right Ctrl').
 
    See https://www.virtualbox.org/manual/ch04.html#idp52733088 for more details.
 
    CLI Example:
 
        salt '*' vbox_guest.additions_install
        salt '*' vbox_guest.additions_install reboot=True
        salt '*' vbox_guest.additions_install upgrade_os=True
 
    :param reboot: reboot computer to complete installation
    :type reboot: bool
    :param upgrade_os: upgrade OS (to ensure the latests version of kernel and developer tools are installed)
    :type upgrade_os: bool
    :return: version of VirtualBox Guest Additions or string with error
 
 
vbox_guest.additions_mount:
 
    Mount VirtualBox Guest Additions CD to the temp directory.
 
    To connect VirtualBox Guest Additions via VirtualBox graphical interface
    press 'Host+D' ('Host' is usually 'Right Ctrl').
 
    CLI Example:
 
        salt '*' vbox_guest.additions_mount
 
    :return: True or OSError exception
 
 
vbox_guest.additions_remove:
 
    Remove VirtualBox Guest Additions.
 
    Firstly it tries to uninstall itself by executing
    '/opt/VBoxGuestAdditions-VERSION/uninstall.run uninstall'.
    It uses the CD, connected by VirtualBox if it failes.
 
    CLI Example:
 
        salt '*' vbox_guest.additions_remove
        salt '*' vbox_guest.additions_remove force=True
 
    :param force: force VirtualBox Guest Additions removing
    :type force: bool
    :return: True if VirtualBox Guest Additions were removed successfully else False
 
 
 
vbox_guest.additions_umount:
 
    Unmount VirtualBox Guest Additions CD from the temp directory.
 
    CLI Example:
 
        salt '*' vbox_guest.additions_umount
 
    :param mount_point: directory VirtualBox Guest Additions is mounted to
    :return: True or an string with error
 
 
vbox_guest.additions_version:
 
    Check VirtualBox Guest Additions version.
 
    CLI Example:
 
        salt '*' vbox_guest.additions_version
 
    :return: version of VirtualBox Guest Additions or False if they are not installed
 
 
vbox_guest.grant_access_to_shared_folders_to:
 
    Grant access to auto-mounted shared folders to the users.
 
    User is specified by it's name. To grant access for several users use argument `users`.
    Access will be denied to the users not listed in `users` argument.
 
    See https://www.virtualbox.org/manual/ch04.html#sf_mount_auto for more details.
 
    CLI Example:
 
        salt '*' vbox_guest.grant_access_to_shared_folders_to fred
        salt '*' vbox_guest.grant_access_to_shared_folders_to users ['fred', 'roman']
 
    :param name: name of the user to grant access to auto-mounted shared folders to
    :type name: str
    :param users: list of names of users to grant access to auto-mounted shared folders to (if specified, `name` will not be taken into account)
    :type users: list of str
    :return: list of users who have access to auto-mounted shared folders
 
 
vbox_guest.list_shared_folders_users:
 
    List users who have access to auto-mounted shared folders.
 
    See https://www.virtualbox.org/manual/ch04.html#sf_mount_auto for more details.
 
    CLI Example:
 
        salt '*' vbox_guest.list_shared_folders_users
 
    :return: list of users who have access to auto-mounted shared folders
 
 
virtualenv.create:
 
    Create a virtualenv
 
    path
        The path to create the virtualenv
    venv_bin : None (default 'virtualenv')
        The name (and optionally path) of the virtualenv command. This can also
        be set globally in the minion config file as ``virtualenv.venv_bin``.
    system_site_packages : False
        Passthrough argument given to virtualenv or pyvenv
    distribute : False
        Passthrough argument given to virtualenv
    pip : False
        Install pip after creating a virtual environment,
        implies distribute=True
    clear : False
        Passthrough argument given to virtualenv or pyvenv
    python : None (default)
        Passthrough argument given to virtualenv
    extra_search_dir : None (default)
        Passthrough argument given to virtualenv
    never_download : None (default)
        Passthrough argument given to virtualenv if True
    prompt : None (default)
        Passthrough argument given to virtualenv if not None
    symlinks : None
        Passthrough argument given to pyvenv if True
    upgrade : None
        Passthrough argument given to pyvenv if True
    user : None
        Set ownership for the virtualenv
    runas : None
        Set ownership for the virtualenv
 
    use_vt : False
        Use VT terminal emulation (see ouptut while installing)
 
        New in version 2015.5.0
 
    saltenv : 'base'
        Specify a different environment. The default environment is ``base``.
 
        New in version 2014.1.0
 
    Note:
        The ``runas`` argument is deprecated as of 2014.1.0. ``user`` should be
        used instead.
 
    CLI Example:
 
        salt '*' virtualenv.create /path/to/new/virtualenv
 
 
virtualenv.get_resource_content:
 
    Returns the content of a resource of a package or a distribution inside a virtualenv
 
    New in version 2015.5.0
 
    venv
        Path to the virtualenv.
    package_or_requirement
        Name of the package where the resource resides in.
    resource_name
        Name of the resource of which the content is to be returned.
 
 
    CLI Example:
 
        salt '*' virtualenv.get_resource_content /path/to/my/venv my_package my/resource.xml
 
 
virtualenv.get_resource_path:
 
    Returns the path to a resource of a package or a distribution inside a virtualenv
 
    New in version 2015.5.0
 
    venv
        Path to the virtualenv.
    package_or_requirement
        Name of the package where the resource resides in.
    resource_name
        Name of the resource of which the path is to be returned.
 
    CLI Example:
 
        salt '*' virtualenv.get_resource_path /path/to/my/venv my_package my/resource.xml
 
 
virtualenv.get_site_packages:
 
    Returns the path to the site-packages directory inside a virtualenv
 
    venv
        Path to the virtualenv.
 
    CLI Example:
 
        salt '*' virtualenv.get_site_packages /path/to/my/venv
 
 
xfs.defragment:
 
    Defragment mounted XFS filesystem.
    In order to mount a filesystem, device should be properly mounted and writable.
 
    CLI Example:
 
        salt '*' xfs.defragment /dev/sda1
 
 
xfs.devices:
 
    Get known XFS formatted devices on the system.
 
    CLI Example:
 
        salt '*' xfs.devices
 
 
xfs.dump:
 
    Dump filesystem device to the media (file, tape etc).
 
    Required parameters:
 
    * **device**: XFS device, content of which to be dumped.
    * **destination**: Specifies a dump destination.
 
    Valid options are:
 
    * **label**: Label of the dump. Otherwise automatically generated label is used.
    * **level**: Specifies a dump level of 0 to 9.
    * **noerase**: Pre-erase media.
 
    Other options are not used in order to let ``xfsdump`` use its default
    values, as they are most optimal. See the ``xfsdump(8)`` manpage for
    a more complete description of these options.
 
    CLI Example:
 
        salt '*' xfs.dump /dev/sda1 /detination/on/the/client
        salt '*' xfs.dump /dev/sda1 /detination/on/the/client label='Company accountancy'
        salt '*' xfs.dump /dev/sda1 /detination/on/the/client noerase=True
 
 
xfs.estimate:
 
    Estimate the space that an XFS filesystem will take.
    For each directory estimate the space that directory would take
    if it were copied to an XFS filesystem.
    Estimation does not cross mount points.
 
    CLI Example:
 
        salt '*' xfs.estimate /path/to/file
        salt '*' xfs.estimate /path/to/dir/*
 
 
xfs.info:
 
    Get filesystem geometry information.
 
    CLI Example:
 
        salt '*' xfs.info /dev/sda1
 
 
xfs.inventory:
 
    Display XFS dump inventory without restoration.
 
    CLI Example:
 
        salt '*' xfs.inventory
 
 
xfs.mkfs:
 
    Create a file system on the specified device. By default wipes out with force.
 
    General options:
 
    * **label**: Specify volume label.
    * **ssize**: Specify the fundamental sector size of the filesystem.
    * **noforce**: Do not force create filesystem, if disk is already formatted.
 
    Filesystem geometry options:
 
    * **bso**: Block size options.
    * **gmo**: Global metadata options.
    * **dso**: Data section options. These options specify the location, size,
               and other parameters of the data section of the filesystem.
    * **ino**: Inode options to specify the inode size of the filesystem, and other inode allocation parameters.
    * **lso**: Log section options.
    * **nmo**: Naming options.
    * **rso**: Realtime section options.
 
    See the ``mkfs.xfs(8)`` manpage for a more complete description of corresponding options description.
 
    CLI Example:
 
        salt '*' xfs.mkfs /dev/sda1
        salt '*' xfs.mkfs /dev/sda1 dso='su=32k,sw=6' noforce=True
        salt '*' xfs.mkfs /dev/sda1 dso='su=32k,sw=6' lso='logdev=/dev/sda2,size=10000b'
 
 
xfs.modify:
 
    Modify parameters of an XFS filesystem.
 
    CLI Example:
 
        salt '*' xfs.modify /dev/sda1 label='My backup' lazy_counting=False
        salt '*' xfs.modify /dev/sda1 uuid=False
        salt '*' xfs.modify /dev/sda1 uuid=True
 
 
xfs.prune_dump:
 
    Prunes the dump session identified by the given session id.
 
    CLI Example:
 
        salt '*' xfs.prune_dump b74a3586-e52e-4a4a-8775-c3334fa8ea2c
 
    
salt.txt · Последние изменения: 2016/03/13 05:20 — sander