neulab/tldr huggingface dataset:
The 0.17.0 release is a very exciting release of Salt, this brings to Salt some very powerful new features and advances. The advances range from the state system to the test suite, covering new transport capabilities and making states easier and more powerful, to extending Salt Virt and much more!
The 0.17.0 release will also be the last release of Salt to follow the old 0.XX.X numbering system, the next release of Salt will change the numbering to be date based following this format:
<Year>.<Month>.<Minor>
So if the release happens in November of 2013 the number will be 13.11.0, the first bugfix release will be 13.11.1 and so forth.
Major Features Halite The new Halite web GUI is now available on PyPI. A great deal of work has been put into Halite to make it fully event driven and amazingly fast. The Halite UI can be started from within the Salt Master (after being installed from PyPI), or standalone, and does not require an external database to run.  It is very lightweight!
This initial release of Halite is primarily the framework for the UI and the communication systems, making it easy to extend and build the UI up. It presently supports watching the event bus and firing commands over Salt.
At this time, Halite is not available as a package, but installation documentation is available at: https://docs.saltproject.io/topics/tutorials/halite.html
Halite is, like the rest of Salt, Open Source!
Much more will be coming in the future of Halite!
Salt SSH The new salt-ssh command has been added to Salt. This system allows for remote execution and states to be run over ssh. The benefit here being, that salt can run relying only on the ssh agent, rather than requiring a minion to be deployed.
The salt-ssh system runs states in a compatible way as Salt and states created and run with salt-ssh can be moved over to a standard salt deployment without modification.
Since this is the initial release of salt-ssh, there is plenty of room for improvement, but it is fully operational, not just a bootstrap tool.
Rosters Salt is designed to have the minions be aware of the master and the master does not need to be aware of the location of the minions. The new salt roster system was created and designed to facilitate listing the targets for salt-ssh.
The roster system, like most of Salt, is a plugin system, allowing for the list of systems to target to be derived from any pluggable backend. The rosters shipping with 0.17.0 are flat and scan. Flat is a file which is read in via the salt render system and the scan roster does simple network scanning to discover ssh servers.
State Auto Order This is a major change in how states are evaluated in Salt. State Auto Order is a new feature that makes states get evaluated and executed in the order in which they are defined in the sls file. This feature makes it very easy to see the finite order in which things will be executed, making Salt now, fully imperative AND fully declarative.
The requisite system still takes precedence over the order in which states are defined, so no existing states should break with this change. But this new feature can be turned off by setting state_auto_order: False in the master config, thus reverting to the old lexicographical order.
state.sls Runner The state.sls runner has been created to allow for a more powerful system for orchestrating state runs and function calls across the salt minions. This new system uses the state system for organizing executions.
This allows for states to be defined that are executed on the master to call states on minions via salt-run state.sls.
Salt Thin Salt Thin is an exciting new component of Salt, this is the ability to execute Salt routines without any transport mechanisms installed, it is a pure python subset of Salt.
Salt Thin does not have any networking capability, but can be dropped into any system with Python installed and then salt-call can be called directly. The Salt Thin system, is used by the salt-ssh command, but can still be used to just drop salt somewhere for easy use.
Event Namespacing Events have been updated to be much more flexible. The tags in events have all been namespaced allowing easier tracking of event names.
Mercurial Fileserver Backend The popular git fileserver backend has been joined by the mercurial fileserver backend, allowing the state tree to be managed entirely via mercurial.
External Logging Handlers The external logging handler system allows for Salt to directly hook into any external logging system. Currently supported are sentry and logstash.
Jenkins Testing The testing systems in Salt have been greatly enhanced, tests for salt are now executed, via jenkins.saltstack.com, across many supported platforms. Jenkins calls out to salt-cloud to create virtual machines on Rackspace, then the minion on the virtual machine checks into the master running on Jenkins where a state run is executed that sets up the minion to run tests and executes the test suite.
This now automates the sequence of running platform tests and allows for continuous destructive tests to be run.
Salt Testing Project The testing libraries for salt have been moved out of the main salt code base and into a standalone codebase. This has been done to ease the use of the testing systems being used in salt based projects other than Salt itself.
StormPath External Authentication The external auth system now supports the fantastic Stormpath cloud based authentication system.
LXC Support Extensive additions have been added to Salt for LXC support. This included the backend libs for managing LXC containers. Addition into the salt-virt system is still in the works.
macOS User/Group Support Salt is now able to manage users and groups on Minions running macOS. However, at this time user passwords cannot be managed.
Django ORM External Pillar Pillar data can now be derived from Django managed databases.
Fixes from RC to release • Multiple documentation fixes
• Add multiple source files + templating for file.append (issue #6905)
• Support sysctl configuration files in systemd>=207 (issue #7351)
• Add file.search and file.replace
• Fix cross-calling execution functions in provider overrides
• Fix locale override for postgres (issue #4543)
• Fix Raspbian identification for service/pkg support (issue #7371)
• Fix cp.push file corruption (issue #6495)
• Fix ALT Linux password hash specification (issue #3474)
• Multiple salt-ssh-related fixes and improvements
Salt 0.17.1 Release Notes release 2013-10-17
NOTE: THIS RELEASE IS NOT COMPATIBLE WITH PREVIOUS VERSIONS.  If you update your master to 0.17.1, you must update your minions as well.  Sorry for the inconvenience -- this is a result of one of the security fixes listed below.
The 0.17.1 release comes with a number of improvements to salt-ssh, many bugfixes, and a number of security updates.
Salt SSH has been improved to be faster, more featureful and more secure. Since the original release of Salt SSH was primarily a proof of concept, it has been very exciting to see its rapid adoption. We appreciate the willingness of security experts to review Salt SSH and help discover oversights and ensure that security issues only exist for such a tiny window of time.
SSH Enhancements Shell Improvements Improvements to Salt SSH's communication have been added that improve routine execution regardless of the target system's login shell.
Performance Deployment of routines is now faster and takes fewer commands to execute.
Security Updates Be advised that these security issues all apply to a small subset of Salt users and mostly apply to Salt SSH.
Insufficient Argument Validation This issue allowed for a user with limited privileges to embed executions inside of routines to execute routines that should be restricted. This applies to users using external auth or client ACL and opening up specific routines.
Be advised that these patches address the direct issue. Additional commits have been applied to help mitigate this issue from resurfacing.
CVE CVE-2013-4435
Affected Versions 0.15.0 - 0.17.0
Patches https://github.com/saltstack/salt/commit/6d8ef68b605fd63c36bb8ed96122a75ad2e80269 https://github.com/saltstack/salt/commit/ebdef37b7e5d2b95a01d34b211c61c61da67e46a https://github.com/saltstack/salt/commit/7f190ff890e47cdd591d9d7cefa5126574660824 https://github.com/saltstack/salt/commit/8e5afe59cef6743fe5dbd510dcf463dbdfca1ced https://github.com/saltstack/salt/commit/aca78f314481082862e96d4f0c1b75fa382bb885 https://github.com/saltstack/salt/commit/6a9752cdb1e8df2c9505ea910434c79d132eb1e2 https://github.com/saltstack/salt/commit/b73677435ba54ecfc93c1c2d840a7f9ba6f53410 https://github.com/saltstack/salt/commit/07972eb0a6f985749a55d8d4a2e471596591c80d https://github.com/saltstack/salt/commit/1e3f197726aa13ac5c3f2416000089f477f489b5
Found By Feth Arezki, of Majerti
MITM SSH attack in salt-ssh SSH host keys were being accepted by default and not enforced on future SSH connections. These patches set SSH host key checking by default and can be overridden by passing the -i flag to salt-ssh.
CVE CVE-2013-4436
Affected Versions 0.17.0
Found By Michael Scherer, Red Hat
Insecure Usage of /tmp in salt-ssh The initial release of salt-ssh used the /tmp directory in an insecure way.  These patches not only secure usage of files under /tmp in salt-ssh, but also add checksum validation for all packages sent into the now secure locations on target systems.
CVE CVE-2013-4438
Patches https://github.com/saltstack/salt/commit/aa4bb77ef230758cad84381dde0ec660d2dc340a https://github.com/saltstack/salt/commit/8f92b6b2cb2e4ec3af8783eb6bf4ff06f5a352cf https://github.com/saltstack/salt/commit/c58e56811d5a50c908df0597a0ba0b643b45ebfd https://github.com/saltstack/salt/commit/0359db9b46e47614cff35a66ea6a6a76846885d2 https://github.com/saltstack/salt/commit/4348392860e0fd43701c331ac3e681cf1a8c17b0 https://github.com/saltstack/salt/commit/664d1a1cac05602fad2693f6f97092d98a72bf61 https://github.com/saltstack/salt/commit/bab92775a576e28ff9db262f32db9cf2375bba87 https://github.com/saltstack/salt/commit/c6d34f1acf64900a3c87a2d37618ff414e5a704e
YAML Calling Unsafe Loading Routine It has been argued that this is not a valid security issue, as the YAML loading that was happening was only being called after an initial gateway filter in Salt has already safely loaded the YAML and would fail if non-safe routines were embedded. Nonetheless, the CVE was filed and patches applied.
Patches https://github.com/saltstack/salt/commit/339b0a51befae6b6b218ebcb55daa9cd3329a1c5
Failure to Drop Supplementary Group on Salt Master If a salt master was started as a non-root user by the root user, root's groups would still be applied to the running process. This fix changes the process to have only the groups of the running user.
CVE CVE not considered necessary by submitter.
Affected Versions 0.11.0 - 0.17.0
Patches https://github.com/saltstack/salt/commit/b89fa9135822d029795ab1eecd68cce2d1ced715
Failure to Validate Minions Posting Data This issue allowed a minion to pose as another authorized minion when posting data such as the mine data. All minions now pass through the id challenge before posting such data.
CVE CVE-2013-4439
Patches https://github.com/saltstack/salt/commit/7b850ff3d07ef6782888914ac4556c01e8a1c482 https://github.com/saltstack/salt/commit/151759b2a1e1c6ce29277aa81b054219147f80fd
Found By David Anderson
Fix Reference Version 0.17.1 is the first bugfix release for 0.17.0.  The changes include:
• Fix symbolic links in thin.tgz (issue #7482)
• Pass env through to file.patch state (issue #7452)
• Service provider fixes and reporting improvements (issue #7361)
• Add --priv option for specifying salt-ssh private key
• Fix salt-thin's salt-call on setuptools installations (issue #7516)
• Fix salt-ssh to support passwords with spaces (issue #7480)
• Fix regression in wildcard includes (issue #7455)
• Fix salt-call outputter regression (issue #7456)
• Fix custom returner support for startup states (issue #7540)
• Fix value handling in augeas (issue #7605)
• Fix regression in apt (issue #7624)
• Fix minion ID guessing to use socket.getfqdn() first (issue #7558)
• Add minion ID caching (issue #7558)
• Fix salt-key race condition (issue #7304)
• Add --include-all flag to salt-key (issue #7399)
• Fix custom grains in pillar (part of issue #5716, issue #6083)
• Fix race condition in salt-key (issue #7304)
• Fix regression in minion ID guessing, prioritize socket.getfqdn() (‐ issue #7558)
• Cache minion ID on first guess (issue #7558)
• Allow trailing slash in file.directory state
• Fix reporting of file_roots in pillar return (issue #5449 and issue #5951)
• Remove pillar matching for mine.get (issue #7197)
• Sanitize args for multiple execution modules
• Fix yumpkg mod_repo functions to filter hidden args (issue #7656)
• Fix conflicting IDs in state includes (issue #7526)
• Fix mysql_grants.absent string formatting issue (issue #7827)
• Fix postgres.version so it won't return None (issue #7695)
• Fix for trailing slashes in mount.mounted state
• Fix rogue AttributErrors in the outputter system (issue #7845)
• Fix for incorrect ssh key encodings resulting in incorrect key added (‐ issue #7718)
• Fix for pillar/grains naming regression in python renderer (issue #7693)
• Fix args/kwargs handling in the scheduler (issue #7422)
• Fix logfile handling for file://, tcp://, and udp:// (issue #7754)
• Fix error handling in config file parsing (issue #6714)
• Fix RVM using sudo when running as non-root user (issue #2193)
• Fix client ACL and underlying logging bugs (issue #7706)
• Fix scheduler bug with returner (issue #7367)
• Fix user management bug related to default groups (issue #7690)
• Fix various salt-ssh bugs (issue #7528)
• Many various documentation fixes
Salt 0.17.2 Release Notes release 2013-11-14
Version 0.17.2 is another bugfix release for 0.17.0.  The changes include:
• Add ability to delete key with grains.delval (issue #7872)
• Fix possible state compiler stack trace (issue #5767)
• Fix architecture regression in yumpkg (issue #7813)
• Use correct ps on Debian to prevent truncating (issue #5646)
• Fix grains targeting for new grains (issue #5737)
• Fix bug with merging in git_pillar (issue #6992)
• Fix print_jobs duplicate results
• Fix apt version specification for pkg.install
• Fix possible KeyError from ext_job_cache missing option
• Fix auto_order for - names states (issue #7649)
• Fix regression in new gitfs installs (directory not found error)
• Fix escape pipe issue on Windows for file.recurse (issue #7967)
• Fix fileclient in case of master restart (issue #7987)
• Try to output warning if CLI command malformed (issue #6538)
• Fix --out=quiet to actually be quiet (issue #8000)
• Fix for state.sls in salt-ssh (issue #7991)
• Fix for MySQL grants ordering issue (issue #5817)
• Fix traceback for certain missing CLI args (issue #8016)
• Add ability to disable lspci queries on master (issue #4906)
• Fail if sls defined in topfile does not exist (issue #5998)
• Add ability to downgrade MySQL grants (issue #6606)
• Fix ssh_auth.absent traceback (issue #8043)
• Add upstart detection for Debian/Raspbian (issue #8039)
• Fix ID-related issues (issue #8052, issue #8050, and others)
• Fix for jinja rendering issues (issue #8066 and issue #8079)
• Fix argument parsing in salt-ssh (issue #7928)
• Fix some GPU detection instances (issue #6945)
• Fix bug preventing includes from other environments in SLS files
• Fix for kwargs with dashes (issue #8102)
• Fix salt.utils.which for windows '.exe' (issue #7904)
• Fix apache.adduser without apachectl (issue #8123)
• Fix issue with evaluating test kwarg in states (issue #7788)
• Fix regression in salt.client.Caller() (issue #8078)
• Fix apt-key silent failure
• Fix bug where cmd.script would try to run even if caching failed (issue #7601)
• Fix apt pkg.latest regression (issue #8067)
• Fix for mine data not being updated (issue #8144)
• Fix for noarch packages in yum
• Fix a Xen detection edge case (issue #7839)
• Fix windows __opts__ dictionary persistence (issue #7714)
• Fix version generation for when it's part of another git repo (issue #8090)
• Fix _handle_iorder stacktrace so that the real syntax error is shown (‐ issue #8114 and issue #7905)
• Fix git.latest state when a commit SHA is used (issue #8163)
• Fix various small bugs in yumpkg.py (issue #8201)
• Fix for specifying identify file in git.latest (issue #8094)
• Fix for --output-file CLI arg (issue #8205)
• Add ability to specify shutdown time for system.shutdown (issue #7833)
• Fix for salt version using non-salt git repo info (issue #8266)
• Add additional hints at impact of pkgrepo states when test=True (issue #8247)
• Fix for salt-ssh files not being owned by root (issue #8216)
• Fix retry logic and error handling in fileserver (related to issue #7755)
• Fix file.replace with test=True (issue #8279)
• Add flag for limiting file traversal in fileserver (issue #6928)
• Fix for extra mine processes (issue #5729)
• Fix for unloading custom modules (issue #7691)
• Fix for salt-ssh opts (issue #8005 and issue #8271)
• Fix compound matcher for grains (issue #7944)
• Improve error reporting in ebuild module (related to issue #5393)
• Add dir_mode to file.managed (issue #7860)
• Improve traceroute support for FreeBSD and macOS (issue #4927)
• Fix for matching minions under syndics (issue #7671)
• Improve exception handling for missing ID (issue #8259)
• Fix grain mismatch for ScientificLinux (issue #8338)
• Add configuration option for minion_id_caching
• Fix open mode auth errors (issue #8402)
Salt 0.17.3 Release Notes release 2013-12-08
NOTE: 0.17.3 had some regressions which were promptly fixed in the 0.17.4 release.  Please use 0.17.4 instead.
Version 0.17.3 is another bugfix release for 0.17.0.  The changes include:
• Fix some jinja render errors (issue #8418)
• Fix file.replace state changing file ownership (issue #8399)
• Fix state ordering with the PyDSL renderer (issue #8446)
• Fix for new npm version (issue #8517)
• Fix for pip state requiring name even with requirements file (issue #8519)
• Fix yum logging to open terminals (issue #3855)
• Add sane maxrunning defaults for scheduler (issue #8563)
• Fix states duplicate key detection (issue #8053)
• Fix SUSE patch level reporting (issue #8428)
• Fix managed file creation umask (issue #8590)
• Fix logstash exception (issue #8635)
• Improve argument exception handling for salt command (issue #8016)
• Fix pecl success reporting (issue #8750)
• Fix launchctl module exceptions (issue #8759)
• Fix argument order in pw_user module
• Add warnings for failing grains (issue #8690)
• Fix hgfs problems caused by connections left open (issue #8811 and issue #8810)
• Add Debian iptables default for iptables-persistent package (issue #8889)
• Fix installation of packages with dots in pkg name (issue #8614)
• Fix noarch package installation on CentOS 6 (issue #8945)
• Fix portage_config.enforce_nice_config (issue #8252)
• Fix salt.util.copyfile umask usage (issue #8590)
• Fix rescheduling of failed jobs (issue #8941)
• Fix pkg on Amazon Linux (uses yumpkg5 now) (issue #8226)
• Fix conflicting options in postgres module (issue #8717)
• Fix ps modules for psutil >= 0.3.0 (issue #7432)
• Fix postgres module to return False on failure (issue #8778)
• Fix argument passing for args with pound signs (issue #8585)
• Fix pid of salt CLi command showing in status.pid output (issue #8720)
• Fix rvm to run gem as the correct user (issue #8951)
• Fix namespace issue in win_file module (issue #9060)
• Fix masterless state paths on windows (issue #9021)
• Fix timeout option in master config (issue #9040)
Salt 0.17.4 Release Notes release 2013-12-10
Version 0.17.4 is another bugfix release for 0.17.0.  The changes include:
• Fix file.replace bug when replacement str is numeric (issue #9101)
• Fix regression in file.managed (issue #9131)
• Prevent traceback when job is None. (issue #9145)
Salt 0.17.5 Release Notes release 2014-01-27
Version 0.17.5 is another bugfix release for 0.17.0.  The changes include:
• Fix user.present states with non-string fullname (issue #9085)
• Fix virt.init return value on failure (issue #6870)
• Fix reporting of file.blockreplace state when test=True
• Fix network.interfaces when used in cron (issue #7990)
• Fix bug in pkgrepo when switching to/from mirrorlist-based repo def (‐ issue #9121)
• Fix infinite recursion when cache file is corrupted
• Add checking for rev and mirror/bare args in git.latest (issue #9107)
• Add cmd.watch alias (points to cmd.wait) (issue #8612)
• Fix stacktrace when prereq is not formed as a list (issue #8235)
• Fix stdin issue with lvdisplay command (issue #9128)
• Add pre-check function for range matcher (issue #9236)
• Add exception handling for psutil for processes that go missing (issue #9274)
• Allow _in requisites to match both on ID and name (issue #9061)
• Fix multiple client timeout issues (issue #7157 and issue #9302, probably others)
• Multiple optimization in minion auth routines
Salt 0.6.0 release notes The Salt remote execution manager has reached initial functionality! Salt is a management application which can be used to execute commands on remote sets of servers.
The whole idea behind Salt is to create a system where a group of servers can be remotely controlled from a single master, not only can commands be executed on remote systems, but salt can also be used to gather information about your server environment.
Unlike similar systems, like Func and MCollective, Salt is extremely simple to setup and use, the entire application is contained in a single package, and the master and minion daemons require no running dependencies in the way that Func requires Certmaster and MCollective requires activeMQ.
Salt also manages authentication and encryption. Rather than using SSL for encryption, salt manages encryption on a payload level, so the data sent across the network is encrypted with fast AES encryption, and authentication uses RSA keys. This means that Salt is fast, secure, and very efficient.
Messaging in Salt is executed with ZeroMQ, so the message passing interface is built into salt and does not require an external ZeroMQ server. This also adds speed to Salt since there is no additional bloat on the networking layer, and ZeroMQ has already proven itself as a very fast networking system.
The remote execution in Salt is "Lazy Execution", in that once the command is sent the requesting network connection is closed. This makes it easier to detach the execution from the calling process on the master, it also means that replies are cached, so that information gathered from historic commands can be queried in the future.
Salt also allows users to make execution modules in Python. Writers of these modules should also be pleased to know that they have access to the impressive information gathered from PuppetLabs' Facter application, making Salt module more flexible. In the future I hope to also allow Salt to group servers based on Facter information as well.
All in all Salt is fast, efficient, and clean, can be used from a simple command line client or through an API, uses message queue technology to make network execution extremely fast, and encryption is handled in a very fast and efficient manner. Salt is also VERY easy to use and VERY easy to extend.
You can find the source code for Salt on my GitHub page, I have also set up a few wiki pages explaining how to use and set up Salt. If you are using Arch Linux there is a package available in the Arch Linux AUR.
GitHub page: https://github.com/saltstack/salt
Wiki: https://github.com/saltstack/salt/wiki
Arch Linux Package: https://aur.archlinux.org/packages/salt-git/
I am very open to contributions, for instance I need packages for more Linux distributions as well as BSD packages and testers.
Give Salt a try, this is the initial release and is not a 1.0 quality release, but it has been working well for me! I am eager to get your feedback!
Salt 0.7.0 release notes I am pleased to announce the release of Salt 0.7.0!
This release marks what is the first stable release of salt, 0.7.0 should be suitable for general use.
0.7.0 Brings the following new features to Salt:
• Integration with Facter data from puppet labs
• Allow for matching minions from the salt client via Facter information
• Minion job threading, many jobs can be executed from the master at once
• Preview of master clustering support - Still experimental
• Introduce new minion modules for stats, virtualization, service management and more
• Add extensive logging to the master and minion daemons
• Add sys.reload_functions for dynamic function reloading
• Greatly improve authentication
• Introduce the saltkey command for managing public keys
• Begin backend development preparatory to introducing butter
• Addition of man pages for the core commands
• Extended and cleaned configuration
0.7.0 Fixes the following major bugs:
• Fix crash in minions when matching failed
• Fix configuration file lookups for the local client
• Repair communication bugs in encryption
• Numerous fixes in the minion modules
The next release of Salt should see the following features:
• Stabilize the cluster support
• Introduce a remote client for salt command tiers
• salt-ftp system for distributed file copies
• Initial support for "butter"
Coming up next is a higher level management framework for salt called Butter. I want salt to stay as a simple and effective communication framework, and allow for more complicated executions to be managed via Butter.
Right now Butter is being developed to act as a cloud controller using salt as the communication layer, but features like system monitoring and advanced configuration control (a puppet manager) are also in the pipe.
Special thanks to Joseph Hall for the status and network modules, and thanks to Matthias Teege for tracking down some configuration bugs!
Salt can be downloaded from the following locations;
Arch Linux Package:
https://aur.archlinux.org/packages/salt-git/
Please enjoy the latest Salt release!
Salt 0.8.0 release notes Salt 0.8.0 is ready for general consumption!  The source tarball is available on GitHub for download:
A lot of work has gone into salt since the last release just 2 weeks ago, and salt has improved a great deal. A swath of new features are here along with performance and threading improvements!
The main new features of salt 0.8.0 are:
Salt-cp
Cython minion modules
Dynamic returners
Faster return handling
Lowered required Python version to 2.6
Advanced minion threading
Configurable minion modules
Salt-cp The salt-cp command introduces the ability to copy simple files via salt to targeted servers. Using salt-cp is very simple, just call salt-cp with a target specification, the source file(s) and where to copy the files on the minions.  For instance:
# salt-cp ‘*’ /etc/hosts /etc/hosts
Will copy the local /etc/hosts file to all of the minions.
Salt-cp is very young, in the future more advanced features will be added, and the functionality will much more closely resemble the cp command.
Cython minion modules Cython is an amazing tool used to compile Python modules down to c. This is arguably the fastest way to run Python code, and since pyzmq requires cython, adding support to salt for cython adds no new dependencies.
Cython minion modules allow minion modules to be written in cython and therefore executed in compiled c. Simply write the salt module in cython and use the file extension “.pyx” and the minion module will be compiled when the minion is started. An example cython module is included in the main distribution called cytest.pyx:
https://github.com/saltstack/salt/blob/master/salt/modules/cytest.pyx
Dynamic Returners By default salt returns command data back to the salt master, but now salt can return command data to any system. This is enabled via the new returners modules feature for salt. The returners modules take the return data and sends it to a specific module. The returner modules work like minion modules, so any returner can be added to the minions.
This means that a custom data returner can be added to communicate the return data so anything from MySQL, Redis, MongoDB, and more!
There are 2 simple stock returners in the returners directory:
https://github.com/saltstack/salt/blob/master/salt/returners
The documentation on writing returners will be added to the wiki shortly, and returners can be written in pure Python, or in cython.
Configurable Minion Modules Minion modules may need to be configured, now the options passed to the minion configuration file can be accessed inside of the minion modules via the __opt__ dict.
Information on how to use this simple addition has been added to the wiki: Writing modules
The test module has an example of using the __opts__ dict, and how to set default options:
https://github.com/saltstack/salt/blob/master/salt/modules/test.py
Advanced Minion Threading In 0.7.0 the minion would block after receiving a command from the master, now the minion will spawn a thread or multiprocess. By default Python threads are used because for general use they have proved to be faster, but the minion can now be configured to use the Python multiprocessing module instead. Using multiprocessing will cause executions that are CPU bound or would otherwise exploit the negative aspects of the Python GIL to run faster and more reliably, but simple calls will still be faster with Python threading.  The configuration option can be found in the minion configuration file:
https://github.com/saltstack/salt/blob/master/conf/minion
Lowered Supported Python to 2.6 The requirement for Python 2.7 has been removed to support Python 2.6. I have received requests to take the minimum Python version back to 2.4, but unfortunately this will not be possible, since the ZeroMQ Python bindings do not support Python 2.4.
Salt 0.8.0 is a very major update, it also changes the network protocol slightly which makes communication with older salt daemons impossible, your master and minions need to be upgraded together!
I could use some help bringing salt to the people! Right now I only have packages for Arch Linux, Fedora 14 and Gentoo. We need packages for Debian and people willing to help test on more platforms. We also need help writing more minion modules and returner modules. If you want to contribute to salt please hop on the mailing list and send in patches, make a fork on GitHub and send in pull requests! If you want to help but are not sure where you can, please email me directly or post tot he mailing list!
I hope you enjoy salt, while it is not yet 1.0 salt is completely viable and usable!
-Thomas S. Hatch
Salt 0.8.7 release notes It has been a month since salt 0.8.0, and it has been a long month! But Salt is still coming along strong. 0.8.7 has a lot of changes and a lot of updates.  This update makes Salt’s ZeroMQ back end better, strips Facter from the dependencies, and introduces interfaces to handle more capabilities.
Many of the major updates are in the background, but the changes should shine through to the surface. A number of the new features are still a little thin, but the back end to support expansion is in place.
I also recently gave a presentation to the Utah Python users group in Salt Lake City, the slides from this presentation are available here:
The video from this presentation will be available shortly.
The major new features and changes in Salt 0.8.7 are:
• Revamp ZeroMQ topology on the master for better scalability
• State enforcement
• Dynamic state enforcement managers
• Extract the module loader into salt.loader
• Make Job ids more granular
• Replace Facter functionality with the new salt grains interface
• Support for “virtual” salt modules
• Introduce the salt-call command
• Better debugging for minion modules
The new ZeroMQ topology allows for better scalability, this will be required by the need to execute massive file transfers to multiple machines in parallel and state management. The new ZeroMQ topology is available in the aforementioned presentation.
0.8.7 introduces the capability to declare states, this is similar to the capabilities of Puppet. States in salt are declared via state data structures.  This system is very young, but the core feature set is available. Salt states work around rendering files which represent Salt high data. More on the Salt state system will be documented in the near future.
The system for loading salt modules has been pulled out of the minion class to be a standalone module, this has enabled more dynamic loading of Salt modules and enables many of the updates in 0.8.7 –
https://github.com/saltstack/salt/blob/master/salt/loader.py
Salt Job ids are now microsecond precise, this was needed to repair a race condition unveiled by the speed improvements in the new ZeroMQ topology.
The new grains interface replaces the functionality of Facter, the idea behind grains differs from Facter in that the grains are only used for static system data, dynamic data needs to be derived from a call to a salt module. This makes grains much faster to use, since the grains data is generated when the minion starts.
Virtual salt modules allows for a salt module to be presented as something other than its module name. The idea here is that based on information from the minion decisions about which module should be presented can be made. The best example is the pacman module. The pacman module will only load on Arch Linux minions, and will be called pkg. Similarly the yum module will be presented as pkg when the minion starts on a Fedora/RedHat system.
The new salt-call command allows for minion modules to be executed from the minion. This means that on the minion a salt module can be executed, this is a great tool for testing Salt modules. The salt-call command can also be used to view the grains data.
In previous releases when a minion module threw an exception very little data was returned to the master. Now the stack trace from the failure is returned making debugging of minion modules MUCH easier.
Salt is nearing the goal of 1.0, where the core feature set and capability is complete!
-Thomas S Hatch
Salt 0.8.8 release notes Salt 0.8.8 is here! This release adds a great deal of code and some serious new features.
Improved Documentation has been set up for salt using sphinx thanks to the efforts of Seth House. This new documentation system will act as the back end to the salt website which is still under heavy development. The new sphinx documentation system has also been used to greatly clean up the salt manpages.  The salt 7 manpage in particular now contains extensive information which was previously only in the wiki. The new documentation can be found at: https://docs.saltproject.io/ We still have a lot to add, and when the domain is set up I will post another announcement.
More additions have been made to the ZeroMQ setup, particularly in the realm of file transfers. Salt 0.8.8 introduces a built in, stateless, encrypted file server which allows salt minions to download files from the salt master using the same encryption system used for all other salt communications. The main motivation for the salt file server has been to facilitate the new salt state system.
Much of the salt code has been cleaned up and a new cleaner logging system has been introduced thanks to the efforts of Pedro Algarvio. These additions will allow for much more flexible logging to be executed by salt, and fixed a great deal of my poor spelling in the salt docstrings! Pedro Algarvio has also cleaned up the API, making it easier to embed salt into another application.
The biggest addition to salt found in 0.8.8 is the new state system. The salt module system has received a new front end which allows salt to be used as a configuration management system. The configuration management system allows for system configuration to be defined in data structures. The configuration management system, or as it is called in salt, the “salt state system” supports many of the features found in other configuration managers, but allows for system states to be written in a far simpler format, executes at blazing speeds, and operates via the salt minion matching system. The state system also operates within the normal scope of salt, and requires no additional configuration to use.
The salt state system can enforce the following states with many more to come: Packages Files Services Executing commands Hosts
The system used to define the salt states is based on a data structure, the data structure used to define the salt states has been made to be as easy to use as possible. The data structure is defined by default using a YAML file rendered via a Jinja template. This means that the state definition language supports all of the data structures that YAML supports, and all of the programming constructs and logic that Jinja supports. If the user does not like YAML or Jinja the states can be defined in yaml-mako, json-jinja, or json-mako. The system used to render the states is completely dynamic, and any rendering system can be added to the capabilities of Salt, this means that a rendering system that renders XML data in a cheetah template, or whatever you can imagine, can be easily added to the capabilities of salt.
The salt state system also supports isolated environments, as well as matching code from several environments to a single salt minion.
The feature base for Salt has grown quite a bit since my last serious documentation push. As we approach 0.9.0 the goals are becoming very clear, and the documentation needs a lot of work. The main goals for 0.9.0 are to further refine the state system, fix any bugs we find, get Salt running on as many platforms as we can, and get the documentation filled out. There is a lot more to come as Salt moves forward to encapsulate a much larger scope, while maintaining supreme usability and simplicity.
If you would like a more complete overview of Salt please watch the Salt presentation: Slides:
Salt 0.8.9 Release Notes Salt 0.8.9 has finally arrived! Unfortunately this is much later than I had hoped to release 0.8.9, life has been very crazy over the last month. But despite challenges, Salt has moved forward!
This release, as expected, adds few new features and many refinements. One of the most exciting aspect of this release is that the development community for salt has grown a great deal and much of the code is from contributors.
Also, I have filled out the documentation a great deal. So information on States is properly documented, and much of the documentation that was out of date has been filled in.
Download! The Salt source can be downloaded from PyPI:
https://pypi.python.org/packages/source/s/salt/salt-0.8.9.tar.gz
Here s the md5sum:
7d5aca4633bc22f59045f59e82f43b56
For instructions on how to set up Salt please see the installation instructions.
New Features Salt Run A big feature is the addition of Salt run, the salt-run command allows for master side execution modules to be made that gather specific information or execute custom routines from the master.
Documentation for salt-run can be found here
Refined Outputters One problem often complained about in salt was the fact that the output was so messy. Thanks to help from Jeff Schroeder a cleaner interface for the command output for the Salt CLI has been made. This new interface makes adding new printout formats easy and additions to the capabilities of minion modules makes it possible to set the printout mode or outputter for functions in minion modules.
Cross Calling Salt Modules Salt modules can now call each other, the __salt__ dict has been added to the predefined references in minion modules. This new feature is documented in the modules documentation.
Watch Option Added to Salt State System Now in Salt states you can set the watch option, this will allow watch enabled states to change based on a change in the other defined states. This is similar to subscribe and notify statements in puppet.
Root Dir Option Travis Cline has added the ability to define the option root_dir which allows the salt minion to operate in a subdir. This is a strong move in supporting the minion running as an unprivileged user
Config Files Defined in Variables Thanks again to Travis Cline, the master and minion configuration file locations can be defined in environment variables now.
New Modules Quite a few new modules, states, returners, and runners have been made.
New Minion Modules apt Support for apt-get has been added, this adds greatly improved Debian and Ubuntu support to Salt!
useradd and groupadd Support for manipulating users and groups on Unix-like systems.
moosefs Initial support for reporting on aspects of the distributed file system, MooseFS. For more information on MooseFS please see: http://www.moosefs.org
Thanks to Joseph Hall for his work on MooseFS support.
mount Manage mounts and the fstab.
puppet Execute puppet on remote systems.
shadow Manipulate and manage the user password file.
ssh Interact with ssh keys.
New States user and group Support for managing users and groups in Salt States.
mount Enforce mounts and the fstab.
New Returners mongo_return Send the return information to a MongoDB server.
New Runners manage Display minions that are up or down.
Salt 0.9.0 Release Notes release 2011-08-27
Salt 0.9.0 is here. This is an exciting release, 0.9.0 includes the new network topology features allowing peer salt commands and masters of masters via the syndic interface.
0.9.0 also introduces many more modules, improvements to the API and improvements to the ZeroMQ systems.
https://pypi.python.org/packages/source/s/salt/salt-0.9.0.tar.gz
Here is the md5sum:
9a925da04981e65a0f237f2e77ddab37
New Features Salt Syndic The new Syndic interface allows a master to be commanded via another higher level salt master. This is a powerful solution allowing a master control structure to exist, allowing salt to scale to much larger levels then before.
Peer Communication 0.9.0 introduces the capability for a minion to call a publication on the master and receive the return from another set of minions. This allows salt to act as a communication channel between minions and as a general infrastructure message bus.
Peer communication is turned off by default but can be enabled via the peer option in the master configuration file. Documentation on the new Peer interface.
Easily Extensible API The minion and master classes have been redesigned to allow for specialized minion and master servers to be easily created. An example on how this is done for the master can be found in the master.py salt module:
https://github.com/saltstack/salt/blob/master/salt/master.py
The Master class extends the SMaster class and set up the main master server.
The minion functions can now also be easily added to another application via the SMinion class, this class can be found in the minion.py module:
https://github.com/saltstack/salt/blob/master/salt/minion.py
Cleaner Key Management This release changes some of the key naming to allow for multiple master keys to be held based on the type of minion gathering the master key.
The -d option has also been added to the salt-key command allowing for easy removal of accepted public keys.
The --gen-keys option is now available as well for salt-key, this allows for a salt specific RSA key pair to be easily generated from the command line.
Improved 0MQ Master Workers The 0MQ worker system has been further refined to be faster and more robust.  This new system has been able to handle a much larger load than the previous setup. The new system uses the IPC protocol in 0MQ instead of TCP.
New Modules Quite a few new modules have been made.
New Minion Modules apache Work directly with apache servers, great for managing balanced web servers
cron Read out the contents of a systems crontabs
mdadm Module to manage raid devices in Linux, appears as the raid module
mysql Gather simple data from MySQL databases
ps Extensive utilities for managing processes
publish Used by the peer interface to allow minions to make publications
Salt 0.9.1 Release Notes release 2011-08-29
Salt 0.9.2 Release Notes release 2011-09-17
Salt 0.9.2 has arrived! 0.9.2 is primarily a bugfix release, the exciting component in 0.9.2 is greatly improved support for salt states. All of the salt states interfaces have been more thoroughly tested and the new salt-states git repo is growing with example of how to use states.
This release introduces salt states for early developers and testers to start helping us clean up the states interface and make it ready for the world!
0.9.2 also fixes a number of bugs found on Python 2.6.
https://pypi.python.org/packages/source/s/salt/salt-0.9.2.tar.gz
New Features Salt-Call Additions The salt-call command has received an overhaul, it now hooks into the outputter system so command output looks clean, and the logging system has been hooked into salt-call, so the -l option allows the logging output from salt minion functions to be displayed.
The end result is that the salt-call command can execute the state system and return clean output:
# salt-call state.highstate
State System Fixes The state system has been tested and better refined. As of this release the state system is ready for early testers to start playing with. If you are interested in working with the state system please check out the (still very small) salt-states GitHub repo:
https://github.com/SS-archive/salt-states
This git repo is the active development branch for determining how a clean salt-state database should look and act. Since the salt state system is still very young a lot of help is still needed here. Please fork the salt-states repo and help us develop a truly large and scalable system for configuration management!
Notable Bug Fixes Python 2.6 String Formatting Python 2.6 does not support format strings without an index identifier, all of them have been repaired.
Cython Loading Disabled by Default Cython loading requires a development tool chain to be installed on the minion, requiring this by default can cause problems for most Salt deployments. If Cython auto loading is desired it will need to be turned on in the minion config.
Salt 0.9.3 Release Notes release 2011-11-05
Salt 0.9.3 is finally arrived. This is another big step forward for Salt, new features range from proper FreeBSD support to fixing issues seen when attaching a minion to a master over the Internet.
The biggest improvements in 0.9.3 though can be found in the state system, it has progressed from something ready for early testers to a system ready to compete with platforms such as Puppet and Chef. The backbone of the state system has been greatly refined and many new features are available.
https://pypi.python.org/packages/source/s/salt/salt-0.9.3.tar.gz
New Features WAN Support Recently more people have been testing Salt minions connecting to Salt Masters over the Internet. It was found that Minions would commonly loose their connection to the master when working over the internet. The minions can now detect if the connection has been lost and reconnect to the master, making WAN connections much more reliable.
State System Fixes Substantial testing has gone into the state system and it is ready for real world usage. A great deal has been added to the documentation for states and the modules and functions available to states have been cleanly documented.
A number of State System bugs have also been founds and repaired, the output from the state system has also been refined to be extremely clear and concise.
Error reporting has also been introduced, issues found in sls files will now be clearly reported when executing Salt States.
Extend Declaration The Salt States have also gained the extend declaration. This declaration allows for states to be cleanly modified in a post environment. Simply said, if there is an apache.sls file that declares the apache service, then another sls can include apache and then extend it:
extend: apache: service: - require: - pkg: mod_python
mod_python: pkg: - installed
The notable behavior with the extend functionality is that it literally extends or overwrites a declaration set up in another sls module. This means that Salt will behave as though the modifications were made directly to the apache sls.  This ensures that the apache service in this example is directly tied to all requirements.
Highstate Structure Specification This release comes with a clear specification of the Highstate data structure that is used to declare Salt States. This specification explains everything that can be declared in the Salt SLS modules.
The specification is extremely simple, and illustrates how Salt has been able to fulfill the requirements of a central configuration manager within a simple and easy to understand format and specification.