Glossary ======== .. glossary:: Auto-Order The evaluation of states in the order that they are defined in a SLS file. *See also*: :ref:`ordering `. Bootstrap A stand-alone Salt project which can download and install a Salt master and/or a Salt minion onto a host. *See also*: `salt-bootstrap `_. Compound Matcher A combination of many target definitions that can be combined with boolean operators. *See also*: :ref:`targeting `. EAuth Shorthand for 'external authentication'. A system for calling to a system outside of Salt in order to authenticate users and determine if they are allowed to issue particular commands to Salt. *See also*: :ref:`external auth`. Environment A directory tree containing state files which can be applied to minions. *See also*: :ref:`top file`. Execution Module A Python module that contains execution functions which directly perform various system-management tasks on a server. Salt ships with a number of execution modules but users can also write their own execution modules to perform specialized tasks. *See also*: :ref:`the list of execution modules `. Execution Function A Python function inside an Execution Module that may take arguments and performs specific system-management tasks. *See also*: :ref:`the list of execution modules `. External Job Cache An external data-store that can archive information about jobs that have been run. A default returner. *See also*: :conf_master:`ext_job_cache`, :ref:`the list of returners `. External Pillar A module that accepts arbitrary arguments and returns a dictionary. The dictionary is automatically added to a pillar for a minion. Event A notice emitted onto an event bus. Events are often driven by requests for actions to occur on a minion or master and the results of those actions. *See also*: :ref:`Salt Reactor `. File Server A local or remote location for storing both Salt-specific files such as top files or SLS files as well as files that can be distributed to minions, such as system configuration files. *See also*: :ref:`Salt's file server `. Grain A key-value pair which contains a fact about a system, such as its hostname, network addresses. *See also*: :ref:`targeting with grains `. Halite The Salt GUI. *See also*: `Halite `_. Jinja A templating language which allows variables and simple logic to be dynamically inserted into static text files when they are rendered. *See also*: :py:mod:`Salt's Jinja documentation `. Job The complete set of tasks to be performed by the execution of a Salt command are a single job. *See also*: :py:mod:`jobs runner `. Job Cache A storage location for job results, which may then be queried by a salt runner or an external system. May be local to a salt master or stored externally. Job ID A unique identifier to represent a given :term:`job`. Highdata The data structure in a SLS file the represents a set of state declarations. *See also*: :ref:`state layers `. Highstate The collection of states to be applied to a system. *See also*: :ref:`state layers `. Low State The collection of processed states after requisites and order are evaluated. *See also*: :ref:`state layers `. Master A central Salt daemon which from which commands can be issued to listening minions. Masterless A minion which does not require a Salt master to operate. All configuration is local. *See also*: :conf_minion:`file_client`. Master Tops A system for the master that allows hooks into external systems to generate top file data. Mine A facility to collect arbitrary data from minions and store that data on the master. This data is then available to all other minions. [Sometimes referred to as Salt Mine.] *See also*: :ref:`Salt Mine `. Minion A server running a Salt minion daemon which can listen to commands from a master and perform the requested tasks. Generally, minions are servers which are to be controlled using Salt. Minion ID A globally unique identifier for a minion. *See also*: :conf_minion:`id`. Multi-Master The ability for a minion to be actively connected to multiple Salt masters at the same time in high-availability environments. Node Group A pre-defined group of minions declared in the master configuration file. *See also*: :ref:`targeting `. Outputter A formatter for defining the characteristics of output data from a Salt command. *See also*: :ref:`list of outputters `. Overstate A system by which a Master can issue function calls to minions in a deterministic order. *See also*: :ref:`overstate `. Peer Communication The ability for minions to communicate directly with other minions instead of brokering commands through the Salt master. *See also*: :ref:`peer communication `. Pillar A simple key-value store for user-defined data to be made available to a minion. Often used to store and distribute sensitive data to minions. *See also*: :ref:`Pillar `, :ref:`list of Pillar modules `. Proxy Minion A minion which can control devices that are unable to run a Salt minion locally, such as routers and switches. PyDSL A Pythonic domain-specific-language used as a Salt renderer. PyDSL can be used in cases where adding pure Python into SLS files is beneficial. *See also*: :py:mod:`PyDSL `. Reactor An interface for listening to events and defining actions that Salt should taken upon receipt of given events. *See also*: :ref:`Reactor `. Render Pipe Allows SLS files to be rendered by multiple renderers, with each renderer receiving the output of the previous. *See also*: :ref:`composing renderers `. Renderer Responsible for translating a given data serialization format such as YAML or JSON into a Python data structure that can be consumed by Salt. *See also*: :ref:`list of renderers `. Returner Allows for the results of a Salt command to be sent to a given data-store such as a database or log file for archival. *See also*: :ref:`list of returners `. Roster A flat-file list of target hosts. (Currently only used by salt-ssh.) Runner Module A module containing a set of runner functions. *See also*: :ref:`list of runner modules `. Runner Function A function which is is called by the :command:`salt-run` command and executes on the master instead of on a minion. *See also*: :term:`Runner Module`. Salt Cloud A suite of tools used to create and deploy systems on many hosted cloud providers. *See also*: :ref:`salt-cloud `. Salt SSH A configuration management and remote orchestration system that does not require that any software besides SSH be installed on systems to be controlled. Salt Thin A subset of the normal Salt distribution that does not include any transport routines. A Salt Thin bundle can be dropped onto a host and used directly without any requirement that the host be connected to a network. Used by Salt SSH. *See also*: :py:mod:`thin runner `. Salt Virt Used to manage the creation and deployment of virtual machines onto a set of host machines. Often used to create and deploy private clouds. *See also*: :py:mod:`virt runner `. SLS Module Contains a set of :term:`state declarations `. State Declaration A data structure which contains a unique ID and describes one or more states of a system such as ensuring that a package is installed or a user is defined. *See also*: :ref:`highstate structure `. State Module A module which contains a set of state functions. *See also*: :ref:`list of state modules `. State Function A function contained inside a :term:`state module ` which can manages the application of a particular state to a system. State functions frequently call out to one or more :term:`execution modules ` to perform a given task. State Run The application of a set of states on a set of systems. State Compiler Translates :term:`highdata` into lowdata. Syndic A forwarder which can relay messages between tiered masters. **See also**: :ref:`Syndic `. Target Minion(s) to which a given salt command will apply. *See also*: :ref:`targeting `. Top File Determines which SLS files should be applied to various systems and organizes those groups of systems into environments. *See also*: :ref:`top file `, :ref:`list of master top modules `. Worker A master process which can send notices and receive replies from minions. *See also*: :conf_master:`worker_threads`. __virtual__ A function in a module that is called on module load to determine whether or not the module should be available to a minion. This function commonly contains logic to determine if all requirements for a module are available, such as external libraries.