Updated master and minion default config files

Added parameters new to 2016.03 (or simply missing in the existing config).

salt/files/master.d/f_defaults.conf

 # This file managed by Salt, do not edit by hand!!
-# Based on salt version 2015.8.7 default config
+# Based on salt version 2016.11 default config
 {% set reserved_keys = ['master', 'minion', 'cloud', 'salt_cloud_certs', 'engines', 'lxc.network_profile', 'lxc.container_profile'] -%}
 {% set cfg_salt = pillar.get('salt', {}) -%}
 {% set cfg_master = cfg_salt.get('master', {}) -%}
 # key_logfile, pidfile:
 {{ get_config('root_dir', '/') }}
 
+# The path to the master's configuration file.
+{{ get_config('conf_file', '/etc/salt/master') }}
+
 # Directory used to store public key data:
 {{ get_config('pki_dir', '/etc/salt/pki/master') }}
 
+# Key cache. Increases master speed for large numbers of accepted
+# keys. Available options: 'sched'. (Updates on a fixed schedule.)
+# Note that enabling this feature means that minions will not be
+# available to target for up to the length of the maintanence loop
+# which by default is 60s.
+{%- if cfg_minion['key_cache'] in cfg_master %}
+{{ get_config('key_cache', '') }}
+{% else %}
+#key_cache: ''
+{% endif %}
+
 # Directory to store job and cache data:
 # This directory may contain sensitive data and should be protected accordingly.
 #
 
 # Directory for custom modules. This directory can contain subdirectories for
 # each of Salt's module types such as "runners", "output", "wheel", "modules",
-# "states", "returners", etc.
+# "states", "returners", "engines", etc.
 # Like 'extension_modules' but can take an array of paths
 {% if 'module_dirs' in cfg_master -%}
 {%- do default_keys.append('module_dirs') %}
 # Set the number of hours to keep old job information in the job cache:
 {{ get_config('keep_jobs', '24') }}
 
+# The number of seconds to wait when the client is requesting information
+# about running jobs.
+{{ get_config('gather_job_timeout', '10') }}
+
 # Set the default timeout for the salt command and api. The default is 5
 # seconds.
 {{ get_config('timeout', '5') }}
 # Set the default outputter used by the salt command. The default is "nested".
 {{ get_config('output', 'nested') }}
 
+# Set the default output file used by the salt command. Default is to output
+# to the CLI and not to a file. Functions the same way as the "--out-file"
+# CLI option, only sets this to a single file for all salt commands.
+{{ get_config('output_file', 'None') }}
+
 # Return minions that timeout when running commands like test.ping
 {{ get_config('show_timeout', 'True') }}
 
 # (true by default).
 {{ get_config('strip_colors', 'False') }}
 
+# To display a summary of the number of minions targeted, the number of
+# minions returned, and the number of minions that did not return, set the
+# cli_summary value to True. (False by default.)
+#
+{{ get_config('cli_summary', 'False') }}
+
 # Set the directory used to hold unix sockets:
 {{ get_config('sock_dir', '/var/run/salt/master') }}
 
 # the jobs system and is not generally recommended.
 {{ get_config('job_cache', 'True') }}
 
-# Cache minion grains and pillar data in the cachedir.
+# Cache minion grains, pillar and mine data via the cache subsystem in the
+# cachedir or a database.
 {{ get_config('minion_data_cache', 'True') }}
 
+# Cache subsystem module to use for minion data cache.
+{{ get_config('cache', 'localfs') }}
+# Enables a fast in-memory cache booster and sets the expiration time.
+{{ get_config('memcache_expire_seconds', '0') }}
+# Set a memcache limit in items (bank + key) per cache storage (driver + driver_opts).
+{{ get_config('memcache_max_items', '1024') }}
+# Each time a cache storage got full cleanup all the expired items not just the oldest one.
+{{ get_config('memcache_full_cleanup', 'False') }}
+# Enable collecting the memcache stats and log it on `debug` log level.
+{{ get_config('memcache_debug', 'False') }}
+
 # Store all returns in the given returner.
 # Setting this option requires that any returner-specific configuration also
 # be set. See various returners in salt/returners for details on required
 # By default, events are not queued.
 {{ get_config('event_return_queue', '0') }}
 
-# Only events returns matching tags in a whitelist
+# Only return events matching tags in a whitelist, supports glob matches.
 {% if 'event_return_whitelist' in cfg_master -%}
 {%- do default_keys.append('event_return_whitelist') %}
 event_return_whitelist:
   - {{ event_return }}
   {%- endfor -%}
 {% else -%}
-# event_return_whitelist:
-#   - salt/master/a_tag
-#   - salt/master/another_tag
+#event_return_whitelist:
+#  - salt/master/a_tag
+#  - salt/run/*/ret
 {% endif %}
 
-# Store all event returns _except_ the tags in a blacklist
+# Store all event returns **except** the tags in a blacklist supports globs.
 {% if 'event_return_blacklist' in cfg_master -%}
 {%- do default_keys.append('event_return_blacklist') %}
 event_return_blacklist:
   - {{ event_return }}
   {%- endfor -%}
 {% else -%}
-# event_return_blacklist:
-#   - salt/master/not_this_tag
-#   - salt/master/or_this_one
+#event_return_blacklist:
+#  - salt/master/not_this_tag
+#  - salt/wheel/*/ret
 {% endif %}
 
 # Passing very large events can cause the minion to consume large amounts of
 # Set the ZeroMQ high water marks
 # http://api.zeromq.org/3-2:zmq-setsockopt
 
+# The listen queue size / backlog
+{{ get_config('zmq_backlog', '1000') }}
+
 # The publisher interface ZeroMQPubServerChannel
 {{ get_config('pub_hwm', '1000') }}
 
 # ZMQ high-water-mark for EventPublisher pub socket
 {{ get_config('event_publisher_pub_hwm', '10000') }}
 
+# The master may allocate memory per-event and not
+# reclaim it.
+# To set a high-water mark for memory allocation, use
+# ipc_write_buffer to set a high-water mark for message
+# buffering.
+# Value: In bytes. Set to 'dynamic' to have Salt select
+# a value for you. Default is disabled.
+{%- if 'ipc_write_buffer' in cfg_master %}
+{{ get_config('ipc_write_buffer', 'dynamic') }}
+{%- else %}
+# ipc_write_buffer: 'dynamic'
+{%- endif %}
+
 
 #####        Security settings       #####
 ##########################################
 # public keys from the minions. Note that this is insecure.
 {{ get_config('auto_accept', 'False') }}
 
-# Time in minutes that a incoming public key with a matching name found in
+# Time in minutes that an incoming public key with a matching name found in
 # pki_dir/minion_autosign/keyid is automatically accepted. Expired autosign keys
 # are removed when the master checks the minion_autosign directory.
 # 0 equals no timeout
 #  larry:
 #    - test.ping
 #    - network.*
+#
 {%- endif %}
 
 # Blacklist any of the following users or modules
 # This example would blacklist all non sudo users, including root from
 # running any commands. It would also blacklist any use of the "cmd"
 # module. This is completely disabled by default.
+#
+#
+# Check the list of configured users in client ACL against users on the
+# system and throw errors if they do not exist.
+{{ get_config('client_acl_verify', 'True') }}
+#
 {% if 'publisher_acl_blacklist' in cfg_master %}
 {%- do default_keys.append('publisher_acl_blacklist') %}
 publisher_acl_blacklist:
 #  modules:
 #    - cmd
 {% endif %}
+#
+# WARNING: client_acl and client_acl_blacklist options are deprecated and will
+# be removed in the future releases. Use publisher_acl and
+# publisher_acl_blacklist instead.
 
 # Enforce publisher_acl & publisher_acl_blacklist when users have sudo
 # access to the salt command.
 
 # Time (in seconds) for a newly generated token to live. Default: 12 hours
 {{ get_config('token_expire', '43200') }}
+#
+# Allow eauth users to specify the expiry time of the tokens they generate.
+# A boolean applies to all users or a dictionary of whitelisted eauth backends
+# and usernames may be given.
+# token_expire_user_override:
+#   pam:
+#     - fred
+#     - tom
+#   ldap:
+#     - gary
+#
+#token_expire_user_override: False
 
 # Allow minions to push files to the master. This is disabled by default, for
 # security purposes.
 # will cause minion to throw an exception and drop the message.
 {{ get_config('sign_pub_message', 'False') }}
 
+# Use TLS/SSL encrypted connection between master and minion.
+# Can be set to a dictionary containing keyword arguments corresponding to Python's
+# 'ssl.wrap_socket' method.
+# Default is None.
+#ssl:
+#    keyfile: <path_to_keyfile>
+#    certfile: <path_to_certfile>
+#    ssl_version: PROTOCOL_TLSv1_2
+
 # Sign the master auth-replies with a cryptographic signature of the masters public key.
 # Please see the tutorial how to use these settings in the Multimaster-PKI with Failover Tutorial
 {{ get_config('master_sign_pubkey', 'False') }}
 # Pass in an alternative location for the salt-ssh roster file
 {{ get_config('roster_file', '/etc/salt/roster') }}
 
+# Define locations for roster files so they can be chosen when using Salt API.
+# An administrator can place roster files into these locations. Then when
+# calling Salt API, parameter 'roster_file' should contain a relative path to
+# these locations. That is, "roster_file=/foo/roster" will be resolved as
+# "/etc/salt/roster.d/foo/roster" etc. This feature prevents passing insecure
+# custom rosters through the Salt API.
+#
+{%- if 'rosters' in cfg_master %}
+rosters:
+  {% for name in cfg_master['rosters'] -%}
+  - {{ name }}
+  {% endfor -%}
+{%- else %}
+#rosters:
+# - /etc/salt/roster.d
+# - /opt/salt/some/more/rosters
+{%- endif %}
+
+# The log file of the salt-ssh command:
+{{ get_config('ssh_log_file', '/var/log/salt/ssh') }}
+
 # Pass in minion option overrides that will be inserted into the SHIM for
 # salt-ssh calls. The local minion config is not used for salt-ssh. Can be
 # overridden on a per-minion basis in the roster (`minion_opts`)
 #  gpg_keydir: /root/gpg
 {{ get_config('ssh_minion_opts', '{}') }}
 
+# Set this to True to default to using ~/.ssh/id_rsa for salt-ssh
+# authentication with minions
+{{ get_config('ssh_use_home_key', 'False') }}
+
 #####    Master Module Management    #####
 ##########################################
 # Manage how master side modules are loaded.
 # (block, not variable tag!). Defaults to False, corresponds to the Jinja
 # environment init variable "trim_blocks".
 {{ get_config('jinja_trim_blocks', 'False') }}
-
+#
 # If this is set to True leading spaces and tabs are stripped from the start
 # of a line to a block. Defaults to False, corresponds to the Jinja
 # environment init variable "lstrip_blocks".
 #file_roots:
 #  base:
 #    - /srv/salt
+#
 {%- endif %}
 
 # When using multiple environments, each with their own top file, the
 {{ get_config('default_top', 'base') }}
 
 # The hash_type is the hash to use when discovering the hash of a file on
-# the master server. The default is md5, but sha1, sha224, sha256, sha384
+# the master server. The default is md5 but sha1, sha224, sha256, sha384
 # and sha512 are also supported.
 #
+# WARNING: While md5 and sha1 are also supported, do not use it due to the high chance
+# of possible collisions and thus security breach.
+#
 # Prior to changing this value, the master should be stopped and all Salt
 # caches should be cleared.
 {{ get_config('hash_type', 'md5') }}
 # and the first repo to have the file will return it.
 # When using the git backend branches and tags are translated into salt
 # environments.
-# Note:  file:// repos will be treated as a remote, so refs you want used must
+# Note: file:// repos will be treated as a remote, so refs you want used must
 # exist in that repo as *local* refs.
 {% if 'gitfs_remotes' in cfg_master -%}
 {%- do default_keys.append('gitfs_remotes') %}
 #pillar_roots:
 #  base:
 #    - /srv/pillar
+#
 {%- endif %}
 
 {% if 'ext_pillar' in cfg_master %}
 # ext_pillar.
 {{ get_config('ext_pillar_first', 'False') }}
 
+# The external pillars permitted to be used on-demand using pillar.ext
+{%- if 'on_demand_ext_pillar' in cfg_master %}
+on_demand_ext_pillar:
+  {% for name in cfg_master['on_demand_ext_pillar'] -%}
+  - {{ name }}
+  {% endfor -%}
+{%- else %}
+#on_demand_ext_pillar:
+#  - libvirt
+#  - virtkey
+{%- endif %}
+
 # The pillar_gitfs_ssl_verify option specifies whether to ignore ssl certificate
 # errors when contacting the pillar gitfs backend. You might want to set this to
 # false if you're using a git backend that uses a self-signed certificate but
 {{ get_config('pillar_safe_render_error', 'True') }}
 
 # The pillar_source_merging_strategy option allows you to configure merging strategy
-# between different sources. It accepts four values: recurse, aggregate, overwrite,
-# or smart. Recurse will merge recursively mapping of data. Aggregate instructs
-# aggregation of elements between sources that use the #!yamlex renderer. Overwrite
-# will verwrite elements according the order in which they are processed. This is
+# between different sources. It accepts five values: none, recurse, aggregate, overwrite,
+# or smart. None will not do any merging at all. Recurse will merge recursively mapping of data.
+# Aggregate instructs aggregation of elements between sources that use the #!yamlex renderer. Overwrite
+# will overwrite elements according the order in which they are processed. This is
 # behavior of the 2014.1 branch and earlier. Smart guesses the best strategy based
 # on the "renderer" setting and is the default value.
 {{ get_config('pillar_source_merging_strategy', 'smart') }}
 
 # Recursively merge lists by aggregating them instead of replacing them.
-{{ get_config('pillar_merge_lists', False) }}
+{{ get_config('pillar_merge_lists', 'False') }}
+
+# Set this option to 'True' to force a 'KeyError' to be raised whenever an
+# attempt to retrieve a named value from pillar fails. When this option is set
+# to 'False', the failed attempt returns an empty string. Default is 'False'.
+{{ get_config('pillar_raise_on_missing', 'False') }}
 
 # Git External Pillar (git_pillar) Configuration Options
 #
 # to authenticate is protected by a passphrase.
 {{ get_config('git_pillar_passphrase', '') }}
 
+# A master can cache pillars locally to bypass the expense of having to render them
+# for each minion on every request. This feature should only be enabled in cases
+# where pillar rendering time is known to be unsatisfactory and any attendant security
+# concerns about storing pillars in a master cache have been addressed.
+#
+# When enabling this feature, be certain to read through the additional ``pillar_cache_*``
+# configuration options to fully understand the tunable parameters and their implications.
+#
+# Note: setting ``pillar_cache: True`` has no effect on targeting Minions with Pillars.
+# See https://docs.saltstack.com/en/latest/topics/targeting/pillar.html
+{{ get_config('pillar_cache', 'False') }}
+
+# If and only if a master has set ``pillar_cache: True``, the cache TTL controls the amount
+# of time, in seconds, before the cache is considered invalid by a master and a fresh
+# pillar is recompiled and stored.
+{{ get_config('pillar_cache_ttl', '3600') }}
+
+# If and only if a master has set `pillar_cache: True`, one of several storage providers
+# can be utililzed.
+#
+# `disk`: The default storage backend. This caches rendered pillars to the master cache.
+#         Rendered pillars are serialized and deserialized as msgpack structures for speed.
+#         Note that pillars are stored UNENCRYPTED. Ensure that the master cache
+#         has permissions set appropriately. (Same defaults are provided.)
+#
+# memory: [EXPERIMENTAL] An optional backend for pillar caches which uses a pure-Python
+#         in-memory data structure for maximal performance. There are several caveats,
+#         however. First, because each master worker contains its own in-memory cache,
+#         there is no guarantee of cache consistency between minion requests. This
+#         works best in situations where the pillar rarely if ever changes. Secondly,
+#         and perhaps more importantly, this means that unencrypted pillars will
+#         be accessible to any process which can examine the memory of the ``salt-master``!
+#         This may represent a substantial security risk.
+#
+{{ get_config('pillar_cache_backend', 'disk') }}
+
+
 #####          Syndic settings       #####
 ##########################################
 # The Salt syndic is used to pass commands through a master from a higher
 
 # If this master will be running a salt syndic daemon, syndic_master tells
 # this master where to receive commands from.
-{{ get_config('syndic_master', 'masterofmaster') }}
+{{ get_config('syndic_master', 'masterofmasters') }}
 
 # This is the 'ret_port' of the MasterOfMaster:
 {{ get_config('syndic_master_port', '4506') }}
 {{ get_config('syndic_pidfile', '/var/run/salt-syndic.pid') }}
 
 # LOG file of the syndic daemon:
-{{ get_config('syndic_log_file', 'syndic.log') }}
+{{ get_config('syndic_log_file', '/var/log/salt/syndic') }}
 
 # The user under which the salt syndic will run.
 {{ get_config('syndic_user', 'root') }}
 
+# The behaviour of the multi-syndic when connection to a master of masters failed.
+# Can specify ``random`` (default) or ``ordered``. If set to ``random``, masters
+# will be iterated in random order. If ``ordered`` is specified, the configured
+# order will be used.
+{{ get_config('syndic_failover', 'random') }}
+
+# The number of seconds for the salt client to wait for additional syndics to
+# check in with their lists of expected minions before giving up.
+{{ get_config('syndic_wait', '5') }}
+
+
 #####      Peer Publish settings     #####
 ##########################################
 # Salt minions can send commands to other minions, but only if the minion is
 
 #####         Node Groups           ######
 ##########################################
-# Node groups allow for logical groupings of minion nodes. A group consists of a group
-# name and a compound target.
+# Node groups allow for logical groupings of minion nodes. A group consists of
+# a group name and a compound target. Nodgroups can reference other nodegroups
+# with 'N@' classifier. Ensure that you do not have circular references.
+#
 #nodegroups:
-#  group1: 'L@foo.domain.com,bar.domain.com,baz.domain.com and bl*.domain.com'
+#  group1: 'L@foo.domain.com,bar.domain.com,baz.domain.com or bl*.domain.com'
 #  group2: 'G@os:Debian and foo.domain.com'
+#  group3: 'G@os:Debian and N@group1'
+#  group4:
+#    - 'G@foo:bar'
+#    - 'or'
+#    - 'G@foo:baz'
 {%- if 'nodegroups' in cfg_master %}
 {%- do default_keys.append('nodegroups') %}
 nodegroups:
 {{ get_config('return', '')}}
 
 
-######     Miscellaneous settings     ######
+######    Miscellaneous  settings     ######
 ############################################
 # Default match type for filtering events tags: startswith, endswith, find, regex, fnmatch
 {{ get_config('event_match_type', 'startswith') }}
 
+# Save runner returns to the job cache
+{{ get_config('runner_returns', 'True') }}
+
+# Permanently include any available Python 3rd party modules into Salt Thin
+# when they are generated for Salt-SSH or other purposes.
+# The modules should be named by the names they are actually imported inside the Python.
+# The value of the parameters can be either one module or a comma separated list of them.
+{%- if 'thin_extra_mods' in cfg_master %}
+{{ get_config('thin_extra_mods', '') }}
+{%- else %}
+#thin_extra_mods: foo,bar
+{%- endif %}
+
 {%- if 'halite' in cfg_master %}
 {%- do default_keys.append('halite') %}
 #####             Halite             #####

salt/files/minion.d/f_defaults.conf

 # This file managed by Salt, do not edit by hand!!
-#  Based on salt version 2015.8.7 default config
+#  Based on salt version 2016.11 default config
 #
 {% set reserved_keys = ['master', 'minion', 'cloud', 'salt_cloud_certs', 'engines', 'beacons'] -%}
 {% set cfg_salt = pillar.get('salt', {}) -%}
 # value to "str".  Failover masters can be requested by setting
 # to "failover".  MAKE SURE TO SET master_alive_interval if you are
 # using failover.
+# Setting master_type to 'disable' let's you have a running minion (with engines and
+# beacons) without a master connection
 {{ get_config('master_type', 'str') }}
 
 # verify_master_pubkey_sign
 # of TCP connections, such as load balancers.)
 {{ get_config('master_alive_interval', '30') }}
 
+# If the minion is in multi-master mode and the master_type configuration option
+# is set to "failover", this setting can be set to "True" to force the minion
+# to fail back to the first master in the list if the first master is back online.
+{{ get_config('master_fallback', 'False') }}
+
+# If the minion is in multi-master mode, the "master_type" configuration is set to
+# "failover", and the "master_failback" option is enabled, the master failback
+# interval can be set to ping the top master with this interval, in seconds.
+{{ get_config('master_fallback_interval', '0') }}
+
 # Set whether the minion should connect to the master via IPv6:
 {{ get_config('ipv6', 'False') }}
 
 # The user to run salt.
 {{ get_config('user', 'root') }}
 
-# Setting sudo_user will cause salt to run all execution modules under an sudo
-# to the user given in sudo_user.  The user under which the salt minion process
-# itself runs will still be that provided in the user config above, but all
-# execution modules run by the minion will be rerouted through sudo.
+# The user to run salt remote execution commands as via sudo. If this option is
+# enabled then sudo will be used to change the active user executing the remote
+# command. If enabled the user will need to be allowed access via the sudoers
+# file for the user that the salt minion is configured to run as. The most
+# common option would be to use the root user. If this option is set the user
+# option should also be set to a non-root user. If migrating from a root minion
+# to a non root minion the minion cache should be cleared and the minion pki
+# directory will need to be changed to the ownership of the new user.
 {{ get_config('sudo_user', 'saltdev') }}
 
 # Specify the location of the daemon process ID file.
 # sock_dir, pidfile.
 {{ get_config('root_dir', '/') }}
 
+# The path to the minion's configuration file.
+{{ get_config('conf_file', '/etc/salt/minion') }}
+
 # The directory to store the pki information in
 {{ get_config('pki_dir', '/etc/salt/pki/minion') }}
 
 #id:
 {%- endif %}
 
+# Cache the minion id to a file when the minion's id is not statically defined
+# in the minion config. Defaults to "True". This setting prevents potential
+# problems when automatic minion id resolution changes, which can cause the
+# minion to lose connection with the master. To turn off minion id caching,
+# set this config to ``False``.
+{{ get_config('minion_id_caching', 'True') }}
+
 # Append a domain to a hostname in the event that it does not exist.  This is
 # useful for systems where socket.getfqdn() does not actually result in a
 # FQDN (for instance, Solaris).
 # This data may contain sensitive data and should be protected accordingly.
 {{ get_config('cachedir', '/var/cache/salt/minion') }}
 
+# Append minion_id to these directories.  Helps with
+# multiple proxies and minions running on the same machine.
+# Allowed elements in the list: pki_dir, cachedir, extension_modules
+# Normally not needed unless running several proxies and/or minions on the same machine
+# Defaults to ['cachedir'] for proxies, [] (empty list) for regular minions
+{% if 'append_minionid_config_dirs' in cfg_minion -%}
+append_minionid_config_dirs:
+  {% for dir in cfg_minion['append_minionid_config_dirs'] -%}
+  - {{ dir }}
+  {% endfor -%}
+{%- else %}
+#append_minionid_config_dirs:
+{%- endif %}
+
 # Verify and set permissions on configuration directories at startup.
 {{ get_config('verify_env', 'True') }}
 
 # authenticate.
 {{ get_config('auth_tries', '7') }}
 
+# The number of attempts to connect to a master before giving up.
+# Set this to -1 for unlimited attempts. This allows for a master to have
+# downtime and the minion to reconnect to it later when it comes back up.
+# In 'failover' mode, it is the number of attempts for each set of masters.
+# In this mode, it will cycle through the list of masters for each attempt.
+#
+# This is different than auth_tries because auth_tries attempts to
+# retry auth attempts with a single master. auth_tries is under the
+# assumption that you can connect to the master but not gain
+# authorization from it. master_tries will still cycle through all
+# the masters in a given try, so it is appropriate if you expect
+# occasional downtime from the master(s).
+{{ get_config('master_tries', '1') }}
+
 # If authentication fails due to SaltReqTimeoutError during a ping_interval,
 # cause sub minion process to restart.
 {{ get_config('auth_safemode', 'False') }}
 {{ get_config('recon_randomize', 'False') }}
 
 # The loop_interval sets how long in seconds the minion will wait between
-# evaluating the scheduler and running cleanup tasks. This defaults to a
-# sane 60 seconds, but if the minion scheduler needs to be evaluated more
-# often lower this value
-{{ get_config('loop_interval', '60') }}
+# evaluating the scheduler and running cleanup tasks.  This defaults to 1
+# second on the minion scheduler.
+{{ get_config('loop_interval', '1') }}
+
+# Some installations choose to start all job returns in a cache or a returner
+# and forgo sending the results back to a master. In this workflow, jobs
+# are most often executed with --async from the Salt CLI and then results
+# are evaluated by examining job caches on the minions or any configured returners.
+# WARNING: Setting this to False will **disable** returns back to the master.
+{{ get_config('pub_ret', 'True') }}
+
+
+# The grains can be merged, instead of overridden, using this option.
+# This allows custom grains to defined different subvalues of a dictionary
+# grain. By default this feature is disabled, to enable set grains_deep_merge
+# to ``True``.
+{{ get_config('grains_deep_merge', 'False') }}
 
 # The grains_refresh_every setting allows for a minion to periodically check
 # its grains to see if they have changed and, if so, to inform the master
 # Cache grains on the minion. Default is False.
 {{ get_config('grains_cache', 'False') }}
 
+# Cache rendered pillar data on the minion. Default is False.
+# This may cause 'cachedir'/pillar to contain sensitive data that should be
+# protected accordingly.
+{{ get_config('minion_pillar_cache', 'False') }}
+
 # Grains cache expiration, in seconds. If the cache file is older than this
 # number of seconds then the grains cache will be dumped and fully re-populated
 # with fresh data. Defaults to 5 minutes. Will have no effect if 'grains_cache'
 # is not enabled.
 {{ get_config('grains_cache_expiration', '300') }}
 
+# Determines whether or not the salt minion should run scheduled mine updates.
+# Defaults to "True". Set to "False" to disable the scheduled mine updates
+# (this essentially just does not add the mine update function to the minion's
+# scheduler).
+{{ get_config('mine_enabled', 'True') }}
+
+# Determines whether or not scheduled mine updates should be accompanied by a job
+# return for the job cache. Defaults to "False". Set to "True" to include job
+# returns in the job cache for mine updates.
+{{ get_config('mine_return_job', 'False') }}
+
+# Example functions that can be run via the mine facility
+# NO mine functions are established by default.
+# Note these can be defined in the minion's pillar as well.
+#mine_functions:
+#  test.ping: []
+#  network.ip_addrs:
+#    interface: eth0
+#    cidr: '10.0.0.0/8'
+
 # Windows platforms lack posix IPC and must rely on slower TCP based inter-
 # process communications. Set ipc_mode to 'tcp' on such systems
 {{ get_config('ipc_mode', 'ipc') }}
     {%- endif -%}
 {% endif %}
 
+# The syndic minion can verify that it is talking to the correct master via the
+# key fingerprint of the higher-level master with the "syndic_finger" config.
+{{ get_config('syndic_finger', '') }}
+
+
 #####   Minion module management     #####
 ##########################################
 # Disable specific modules. This allows the admin to limit the level of
-# access the master has to the minion.
-{{ get_config('disable_modules', '[cmd,test]') }}
+# access the master has to the minion.  The default here is the empty list,
+# below is an example of how this needs to be formatted in the config file
+#disable_modules:
+#  - cmdmod
+#  - test
+#disable_returners: []
+{{ get_config('disable_modules', '[]') }}
 {{ get_config('disable_returners', '[]') }}
 
+# This is the reverse of disable_modules.  The default, like disable_modules, is the empty list,
+# but if this option is set to *anything* then *only* those modules will load.
+# Note that this is a very large hammer and it can be quite difficult to keep the minion working
+# the way you think it should since Salt uses many modules internally itself.  At a bare minimum
+# you need the following enabled or else the minion won't start.
+#whitelist_modules:
+#  - cmdmod
+#  - test
+#  - config
+{{ get_config('whitelist_modules', '[]') }}
+
 # Modules can be loaded from arbitrary paths. This enables the easy deployment
 # of third party modules. Modules for returners and minions can be loaded.
 # Specify a list of extra directories to search for minion modules and
 # by statically setting it. Remember that the recommended way to manage
 # environments is to isolate via the top file.
 {{ get_config('environment', 'None') }}
-
+#
+# Isolates the pillar environment on the minion side. This functions the same
+# as the environment setting, but for pillar instead of states.
+{{ get_config('pillarenv', 'None') }}
+#
+# Set this option to 'True' to force a 'KeyError' to be raised whenever an
+# attempt to retrieve a named value from pillar fails. When this option is set
+# to 'False', the failed attempt returns an empty string. Default is 'False'.
+{{ get_config('pillar_raise_on_missing', 'False') }}
+#
 # If using the local file directory, then the state top file name needs to be
 # defined, by default this is top.sls.
 {{ get_config('state_top', 'top.sls') }}
 #    - /srv/salt
 {%- endif %}
 
-
-# File Server Backend
+# Uncomment the line below if you do not want the file_server to follow
+# symlinks when walking the filesystem tree. This is set to True
+# by default. Currently this only applies to the default roots
+# fileserver_backend.
+{{ get_config('fileserver_followsymlinks', 'True') }}
 #
-# Salt supports a modular fileserver backend system, this system allows
-# the salt minion to link directly to third party systems to gather and
-# manage the files available to minions. Multiple backends can be
-# configured and will be searched for the requested file in the order in which
-# they are defined here. The default setting only enables the standard backend
-# "roots" which uses the "file_roots" option.
-#fileserver_backend:
-#  - roots
+# Uncomment the line below if you do not want symlinks to be
+# treated as the files they are pointing to. By default this is set to
+# False. By uncommenting the line below, any detected symlink while listing
+# files on the Master will not be returned to the Minion.
+{{ get_config('fileserver_ignoresymlinks', 'False') }}
 #
 # To use multiple backends list them in the order they are searched:
 #fileserver_backend:
 # is False.
 {{ get_config('fileserver_limit_traversal', 'False') }}
 
-# The hash_type is the hash to use when discovering the hash of a file in
+# The hash_type is the hash to use when discovering the hash of a file on
 # the local fileserver. The default is md5, but sha1, sha224, sha256, sha384
 # and sha512 are also supported.
 #
+# WARNING: While md5 and sha1 are also supported, do not use it due to the high chance
+# of possible collisions and thus security breach.
+#
 # Warning: Prior to changing this value, the minion should be stopped and all
 # Salt caches should be cleared.
 {{ get_config('hash_type', 'md5') }}
 #    - /srv/pillar
 {%- endif %}
 
+# Set a hard-limit on the size of the files that can be pushed to the master.
+# It will be interpreted as megabytes. Default: 100
+{{ get_config('file_recv_max_size', '100') }}
+
 {% if 'ext_pillar' in cfg_minion %}
 {%- do default_keys.append('ext_pillar') %}
 ext_pillar:
 # "salt-key -F master" on the Salt master.
 {{ get_config('master_finger', "''") }}
 
+# Use TLS/SSL encrypted connection between master and minion.
+# Can be set to a dictionary containing keyword arguments corresponding to Python's
+# 'ssl.wrap_socket' method.
+# Default is None.
+#ssl:
+#    keyfile: <path_to_keyfile>
+#    certfile: <path_to_certfile>
+#    ssl_version: PROTOCOL_TLSv1_2
+
 
 ######         Thread settings        #####
 ###########################################
 # Disable multiprocessing support, by default when a minion receives a
 # publication a new process is spawned and the command is executed therein.
+#
+# WARNING: Disabling multiprocessing may result in substantial slowdowns
+# when processing large pillars. See https://github.com/saltstack/salt/issues/38758
+# for a full explanation.
 {{ get_config('multiprocessing', 'True') }}
 
 
 
 ######      Returner  settings        ######
 ############################################
-# Which returner(s) will be used for minion's result:
+# Default Minion returners. Can be a comma delimited string or a list:
+#
+#return: mysql
+#
+#return: mysql,slack,redis
+#
+#return:
+#  - mysql
+#  - hipchat
+#  - slack
+{%- if 'return' in cfg_minion and cfg_minion['return'] is not string %}
+return:
+  {% for name in cfg_minion['return'] -%}
+  - {{ name }}
+  {% endfor -%}
+{%- else %}
 {{ get_config('return', '') }}
+{%- endif %}
 
 ######    Miscellaneous  settings     ######
 ############################################