golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/states

File/Folder	Size	Actions
__init__.py	25 B
__pycache__	-
acme.py	5.08 KB
alias.py	2.49 KB
alternatives.py	6.75 KB
ansiblegate.py	7.93 KB
apache.py	3.95 KB
apache_conf.py	2.72 KB
apache_module.py	2.73 KB
apache_site.py	2.66 KB
aptpkg.py	1.42 KB
archive.py	68.24 KB
artifactory.py	6.84 KB
at.py	7.48 KB
augeas.py	10.57 KB
aws_sqs.py	2.59 KB
azurearm_compute.py	11.78 KB
azurearm_dns.py	26.05 KB
azurearm_network.py	89.12 KB
azurearm_resource.py	28.23 KB
beacon.py	7.58 KB
bigip.py	96.63 KB
blockdev.py	5.13 KB
boto3_elasticache.py	48.01 KB
boto3_elasticsearch.py	32.58 KB
boto3_route53.py	37.54 KB
boto3_sns.py	12.69 KB
boto_apigateway.py	82.83 KB
boto_asg.py	31.93 KB
boto_cfn.py	11.53 KB
boto_cloudfront.py	6.01 KB
boto_cloudtrail.py	13.18 KB
boto_cloudwatch_alarm.py	6.4 KB
boto_cloudwatch_event.py	12.33 KB
boto_cognitoidentity.py	13.69 KB
boto_datapipeline.py	18.5 KB
boto_dynamodb.py	29.32 KB
boto_ec2.py	71.98 KB
boto_elasticache.py	16.75 KB
boto_elasticsearch_domain.py	12.27 KB
boto_elb.py	55.1 KB
boto_elbv2.py	12.19 KB
boto_iam.py	69.16 KB
boto_iam_role.py	27.12 KB
boto_iot.py	25.33 KB
boto_kinesis.py	16.69 KB
boto_kms.py	12.11 KB
boto_lambda.py	35.52 KB
boto_lc.py	11.04 KB
boto_rds.py	26 KB
boto_route53.py	19.49 KB
boto_s3.py	9.32 KB
boto_s3_bucket.py	24.67 KB
boto_secgroup.py	32.62 KB
boto_sns.py	8.92 KB
boto_sqs.py	7.97 KB
boto_vpc.py	62.23 KB
bower.py	8.26 KB
btrfs.py	10.34 KB
cabal.py	5.73 KB
ceph.py	1.9 KB
chef.py	3.76 KB
chocolatey.py	16.15 KB
chronos_job.py	4.6 KB
cimc.py	14.32 KB
cisconso.py	3.14 KB
cloud.py	14.4 KB
cmd.py	40.92 KB
composer.py	8.38 KB
consul.py	5.4 KB
cron.py	23.39 KB
cryptdev.py	6.17 KB
csf.py	9.98 KB
cyg.py	7.05 KB
ddns.py	4.2 KB
debconfmod.py	6.33 KB
dellchassis.py	24.49 KB
disk.py	6.49 KB
docker_container.py	85.27 KB
docker_image.py	16.7 KB
docker_network.py	36.78 KB
docker_volume.py	6.72 KB
drac.py	4.17 KB
dvs.py	26.29 KB
elasticsearch.py	20.38 KB
elasticsearch_index.py	3.25 KB
elasticsearch_index_template.py	3.67 KB
environ.py	5.81 KB
eselect.py	2.27 KB
esxcluster.py	22.4 KB
esxdatacenter.py	4.44 KB
esxi.py	63.07 KB
esxvm.py	20.11 KB
etcd_mod.py	11 KB
ethtool.py	9.88 KB
event.py	2.48 KB
file.py	316.7 KB
firewall.py	1.33 KB
firewalld.py	26.08 KB
gem.py	7.13 KB
git.py	123.85 KB
github.py	27.25 KB
glance_image.py	2.26 KB
glassfish.py	21.47 KB
glusterfs.py	12.21 KB
gnomedesktop.py	7.47 KB
gpg.py	5.28 KB
grafana.py	12.11 KB
grafana4_dashboard.py	17.31 KB
grafana4_datasource.py	6.15 KB
grafana4_org.py	7.73 KB
grafana4_user.py	5.52 KB
grafana_dashboard.py	17.74 KB
grafana_datasource.py	5.31 KB
grains.py	15.57 KB
group.py	9.84 KB
heat.py	9.69 KB
helm.py	10.39 KB
hg.py	6.33 KB
highstate_doc.py	1.41 KB
host.py	8.64 KB
http.py	7.46 KB
icinga2.py	9.07 KB
idem.py	3.91 KB
ifttt.py	2.12 KB
incron.py	5.71 KB
influxdb08_database.py	2.85 KB
influxdb08_user.py	3.39 KB
influxdb_continuous_query.py	2.83 KB
influxdb_database.py	2.11 KB
influxdb_retention_policy.py	4.82 KB
influxdb_user.py	4.84 KB
infoblox_a.py	4.24 KB
infoblox_cname.py	4.19 KB
infoblox_host_record.py	6.59 KB
infoblox_range.py	6.85 KB
ini_manage.py	12.67 KB
ipmi.py	8.42 KB
ipset.py	9.66 KB
iptables.py	27.65 KB
jboss7.py	23.95 KB
jenkins.py	3.36 KB
junos.py	17.78 KB
kapacitor.py	6.46 KB
kernelpkg.py	6.42 KB
keyboard.py	2.01 KB
keystone.py	27.12 KB
keystone_domain.py	2.81 KB
keystone_endpoint.py	4.69 KB
keystone_group.py	3.25 KB
keystone_project.py	3.36 KB
keystone_role.py	2.33 KB
keystone_role_grant.py	4.08 KB
keystone_service.py	2.89 KB
keystone_user.py	3.47 KB
keystore.py	5.67 KB
kmod.py	8.59 KB
kubernetes.py	24.87 KB
layman.py	2.44 KB
ldap.py	19.78 KB
libcloud_dns.py	5.7 KB
libcloud_loadbalancer.py	5.66 KB
libcloud_storage.py	5.13 KB
linux_acl.py	24.42 KB
locale.py	2.52 KB
logadm.py	4.67 KB
logrotate.py	3.86 KB
loop.py	7.74 KB
lvm.py	13.33 KB
lvs_server.py	6.28 KB
lvs_service.py	4.38 KB
lxc.py	22.17 KB
lxd.py	7.88 KB
lxd_container.py	22.25 KB
lxd_image.py	10.59 KB
lxd_profile.py	7.11 KB
mac_assistive.py	1.55 KB
mac_keychain.py	5.59 KB
mac_xattr.py	3.15 KB
macdefaults.py	2.65 KB
macpackage.py	6.76 KB
makeconf.py	6.87 KB
marathon_app.py	4.45 KB
mdadm_raid.py	6.41 KB
memcached.py	3.95 KB
modjk.py	2.84 KB
modjk_worker.py	6.49 KB
module.py	18.64 KB
mongodb_database.py	1.65 KB
mongodb_user.py	6.26 KB
monit.py	2.68 KB
mount.py	50.32 KB
mssql_database.py	3 KB
mssql_login.py	3.64 KB
mssql_role.py	2.37 KB
mssql_user.py	3.51 KB
msteams.py	2.53 KB
mysql_database.py	6.05 KB
mysql_grants.py	8.49 KB
mysql_query.py	13.07 KB
mysql_user.py	9.51 KB
net_napalm_yang.py	9.15 KB
netacl.py	31.92 KB
netconfig.py	33.42 KB
netntp.py	12.51 KB
netsnmp.py	11.33 KB
netusers.py	16.1 KB
network.py	23.97 KB
neutron_network.py	3.96 KB
neutron_secgroup.py	4 KB
neutron_secgroup_rule.py	4.75 KB
neutron_subnet.py	4.29 KB
nexus.py	4.97 KB
nfs_export.py	4.92 KB
nftables.py	19.5 KB
npm.py	11.21 KB
ntp.py	2.12 KB
nxos.py	10.37 KB
nxos_upgrade.py	3.5 KB
openstack_config.py	3.26 KB
openvswitch_bridge.py	4.36 KB
openvswitch_db.py	2.24 KB
openvswitch_port.py	17.24 KB
opsgenie.py	4.07 KB
pagerduty.py	1.89 KB
pagerduty_escalation_policy.py	5.42 KB
pagerduty_schedule.py	6.09 KB
pagerduty_service.py	3.93 KB
pagerduty_user.py	1.18 KB
panos.py	48.13 KB
pbm.py	20.46 KB
pcs.py	36.46 KB
pdbedit.py	3.43 KB
pecl.py	3.65 KB
pip_state.py	38.55 KB
pkg.py	138.08 KB
pkgbuild.py	11.37 KB
pkgng.py	685 B
pkgrepo.py	27.53 KB
portage_config.py	5.01 KB
ports.py	5.65 KB
postgres_cluster.py	4.19 KB
postgres_database.py	6.08 KB
postgres_extension.py	5.68 KB
postgres_group.py	8.52 KB
postgres_initdb.py	2.84 KB
postgres_language.py	3.94 KB
postgres_privileges.py	7.86 KB
postgres_schema.py	4.34 KB
postgres_tablespace.py	6.62 KB
postgres_user.py	9.49 KB
powerpath.py	2.34 KB
probes.py	15.06 KB
process.py	1.32 KB
proxy.py	4.94 KB
pushover.py	3.13 KB
pyenv.py	6.07 KB
pyrax_queues.py	2.97 KB
quota.py	1.4 KB
rabbitmq_cluster.py	1.84 KB
rabbitmq_plugin.py	2.77 KB
rabbitmq_policy.py	4.59 KB
rabbitmq_upstream.py	7.9 KB
rabbitmq_user.py	8.89 KB
rabbitmq_vhost.py	3.04 KB
rbac_solaris.py	6.67 KB
rbenv.py	7.36 KB
rdp.py	1.28 KB
redismod.py	4.76 KB
reg.py	19.22 KB
restconf.py	6.41 KB
rsync.py	4.45 KB
rvm.py	6.56 KB
salt_proxy.py	1.34 KB
saltmod.py	33.12 KB
saltutil.py	8.91 KB
schedule.py	12.47 KB
selinux.py	18.61 KB
serverdensity_device.py	6.41 KB
service.py	37.89 KB
slack.py	4.98 KB
smartos.py	44.83 KB
smtp.py	2.3 KB
snapper.py	7.24 KB
solrcloud.py	4.48 KB
splunk.py	4.32 KB
splunk_search.py	3.17 KB
sqlite3.py	14.7 KB
ssh_auth.py	19.57 KB
ssh_known_hosts.py	7.92 KB
stateconf.py	494 B
status.py	2.21 KB
statuspage.py	17.29 KB
supervisord.py	10.48 KB
svn.py	8.14 KB
sysctl.py	4.11 KB
sysfs.py	2.13 KB
syslog_ng.py	2.97 KB
sysrc.py	2.82 KB
telemetry_alert.py	7.04 KB
test.py	13.09 KB
testinframod.py	1.35 KB
timezone.py	3.42 KB
tls.py	1.81 KB
tomcat.py	9.72 KB
trafficserver.py	8.82 KB
tuned.py	3.32 KB
uptime.py	1.87 KB
user.py	38.63 KB
vagrant.py	11.4 KB
vault.py	3.28 KB
vbox_guest.py	4.05 KB
victorops.py	3.32 KB
virt.py	80.41 KB
virtualenv_mod.py	11.21 KB
webutil.py	3.89 KB
win_certutil.py	4.8 KB
win_dacl.py	7.96 KB
win_dism.py	14.97 KB
win_dns_client.py	8.32 KB
win_firewall.py	6.87 KB
win_iis.py	31.56 KB
win_lgpo.py	24.99 KB
win_lgpo_reg.py	10.96 KB
win_license.py	1.6 KB
win_network.py	14.18 KB
win_path.py	6.39 KB
win_pki.py	5.56 KB
win_powercfg.py	3.79 KB
win_servermanager.py	10.4 KB
win_shortcut.py	7.81 KB
win_smtp_server.py	10.01 KB
win_snmp.py	6.64 KB
win_system.py	13.78 KB
win_wua.py	16.27 KB
win_wusa.py	3.53 KB
winrepo.py	2.74 KB
wordpress.py	4.82 KB
x509.py	27.86 KB
x509_v2.py	64.78 KB
xml.py	1.75 KB
xmpp.py	2.61 KB
zabbix_action.py	9.35 KB
zabbix_host.py	27.25 KB
zabbix_hostgroup.py	5.64 KB
zabbix_mediatype.py	16.89 KB
zabbix_template.py	35.14 KB
zabbix_user.py	17.6 KB
zabbix_usergroup.py	9.64 KB
zabbix_usermacro.py	9.69 KB
zabbix_valuemap.py	8.11 KB
zcbuildout.py	5.16 KB
zenoss.py	2.89 KB
zfs.py	34.48 KB
zk_concurrency.py	5.81 KB
zone.py	46.48 KB
zookeeper.py	11.55 KB
zpool.py	13.4 KB

Edit: zfs.py

"""
States for managing zfs datasets

:maintainer:    Jorge Schrauwen <sjorge@blackdot.be>
:maturity:      new
:depends:       salt.utils.zfs, salt.modules.zfs
:platform:      smartos, illumos, solaris, freebsd, linux

.. versionadded:: 2016.3.0
.. versionchanged:: 2018.3.1
  Big refactor to remove duplicate code, better type conversions and improved
  consistency in output.

.. code-block:: yaml

test/shares/yuki:
      zfs.filesystem_present:
        - create_parent: true
        - properties:
            quota: 16G

test/iscsi/haruhi:
      zfs.volume_present:
        - create_parent: true
        - volume_size: 16M
        - sparse: true
        - properties:
            readonly: on

test/shares/yuki@frozen:
      zfs.snapshot_present

moka_origin:
      zfs.hold_present:
        - snapshot: test/shares/yuki@frozen

test/shares/moka:
      zfs.filesystem_present:
        - cloned_from: test/shares/yuki@frozen

test/shares/moka@tsukune:
      zfs.snapshot_absent

"""

import logging
from datetime import datetime

from salt.utils.odict import OrderedDict

log = logging.getLogger(__name__)

# Define the state's virtual name
__virtualname__ = "zfs"

# Compare modifiers for zfs.schedule_snapshot
comp_hour = {"minute": 0}
comp_day = {"minute": 0, "hour": 0}
comp_month = {"minute": 0, "hour": 0, "day": 1}
comp_year = {"minute": 0, "hour": 0, "day": 1, "month": 1}

def __virtual__():
    """
    Provides zfs state
    """
    if not __grains__.get("zfs_support"):
        return False, "The zfs state cannot be loaded: zfs not supported"
    return __virtualname__

def _absent(name, dataset_type, force=False, recursive=False):
    """
    internal shared function for *_absent

name : string
        name of dataset
    dataset_type : string [filesystem, volume, snapshot, or bookmark]
        type of dataset to remove
    force : boolean
        try harder to destroy the dataset
    recursive : boolean
        also destroy all the child datasets

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## log configuration
    dataset_type = dataset_type.lower()
    log.debug("zfs.%s_absent::%s::config::force = %s", dataset_type, name, force)
    log.debug(
        "zfs.%s_absent::%s::config::recursive = %s", dataset_type, name, recursive
    )

## destroy dataset if needed
    if __salt__["zfs.exists"](name, **{"type": dataset_type}):
        ## NOTE: dataset found with the name and dataset_type
        if not __opts__["test"]:
            mod_res = __salt__["zfs.destroy"](
                name, **{"force": force, "recursive": recursive}
            )
        else:
            mod_res = OrderedDict([("destroyed", True)])

ret["result"] = mod_res["destroyed"]
        if ret["result"]:
            ret["changes"][name] = "destroyed"
            ret["comment"] = "{} {} was destroyed".format(
                dataset_type,
                name,
            )
        else:
            ret["comment"] = "failed to destroy {} {}".format(
                dataset_type,
                name,
            )
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]
    else:
        ## NOTE: no dataset found with name of the dataset_type
        ret["comment"] = "{} {} is absent".format(dataset_type, name)

return ret

def filesystem_absent(name, force=False, recursive=False):
    """
    ensure filesystem is absent on the system

name : string
        name of filesystem
    force : boolean
        try harder to destroy the dataset (zfs destroy -f)
    recursive : boolean
        also destroy all the child datasets (zfs destroy -r)

.. warning::

If a volume with ``name`` exists, this state will succeed without
        destroying the volume specified by ``name``. This module is dataset type sensitive.

"""
    if not __utils__["zfs.is_dataset"](name):
        ret = {
            "name": name,
            "changes": {},
            "result": False,
            "comment": "invalid dataset name: {}".format(name),
        }
    else:
        ret = _absent(name, "filesystem", force, recursive)
    return ret

def volume_absent(name, force=False, recursive=False):
    """
    ensure volume is absent on the system

name : string
        name of volume
    force : boolean
        try harder to destroy the dataset (zfs destroy -f)
    recursive : boolean
        also destroy all the child datasets (zfs destroy -r)

.. warning::

If a filesystem with ``name`` exists, this state will succeed without
        destroying the filesystem specified by ``name``. This module is dataset type sensitive.

def snapshot_absent(name, force=False, recursive=False):
    """
    ensure snapshot is absent on the system

name : string
        name of snapshot
    force : boolean
        try harder to destroy the dataset (zfs destroy -f)
    recursive : boolean
        also destroy all the child datasets (zfs destroy -r)

"""
    if not __utils__["zfs.is_snapshot"](name):
        ret = {
            "name": name,
            "changes": {},
            "result": False,
            "comment": "invalid snapshot name: {}".format(name),
        }
    else:
        ret = _absent(name, "snapshot", force, recursive)
    return ret

def bookmark_absent(name, force=False, recursive=False):
    """
    ensure bookmark is absent on the system

"""
    if not __utils__["zfs.is_bookmark"](name):
        ret = {
            "name": name,
            "changes": {},
            "result": False,
            "comment": "invalid bookmark name: {}".format(name),
        }
    else:
        ret = _absent(name, "bookmark", force, recursive)
    return ret

def hold_absent(name, snapshot, recursive=False):
    """
    ensure hold is absent on the system

name : string
        name of hold
    snapshot : string
        name of snapshot
    recursive : boolean
        recursively releases a hold with the given tag on the snapshots of all descendent file systems.

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## log configuration
    log.debug("zfs.hold_absent::%s::config::snapshot = %s", name, snapshot)
    log.debug("zfs.hold_absent::%s::config::recursive = %s", name, recursive)

## check we have a snapshot/tag name
    if not __utils__["zfs.is_snapshot"](snapshot):
        ret["result"] = False
        ret["comment"] = "invalid snapshot name: {}".format(snapshot)
        return ret

if (
        __utils__["zfs.is_snapshot"](name)
        or __utils__["zfs.is_bookmark"](name)
        or name == "error"
    ):
        ret["result"] = False
        ret["comment"] = "invalid tag name: {}".format(name)
        return ret

## release hold if required
    holds = __salt__["zfs.holds"](snapshot)
    if name in holds:
        ## NOTE: hold found for snapshot, release it
        if not __opts__["test"]:
            mod_res = __salt__["zfs.release"](
                name, snapshot, **{"recursive": recursive}
            )
        else:
            mod_res = OrderedDict([("released", True)])

ret["result"] = mod_res["released"]
        if ret["result"]:
            ret["changes"] = {snapshot: {name: "released"}}
            ret["comment"] = "hold {} released".format(
                name,
            )
        else:
            ret["comment"] = "failed to release hold {}".format(
                name,
            )
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]
    elif "error" in holds:
        ## NOTE: we have an error
        ret["result"] = False
        ret["comment"] = holds["error"]
    else:
        ## NOTE: no hold found with name for snapshot
        ret["comment"] = "hold {} is absent".format(
            name,
        )

return ret

def hold_present(name, snapshot, recursive=False):
    """
    ensure hold is present on the system

name : string
        name of holdt
    snapshot : string
        name of snapshot
    recursive : boolean
        recursively add hold with the given tag on the snapshots of all descendent file systems.

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## log configuration
    log.debug("zfs.hold_present::%s::config::snapshot = %s", name, snapshot)
    log.debug("zfs.hold_present::%s::config::recursive = %s", name, recursive)

## place hold if required
    holds = __salt__["zfs.holds"](snapshot)
    if name in holds:
        ## NOTE: hold with name already exists for snapshot
        ret["comment"] = "hold {} is present for {}".format(
            name,
            snapshot,
        )
    else:
        ## NOTE: no hold found with name for snapshot
        if not __opts__["test"]:
            mod_res = __salt__["zfs.hold"](name, snapshot, **{"recursive": recursive})
        else:
            mod_res = OrderedDict([("held", True)])

ret["result"] = mod_res["held"]
        if ret["result"]:
            ret["changes"] = OrderedDict([(snapshot, OrderedDict([(name, "held")]))])
            ret["comment"] = "hold {} added to {}".format(name, snapshot)
        else:
            ret["comment"] = "failed to add hold {} to {}".format(name, snapshot)
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]

return ret

def _dataset_present(
    dataset_type,
    name,
    properties,
    volume_size=None,
    sparse=False,
    create_parent=False,
    cloned_from=None,
):
    """
    internal handler for filesystem_present/volume_present

dataset_type : string
        volume or filesystem
    name : string
        name of volume
    volume_size : string
        size of volume
    sparse : boolean
        create sparse volume
    create_parent : boolean
        creates all the non-existing parent datasets.
        any property specified on the command line using the -o option is ignored.
    cloned_from : string
        name of snapshot to clone
    properties : dict
        additional zfs properties (-o)

.. note::
        ``cloned_from`` is only use if the volume does not exist yet,
        when ``cloned_from`` is set after the volume exists it will be ignored.

.. note::
        Properties do not get cloned, if you specify the properties in the state file
        they will be applied on a subsequent run.

``volume_size`` is considered a property, so the volume's size will be
        corrected when the properties get updated if it differs from the
        original volume.

The sparse parameter is ignored when using ``cloned_from``.

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## fallback dataset_type to filesystem if out of range
    if dataset_type not in ["filesystem", "volume"]:
        dataset_type = "filesystem"

## ensure properties are zfs values
    if properties is None:
        properties = {}
    properties = __utils__["zfs.from_auto_dict"](properties)
    if volume_size:
        ## NOTE: add volsize to properties
        volume_size = __utils__["zfs.from_size"](volume_size)
        properties.update({"volsize": volume_size})
    # The sorted isn't necessary for proper behavior, but it helps for the unit
    # tests.
    propnames = ",".join(sorted(properties.keys()))

## log configuration
    log.debug(
        "zfs.%s_present::%s::config::volume_size = %s", dataset_type, name, volume_size
    )
    log.debug("zfs.%s_present::%s::config::sparse = %s", dataset_type, name, sparse)
    log.debug(
        "zfs.%s_present::%s::config::create_parent = %s",
        dataset_type,
        name,
        create_parent,
    )
    log.debug(
        "zfs.%s_present::%s::config::cloned_from = %s", dataset_type, name, cloned_from
    )
    log.debug(
        "zfs.%s_present::%s::config::properties = %s", dataset_type, name, properties
    )

## check we have valid filesystem name/volume name/clone snapshot
    if not __utils__["zfs.is_dataset"](name):
        ret["result"] = False
        ret["comment"] = "invalid dataset name: {}".format(name)
        return ret

if cloned_from and not __utils__["zfs.is_snapshot"](cloned_from):
        ret["result"] = False
        ret["comment"] = "{} is not a snapshot".format(cloned_from)
        return ret

## ensure dataset is in correct state
    ## NOTE: update the dataset
    exists = __salt__["zfs.exists"](name, **{"type": dataset_type})
    if exists and len(properties) == 0:
        ret["comment"] = "{} {} is uptodate".format(dataset_type, name)
    elif exists and len(properties) > 0:
        ## NOTE: fetch current volume properties
        properties_current = __salt__["zfs.get"](
            name,
            properties=propnames,
            type=dataset_type,
            fields="value",
            depth=0,
            parsable=True,
        ).get(name, OrderedDict())

## NOTE: build list of properties to update
        properties_update = []
        for prop in properties:
            ## NOTE: skip unexisting properties
            if prop not in properties_current:
                log.warning(
                    "zfs.%s_present::%s::update - unknown property: %s",
                    dataset_type,
                    name,
                    prop,
                )
                continue

## NOTE: compare current and wanted value
            if properties_current[prop]["value"] != properties[prop]:
                properties_update.append(prop)

## NOTE: update pool properties
        for prop in properties_update:
            if not __opts__["test"]:
                mod_res = __salt__["zfs.set"](name, **{prop: properties[prop]})
            else:
                mod_res = OrderedDict([("set", True)])

if mod_res["set"]:
                if name not in ret["changes"]:
                    ret["changes"][name] = {}
                ret["changes"][name][prop] = properties[prop]
            else:
                ret["result"] = False
                if ret["comment"] == "":
                    ret["comment"] = "The following properties were not updated:"
                ret["comment"] = "{} {}".format(ret["comment"], prop)

## NOTE: update comment
        if ret["result"] and name in ret["changes"]:
            ret["comment"] = "{} {} was updated".format(dataset_type, name)
        elif ret["result"]:
            ret["comment"] = "{} {} is uptodate".format(dataset_type, name)
        else:
            ret["comment"] = "{} {} failed to be updated".format(dataset_type, name)

## NOTE: create or clone the dataset
    elif not exists:
        mod_res_action = "cloned" if cloned_from else "created"
        if __opts__["test"]:
            ## NOTE: pretend to create/clone
            mod_res = OrderedDict([(mod_res_action, True)])
        elif cloned_from:
            ## NOTE: add volsize to properties
            if volume_size:
                properties["volsize"] = volume_size

## NOTE: clone the dataset
            mod_res = __salt__["zfs.clone"](
                cloned_from,
                name,
                **{"create_parent": create_parent, "properties": properties}
            )
        else:
            ## NOTE: create the dataset
            mod_res = __salt__["zfs.create"](
                name,
                **{
                    "create_parent": create_parent,
                    "properties": properties,
                    "volume_size": volume_size,
                    "sparse": sparse,
                }
            )

ret["result"] = mod_res[mod_res_action]
        if ret["result"]:
            ret["changes"][name] = mod_res_action
            if properties:
                ret["changes"][name] = properties
            ret["comment"] = "{} {} was {}".format(
                dataset_type,
                name,
                mod_res_action,
            )
        else:
            ret["comment"] = "failed to {} {} {}".format(
                mod_res_action[:-1],
                dataset_type,
                name,
            )
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]

return ret

def filesystem_present(name, create_parent=False, properties=None, cloned_from=None):
    """
    ensure filesystem exists and has properties set

name : string
        name of filesystem
    create_parent : boolean
        creates all the non-existing parent datasets.
        any property specified on the command line using the -o option is ignored.
    cloned_from : string
        name of snapshot to clone
    properties : dict
        additional zfs properties (-o)

.. note::
        ``cloned_from`` is only use if the filesystem does not exist yet,
        when ``cloned_from`` is set after the filesystem exists it will be ignored.

.. note::
        Properties do not get cloned, if you specify the properties in the
        state file they will be applied on a subsequent run.

"""
    return _dataset_present(
        "filesystem",
        name,
        properties,
        create_parent=create_parent,
        cloned_from=cloned_from,
    )

def volume_present(
    name,
    volume_size,
    sparse=False,
    create_parent=False,
    properties=None,
    cloned_from=None,
):
    """
    ensure volume exists and has properties set

name : string
        name of volume
    volume_size : string
        size of volume
    sparse : boolean
        create sparse volume
    create_parent : boolean
        creates all the non-existing parent datasets.
        any property specified on the command line using the -o option is ignored.
    cloned_from : string
        name of snapshot to clone
    properties : dict
        additional zfs properties (-o)

.. note::
        ``cloned_from`` is only use if the volume does not exist yet,
        when ``cloned_from`` is set after the volume exists it will be ignored.

.. note::
        Properties do not get cloned, if you specify the properties in the state file
        they will be applied on a subsequent run.

``volume_size`` is considered a property, so the volume's size will be
        corrected when the properties get updated if it differs from the
        original volume.

The sparse parameter is ignored when using ``cloned_from``.

"""
    return _dataset_present(
        "volume",
        name,
        properties,
        volume_size,
        sparse=sparse,
        create_parent=create_parent,
        cloned_from=cloned_from,
    )

def bookmark_present(name, snapshot):
    """
    ensure bookmark exists

name : string
        name of bookmark
    snapshot : string
        name of snapshot

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## log configuration
    log.debug("zfs.bookmark_present::%s::config::snapshot = %s", name, snapshot)

## check we have valid snapshot/bookmark name
    if not __utils__["zfs.is_snapshot"](snapshot):
        ret["result"] = False
        ret["comment"] = "invalid snapshot name: {}".format(name)
        return ret

if "#" not in name and "/" not in name:
        ## NOTE: simple snapshot name
        #        take the snapshot name and replace the snapshot but with the simple name
        #        e.g. pool/fs@snap + bm --> pool/fs#bm
        name = "{}#{}".format(snapshot[: snapshot.index("@")], name)
        ret["name"] = name

if not __utils__["zfs.is_bookmark"](name):
        ret["result"] = False
        ret["comment"] = "invalid bookmark name: {}".format(name)
        return ret

## ensure bookmark exists
    if not __salt__["zfs.exists"](name, **{"type": "bookmark"}):
        ## NOTE: bookmark the snapshot
        if not __opts__["test"]:
            mod_res = __salt__["zfs.bookmark"](snapshot, name)
        else:
            mod_res = OrderedDict([("bookmarked", True)])

ret["result"] = mod_res["bookmarked"]
        if ret["result"]:
            ret["changes"][name] = snapshot
            ret["comment"] = "{} bookmarked as {}".format(snapshot, name)
        else:
            ret["comment"] = "failed to bookmark {}".format(snapshot)
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]
    else:
        ## NOTE: bookmark already exists
        ret["comment"] = "bookmark is present"

return ret

def snapshot_present(name, recursive=False, properties=None):
    """
    ensure snapshot exists and has properties set

name : string
        name of snapshot
    recursive : boolean
        recursively create snapshots of all descendent datasets
    properties : dict
        additional zfs properties (-o)

.. note:
        Properties are only set at creation time

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## log configuration
    log.debug("zfs.snapshot_present::%s::config::recursive = %s", name, recursive)
    log.debug("zfs.snapshot_present::%s::config::properties = %s", name, properties)

## ensure properties are zfs values
    if properties:
        properties = __utils__["zfs.from_auto_dict"](properties)

## check we have valid snapshot name
    if not __utils__["zfs.is_snapshot"](name):
        ret["result"] = False
        ret["comment"] = "invalid snapshot name: {}".format(name)
        return ret

## ensure snapshot exits
    if not __salt__["zfs.exists"](name, **{"type": "snapshot"}):
        ## NOTE: create the snapshot
        if not __opts__["test"]:
            mod_res = __salt__["zfs.snapshot"](
                name, **{"recursive": recursive, "properties": properties}
            )
        else:
            mod_res = OrderedDict([("snapshotted", True)])

ret["result"] = mod_res["snapshotted"]
        if ret["result"]:
            ret["changes"][name] = "snapshotted"
            if properties:
                ret["changes"][name] = properties
            ret["comment"] = "snapshot {} was created".format(name)
        else:
            ret["comment"] = "failed to create snapshot {}".format(name)
            if "error" in mod_res:
                ret["comment"] = mod_res["error"]
    else:
        ## NOTE: snapshot already exists
        ret["comment"] = "snapshot is present"

return ret

def promoted(name):
    """
    ensure a dataset is not a clone

name : string
        name of fileset or volume

.. warning::

only one dataset can be the origin,
        if you promote a clone the original will now point to the promoted dataset

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## check we if we have a valid dataset name
    if not __utils__["zfs.is_dataset"](name):
        ret["result"] = False
        ret["comment"] = "invalid dataset name: {}".format(name)
        return ret

## ensure dataset is the primary instance
    if not __salt__["zfs.exists"](name, **{"type": "filesystem,volume"}):
        ## NOTE: we don't have a dataset
        ret["result"] = False
        ret["comment"] = "dataset {} does not exist".format(name)
    else:
        ## NOTE: check if we have a blank origin (-)
        if (
            __salt__["zfs.get"](
                name, **{"properties": "origin", "fields": "value", "parsable": True}
            )[name]["origin"]["value"]
            == "-"
        ):
            ## NOTE: we're already promoted
            ret["comment"] = "{} already promoted".format(name)
        else:
            ## NOTE: promote dataset
            if not __opts__["test"]:
                mod_res = __salt__["zfs.promote"](name)
            else:
                mod_res = OrderedDict([("promoted", True)])

ret["result"] = mod_res["promoted"]
            if ret["result"]:
                ret["changes"][name] = "promoted"
                ret["comment"] = "{} promoted".format(name)
            else:
                ret["comment"] = "failed to promote {}".format(name)
                if "error" in mod_res:
                    ret["comment"] = mod_res["error"]

return ret

def _schedule_snapshot_retrieve(dataset, prefix, snapshots):
    """
    Update snapshots dict with current snapshots

dataset: string
        name of filesystem or volume
    prefix : string
        prefix for the snapshots
        e.g. 'test' will result in snapshots being named 'test-yyyymmdd_hhmm'
    snapshots : OrderedDict
        preseeded OrderedDict with configuration

"""
    ## NOTE: retrieve all snapshots for the dataset
    for snap in sorted(
        __salt__["zfs.list"](
            dataset, **{"recursive": True, "depth": 1, "type": "snapshot"}
        ).keys()
    ):
        ## NOTE: we only want the actualy name
        ##       myzpool/data@zbck-20171201_000248 -> zbck-20171201_000248
        snap_name = snap[snap.index("@") + 1 :]

## NOTE: we only want snapshots matching our prefix
        if not snap_name.startswith("{}-".format(prefix)):
            continue

## NOTE: retrieve the holds for this snapshot
        snap_holds = __salt__["zfs.holds"](snap)

## NOTE: this snapshot has no holds, eligable for pruning
        if not snap_holds:
            snapshots["_prunable"].append(snap)

## NOTE: update snapshots based on holds (if any)
        ##       we are only interested in the ones from our schedule
        ##       if we find any others we skip them
        for hold in snap_holds:
            if hold in snapshots["_schedule"].keys():
                snapshots[hold].append(snap)

return snapshots

def _schedule_snapshot_prepare(dataset, prefix, snapshots):
    """
    Update snapshots dict with info for a new snapshot

"""
    ## NOTE: generate new snapshot name
    snapshot_create_name = "{dataset}@{prefix}-{timestamp}".format(
        dataset=dataset,
        prefix=prefix,
        timestamp=datetime.now().strftime("%Y%m%d_%H%M%S"),
    )

## NOTE: figure out if we need to create the snapshot
    timestamp_now = datetime.now().replace(second=0, microsecond=0)
    snapshots["_create"][snapshot_create_name] = []
    for hold, hold_count in snapshots["_schedule"].items():
        ## NOTE: skip hold if we don't keep snapshots for it
        if hold_count == 0:
            continue

## NOTE: figure out if we need the current hold on the new snapshot
        if snapshots[hold]:
            ## NOTE: extract datetime from snapshot name
            timestamp = datetime.strptime(
                snapshots[hold][-1],
                "{}@{}-%Y%m%d_%H%M%S".format(dataset, prefix),
            ).replace(second=0, microsecond=0)

## NOTE: compare current timestamp to timestamp from snapshot
            if hold == "minute" and timestamp_now <= timestamp:
                continue
            elif hold == "hour" and timestamp_now.replace(
                **comp_hour
            ) <= timestamp.replace(**comp_hour):
                continue
            elif hold == "day" and timestamp_now.replace(
                **comp_day
            ) <= timestamp.replace(**comp_day):
                continue
            elif hold == "month" and timestamp_now.replace(
                **comp_month
            ) <= timestamp.replace(**comp_month):
                continue
            elif hold == "year" and timestamp_now.replace(
                **comp_year
            ) <= timestamp.replace(**comp_year):
                continue

## NOTE: add hold entry for snapshot
        snapshots["_create"][snapshot_create_name].append(hold)

return snapshots

def scheduled_snapshot(name, prefix, recursive=True, schedule=None):
    """
    maintain a set of snapshots based on a schedule

name : string
        name of filesystem or volume
    prefix : string
        prefix for the snapshots
        e.g. 'test' will result in snapshots being named 'test-yyyymmdd_hhmm'
    recursive : boolean
        create snapshots for all children also
    schedule : dict
        dict holding the schedule, the following keys are available (minute, hour,
        day, month, and year) by default all are set to 0 the value indicated the
        number of snapshots of that type to keep around.

.. warning::

snapshots will only be created and pruned every time the state runs.
        a schedule must be setup to automatically run the state. this means that if
        you run the state daily the hourly snapshot will only be made once per day!

.. versionchanged:: 2018.3.0

switched to localtime from gmtime so times now take into account timezones.

"""
    ret = {"name": name, "changes": {}, "result": True, "comment": ""}

## initialize defaults
    schedule_holds = ["minute", "hour", "day", "month", "year"]
    snapshots = OrderedDict(
        [("_create", OrderedDict()), ("_prunable", []), ("_schedule", OrderedDict())]
    )

## strict configuration validation
    ## NOTE: we need a valid dataset
    if not __utils__["zfs.is_dataset"](name):
        ret["result"] = False
        ret["comment"] = "invalid dataset name: {}".format(name)

if not __salt__["zfs.exists"](name, **{"type": "filesystem,volume"}):
        ret["comment"] = "dataset {} does not exist".format(name)
        ret["result"] = False

## NOTE: prefix must be 4 or longer
    if not prefix or len(prefix) < 4:
        ret["comment"] = "prefix ({}) must be at least 4 long".format(prefix)
        ret["result"] = False

## NOTE: validate schedule
    total_count = 0
    for hold in schedule_holds:
        snapshots[hold] = []
        if hold not in schedule:
            snapshots["_schedule"][hold] = 0
        elif isinstance(schedule[hold], int):
            snapshots["_schedule"][hold] = schedule[hold]
        else:
            ret["result"] = False
            ret["comment"] = "schedule value for {} is not an integer".format(
                hold,
            )
            break
        total_count += snapshots["_schedule"][hold]
    if ret["result"] and total_count == 0:
        ret["result"] = False
        ret["comment"] = "schedule is not valid, you need to keep atleast 1 snapshot"

## NOTE: return if configuration is not valid
    if not ret["result"]:
        return ret

## retrieve existing snapshots
    snapshots = _schedule_snapshot_retrieve(name, prefix, snapshots)

## prepare snapshot
    snapshots = _schedule_snapshot_prepare(name, prefix, snapshots)

## log configuration
    log.debug("zfs.scheduled_snapshot::%s::config::recursive = %s", name, recursive)
    log.debug("zfs.scheduled_snapshot::%s::config::prefix = %s", name, prefix)
    log.debug("zfs.scheduled_snapshot::%s::snapshots = %s", name, snapshots)

## create snapshot(s)
    for snapshot_name, snapshot_holds in snapshots["_create"].items():
        ## NOTE: skip if new snapshot has no holds
        if not snapshot_holds:
            continue

## NOTE: create snapshot
        if not __opts__["test"]:
            mod_res = __salt__["zfs.snapshot"](
                snapshot_name, **{"recursive": recursive}
            )
        else:
            mod_res = OrderedDict([("snapshotted", True)])

if not mod_res["snapshotted"]:
            ret["result"] = False
            ret["comment"] = "error creating snapshot ({})".format(snapshot_name)
        else:
            ## NOTE: create holds (if we have a snapshot)
            for hold in snapshot_holds:
                if not __opts__["test"]:
                    mod_res = __salt__["zfs.hold"](
                        hold, snapshot_name, **{"recursive": recursive}
                    )
                else:
                    mod_res = OrderedDict([("held", True)])

if not mod_res["held"]:
                    ret["result"] = False
                    ret["comment"] = "error adding hold ({}) to snapshot ({})".format(
                        hold,
                        snapshot_name,
                    )
                    break

snapshots[hold].append(snapshot_name)

if ret["result"]:
            ret["comment"] = "scheduled snapshots updated"
            if "created" not in ret["changes"]:
                ret["changes"]["created"] = []
            ret["changes"]["created"].append(snapshot_name)

## prune hold(s)
    for hold, hold_count in snapshots["_schedule"].items():
        while ret["result"] and len(snapshots[hold]) > hold_count:
            ## NOTE: pop oldest snapshot
            snapshot_name = snapshots[hold].pop(0)

## NOTE: release hold for snapshot
            if not __opts__["test"]:
                mod_res = __salt__["zfs.release"](
                    hold, snapshot_name, **{"recursive": recursive}
                )
            else:
                mod_res = OrderedDict([("released", True)])

if not mod_res["released"]:
                ret["result"] = False
                ret["comment"] = "error adding hold ({}) to snapshot ({})".format(
                    hold,
                    snapshot_name,
                )

## NOTE: mark as prunable
            if not __salt__["zfs.holds"](snapshot_name):
                snapshots["_prunable"].append(snapshot_name)

## prune snapshot(s)
    for snapshot_name in snapshots["_prunable"]:
        ## NOTE: destroy snapshot
        if not __opts__["test"]:
            mod_res = __salt__["zfs.destroy"](snapshot_name, **{"recursive": recursive})
        else:
            mod_res = OrderedDict([("destroyed", True)])

if not mod_res["destroyed"]:
            ret["result"] = False
            ret["comment"] = "error prunding snapshot ({1})".format(
                snapshot_name,
            )
            break

if ret["result"] and snapshots["_prunable"]:
        ret["comment"] = "scheduled snapshots updated"
        ret["changes"]["pruned"] = snapshots["_prunable"]

if ret["result"] and not ret["changes"]:
        ret["comment"] = "scheduled snapshots are up to date"

return ret