"""
Module for running ZFS command

:codeauthor:    Nitin Madhok <nmadhok@g.clemson.edu>, Jorge Schrauwen <sjorge@blackdot.be>
:maintainer:    Jorge Schrauwen <sjorge@blackdot.be>
:maturity:      new
:depends:       salt.utils.zfs
:platform:      illumos,freebsd,linux

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

"""

import logging
from collections import OrderedDict

import salt.modules.cmdmod
import salt.utils.args
import salt.utils.path
import salt.utils.platform
import salt.utils.versions

__virtualname__ = "zfs"
log = logging.getLogger(__name__)

# Function alias to set mapping.
__func_alias__ = {
    "list_": "list",
}


def __virtual__():
    """
    Only load when the platform has zfs support
    """
    if __grains__.get("zfs_support"):
        return __virtualname__
    else:
        return False, "The zfs module cannot be loaded: zfs not supported"


def exists(name, **kwargs):
    """
    Check if a ZFS filesystem or volume or snapshot exists.

    name : string
        name of dataset
    type : string
        also check if dataset is of a certain type, valid choices are:
        filesystem, snapshot, volume, bookmark, or all.

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.exists myzpool/mydataset
        salt '*' zfs.exists myzpool/myvolume type=volume

    """
    ## Configure command
    # NOTE: initialize the defaults
    opts = {}

    # NOTE: set extra config from kwargs
    if kwargs.get("type", False):
        opts["-t"] = kwargs.get("type")

    ## Check if 'name' of 'type' exists
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="list",
            opts=opts,
            target=name,
        ),
        python_shell=False,
        ignore_retcode=True,
    )

    return res["retcode"] == 0


def create(name, **kwargs):
    """
    Create a ZFS File System.

    name : string
        name of dataset or volume
    volume_size : string
        if specified, a zvol will be created instead of a dataset
    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.
    properties : dict
        additional zfs properties (-o)

    .. note::

        ZFS properties can be specified at the time of creation of the filesystem by
        passing an additional argument called "properties" and specifying the properties
        with their respective values in the form of a python dictionary::

            properties="{'property1': 'value1', 'property2': 'value2'}"

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.create myzpool/mydataset [create_parent=True|False]
        salt '*' zfs.create myzpool/mydataset properties="{'mountpoint': '/export/zfs', 'sharenfs': 'on'}"
        salt '*' zfs.create myzpool/volume volume_size=1G [sparse=True|False]`
        salt '*' zfs.create myzpool/volume volume_size=1G properties="{'volblocksize': '512'}" [sparse=True|False]

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    opts = {}

    # NOTE: push filesystem properties
    filesystem_properties = kwargs.get("properties", {})

    # NOTE: set extra config from kwargs
    if kwargs.get("create_parent", False):
        flags.append("-p")
    if kwargs.get("sparse", False) and kwargs.get("volume_size", None):
        flags.append("-s")
    if kwargs.get("volume_size", None):
        opts["-V"] = __utils__["zfs.to_size"](
            kwargs.get("volume_size"), convert_to_human=False
        )

    ## Create filesystem/volume
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="create",
            flags=flags,
            opts=opts,
            filesystem_properties=filesystem_properties,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "created")


def destroy(name, **kwargs):
    """
    Destroy a ZFS File System.

    name : string
        name of dataset, volume, or snapshot
    force : boolean
        force an unmount of any file systems using the unmount -f command.
    recursive : boolean
        recursively destroy all children. (-r)
    recursive_all : boolean
        recursively destroy all dependents, including cloned file systems
        outside the target hierarchy. (-R)

    .. warning::
        watch out when using recursive and recursive_all

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.destroy myzpool/mydataset [force=True|False]

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []

    # NOTE: set extra config from kwargs
    if kwargs.get("force", False):
        flags.append("-f")
    if kwargs.get("recursive_all", False):
        flags.append("-R")
    if kwargs.get("recursive", False):
        flags.append("-r")

    ## Destroy filesystem/volume/snapshot/...
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="destroy",
            flags=flags,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "destroyed")


def rename(name, new_name, **kwargs):
    """
    Rename or Relocate a ZFS File System.

    name : string
        name of dataset, volume, or snapshot
    new_name : string
        new name of dataset, volume, or snapshot
    force : boolean
        force unmount any filesystems that need to be unmounted in the process.
    create_parent : boolean
        creates all the nonexistent parent datasets. Datasets created in
        this manner are automatically mounted according to the mountpoint
        property inherited from their parent.
    recursive : boolean
        recursively rename the snapshots of all descendent datasets.
        snapshots are the only dataset that can be renamed recursively.

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.rename myzpool/mydataset myzpool/renameddataset

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    target = []

    # NOTE: set extra config from kwargs
    if __utils__["zfs.is_snapshot"](name):
        if kwargs.get("create_parent", False):
            log.warning(
                "zfs.rename - create_parent=True cannot be used with snapshots."
            )
        if kwargs.get("force", False):
            log.warning("zfs.rename - force=True cannot be used with snapshots.")
        if kwargs.get("recursive", False):
            flags.append("-r")
    else:
        if kwargs.get("create_parent", False):
            flags.append("-p")
        if kwargs.get("force", False):
            flags.append("-f")
        if kwargs.get("recursive", False):
            log.warning("zfs.rename - recursive=True can only be used with snapshots.")

    # NOTE: update target
    target.append(name)
    target.append(new_name)

    ## Rename filesystem/volume/snapshot/...
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="rename",
            flags=flags,
            target=target,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "renamed")


def list_(name=None, **kwargs):
    """
    Return a list of all datasets or a specified dataset on the system and the
    values of their used, available, referenced, and mountpoint properties.

    name : string
        name of dataset, volume, or snapshot
    recursive : boolean
        recursively list children
    depth : int
        limit recursion to depth
    properties : string
        comma-separated list of properties to list, the name property will always be added
    type : string
        comma-separated list of types to display, where type is one of
        filesystem, snapshot, volume, bookmark, or all.
    sort : string
        property to sort on (default = name)
    order : string [ascending|descending]
        sort order (default = ascending)
    parsable : boolean
        display numbers in parsable (exact) values
        .. versionadded:: 2018.3.0

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.list
        salt '*' zfs.list myzpool/mydataset [recursive=True|False]
        salt '*' zfs.list myzpool/mydataset properties="sharenfs,mountpoint"

    """
    ret = OrderedDict()

    ## update properties
    # NOTE: properties should be a list
    properties = kwargs.get("properties", "used,avail,refer,mountpoint")
    if not isinstance(properties, list):
        properties = properties.split(",")

    # NOTE: name should be first property
    #       we loop here because there 'name' can be in the list
    #       multiple times.
    while "name" in properties:
        properties.remove("name")
    properties.insert(0, "name")

    ## Configure command
    # NOTE: initialize the defaults
    flags = ["-H"]
    opts = {}

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")
    if kwargs.get("recursive", False) and kwargs.get("depth", False):
        opts["-d"] = kwargs.get("depth")
    if kwargs.get("type", False):
        opts["-t"] = kwargs.get("type")
    kwargs_sort = kwargs.get("sort", False)
    if kwargs_sort and kwargs_sort in properties:
        if kwargs.get("order", "ascending").startswith("a"):
            opts["-s"] = kwargs_sort
        else:
            opts["-S"] = kwargs_sort
    if isinstance(properties, list):
        # NOTE: There can be only one -o and it takes a comma-separated list
        opts["-o"] = ",".join(properties)
    else:
        opts["-o"] = properties

    ## parse zfs list
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="list",
            flags=flags,
            opts=opts,
            target=name,
        ),
        python_shell=False,
    )
    if res["retcode"] == 0:
        for ds in res["stdout"].splitlines():
            if kwargs.get("parsable", True):
                ds_data = __utils__["zfs.from_auto_dict"](
                    OrderedDict(list(zip(properties, ds.split("\t")))),
                )
            else:
                ds_data = __utils__["zfs.to_auto_dict"](
                    OrderedDict(list(zip(properties, ds.split("\t")))),
                    convert_to_human=True,
                )

            ret[ds_data["name"]] = ds_data
            del ret[ds_data["name"]]["name"]
    else:
        return __utils__["zfs.parse_command_result"](res)

    return ret


def list_mount():
    """
    List mounted zfs filesystems

    .. versionadded:: 2018.3.1

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.list_mount

    """
    ## List mounted filesystem
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="mount",
        ),
        python_shell=False,
    )

    if res["retcode"] == 0:
        ret = OrderedDict()
        for mount in res["stdout"].splitlines():
            mount = mount.split()
            ret[mount[0]] = mount[-1]
        return ret
    else:
        return __utils__["zfs.parse_command_result"](res)


def mount(name=None, **kwargs):
    """
    Mounts ZFS file systems

    name : string
        name of the filesystem, having this set to None will mount all filesystems. (this is the default)
    overlay : boolean
        perform an overlay mount.
    options : string
        optional comma-separated list of mount options to use temporarily for
        the duration of the mount.

    .. versionadded:: 2016.3.0
    .. versionchanged:: 2018.3.1

    .. warning::

            Passing '-a' as name is deprecated and will be removed in 3001.

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.mount
        salt '*' zfs.mount myzpool/mydataset
        salt '*' zfs.mount myzpool/mydataset options=ro

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    opts = {}

    # NOTE: set extra config from kwargs
    if kwargs.get("overlay", False):
        flags.append("-O")
    if kwargs.get("options", False):
        opts["-o"] = kwargs.get("options")

    ## Mount filesystem
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="mount",
            flags=flags,
            opts=opts,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "mounted")


def unmount(name, **kwargs):
    """
    Unmounts ZFS file systems

    name : string
        name of the filesystem, you can use None to unmount all mounted filesystems.
    force : boolean
        forcefully unmount the file system, even if it is currently in use.

    .. warning::

        Using ``-a`` for the name parameter will probably break your system, unless your rootfs is not on zfs.

    .. versionadded:: 2016.3.0
    .. versionchanged:: 2018.3.1

    .. warning::

            Passing '-a' as name is deprecated and will be removed in 3001.

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.unmount myzpool/mydataset [force=True|False]

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []

    # NOTE: set extra config from kwargs
    if kwargs.get("force", False):
        flags.append("-f")
    if name in [None, "-a"]:
        # NOTE: still accept '-a' as name for backwards compatibility
        #       until Salt 3001 this should just simplify
        #       this to just set '-a' if name is not set.
        flags.append("-a")
        name = None

    ## Unmount filesystem
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="unmount",
            flags=flags,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "unmounted")


def inherit(prop, name, **kwargs):
    """
    Clears the specified property

    prop : string
        name of property
    name : string
        name of the filesystem, volume, or snapshot
    recursive : boolean
        recursively inherit the given property for all children.
    revert : boolean
        revert the property to the received value if one exists; otherwise
        operate as if the -S option was not specified.

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.inherit canmount myzpool/mydataset [recursive=True|False]

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")
    if kwargs.get("revert", False):
        flags.append("-S")

    ## Inherit property
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="inherit",
            flags=flags,
            property_name=prop,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "inherited")


def diff(name_a, name_b=None, **kwargs):
    """
    Display the difference between a snapshot of a given filesystem and
    another snapshot of that filesystem from a later time or the current
    contents of the filesystem.

    name_a : string
        name of snapshot
    name_b : string
        (optional) name of snapshot or filesystem
    show_changetime : boolean
        display the path's inode change time as the first column of output. (default = True)
    show_indication : boolean
        display an indication of the type of file. (default = True)
    parsable : boolean
        if true we don't parse the timestamp to a more readable date (default = True)

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.diff myzpool/mydataset@yesterday myzpool/mydataset

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = ["-H"]
    target = []

    # NOTE: set extra config from kwargs
    if kwargs.get("show_changetime", True):
        flags.append("-t")
    if kwargs.get("show_indication", True):
        flags.append("-F")

    # NOTE: update target
    target.append(name_a)
    if name_b:
        target.append(name_b)

    ## Diff filesystem/snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="diff",
            flags=flags,
            target=target,
        ),
        python_shell=False,
    )

    if res["retcode"] != 0:
        return __utils__["zfs.parse_command_result"](res)
    else:
        if not kwargs.get("parsable", True) and kwargs.get("show_changetime", True):
            ret = OrderedDict()
            for entry in res["stdout"].splitlines():
                entry = entry.split()
                entry_timestamp = __utils__["dateutils.strftime"](
                    entry[0], "%Y-%m-%d.%H:%M:%S.%f"
                )
                entry_data = "\t\t".join(entry[1:])
                ret[entry_timestamp] = entry_data
        else:
            ret = res["stdout"].splitlines()
        return ret


def rollback(name, **kwargs):
    """
    Roll back the given dataset to a previous snapshot.

    name : string
        name of snapshot
    recursive : boolean
        destroy any snapshots and bookmarks more recent than the one
        specified.
    recursive_all : boolean
        destroy any more recent snapshots and bookmarks, as well as any
        clones of those snapshots.
    force : boolean
        used with the -R option to force an unmount of any clone file
        systems that are to be destroyed.

    .. warning::

        When a dataset is rolled back, all data that has changed since
        the snapshot is discarded, and the dataset reverts to the state
        at the time of the snapshot. By default, the command refuses to
        roll back to a snapshot other than the most recent one.

        In order to do so, all intermediate snapshots and bookmarks
        must be destroyed by specifying the -r option.

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.rollback myzpool/mydataset@yesterday

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive_all", False):
        flags.append("-R")
    if kwargs.get("recursive", False):
        flags.append("-r")
    if kwargs.get("force", False):
        if kwargs.get("recursive_all", False) or kwargs.get("recursive", False):
            flags.append("-f")
        else:
            log.warning(
                "zfs.rollback - force=True can only be used with recursive_all=True or"
                " recursive=True"
            )

    ## Rollback to snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="rollback",
            flags=flags,
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "rolledback")


def clone(name_a, name_b, **kwargs):
    """
    Creates a clone of the given snapshot.

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

    .. note::

        ZFS properties can be specified at the time of creation of the filesystem by
        passing an additional argument called "properties" and specifying the properties
        with their respective values in the form of a python dictionary::

            properties="{'property1': 'value1', 'property2': 'value2'}"

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.clone myzpool/mydataset@yesterday myzpool/mydataset_yesterday

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    target = []

    # NOTE: push filesystem properties
    filesystem_properties = kwargs.get("properties", {})

    # NOTE: set extra config from kwargs
    if kwargs.get("create_parent", False):
        flags.append("-p")

    # NOTE: update target
    target.append(name_a)
    target.append(name_b)

    ## Clone filesystem/volume
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="clone",
            flags=flags,
            filesystem_properties=filesystem_properties,
            target=target,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "cloned")


def promote(name):
    """
    Promotes a clone file system to no longer be dependent on its "origin"
    snapshot.

    .. note::

        This makes it possible to destroy the file system that the
        clone was created from. The clone parent-child dependency relationship
        is reversed, so that the origin file system becomes a clone of the
        specified file system.

        The snapshot that was cloned, and any snapshots previous to this
        snapshot, are now owned by the promoted clone. The space they use moves
        from the origin file system to the promoted clone, so enough space must
        be available to accommodate these snapshots. No new space is consumed
        by this operation, but the space accounting is adjusted. The promoted
        clone must not have any conflicting snapshot names of its own. The
        rename subcommand can be used to rename any conflicting snapshots.

    name : string
        name of clone-filesystem

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.promote myzpool/myclone

    """
    ## Promote clone
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="promote",
            target=name,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "promoted")


def bookmark(snapshot, bookmark):
    """
    Creates a bookmark of the given snapshot

    .. note::

        Bookmarks mark the point in time when the snapshot was created,
        and can be used as the incremental source for a zfs send command.

        This feature must be enabled to be used. See zpool-features(5) for
        details on ZFS feature flags and the bookmarks feature.

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

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.bookmark myzpool/mydataset@yesterday myzpool/mydataset#complete

    """
    # abort if we do not have feature flags
    if not __utils__["zfs.has_feature_flags"]():
        return OrderedDict([("error", "bookmarks are not supported")])

    ## Configure command
    # NOTE: initialize the defaults
    target = []

    # NOTE: update target
    target.append(snapshot)
    target.append(bookmark)

    ## Bookmark snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="bookmark",
            target=target,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "bookmarked")


def holds(snapshot, **kwargs):
    """
    Lists all existing user references for the given snapshot or snapshots.

    snapshot : string
        name of snapshot
    recursive : boolean
        lists the holds that are set on the named descendent snapshots also.

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.holds myzpool/mydataset@baseline

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = ["-H"]
    target = []

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")

    # NOTE: update target
    target.append(snapshot)

    ## Lookup holds
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="holds",
            flags=flags,
            target=target,
        ),
        python_shell=False,
    )

    ret = __utils__["zfs.parse_command_result"](res)
    if res["retcode"] == 0:
        for hold in res["stdout"].splitlines():
            hold_data = OrderedDict(
                list(
                    zip(
                        ["name", "tag", "timestamp"],
                        hold.split("\t"),
                    )
                )
            )
            ret[hold_data["tag"].strip()] = hold_data["timestamp"]

    return ret


def hold(tag, *snapshot, **kwargs):
    """
    Adds a single reference, named with the tag argument, to the specified
    snapshot or snapshots.

    .. note::

        Each snapshot has its own tag namespace, and tags must be unique within that space.

        If a hold exists on a snapshot, attempts to destroy that snapshot by
        using the zfs destroy command return EBUSY.

    tag : string
        name of tag
    snapshot : string
        name of snapshot(s)
    recursive : boolean
        specifies that a hold with the given tag is applied recursively to
        the snapshots of all descendent file systems.

    .. versionadded:: 2016.3.0
    .. versionchanged:: 2018.3.1

    .. warning::

        As of 2018.3.1 the tag parameter no longer accepts a comma-separated value.
        It's is now possible to create a tag that contains a comma, this was impossible before.

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.hold mytag myzpool/mydataset@mysnapshot [recursive=True]
        salt '*' zfs.hold mytag myzpool/mydataset@mysnapshot myzpool/mydataset@myothersnapshot
    """

    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    target = []

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")

    # NOTE: update target
    target.append(tag)
    target.extend(snapshot)

    ## hold snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="hold",
            flags=flags,
            target=target,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "held")


def release(tag, *snapshot, **kwargs):
    """
    Removes a single reference, named with the tag argument, from the
    specified snapshot or snapshots.

    .. note::

        The tag must already exist for each snapshot.
        If a hold exists on a snapshot, attempts to destroy that
        snapshot by using the zfs destroy command return EBUSY.

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

    .. versionadded:: 2016.3.0
    .. versionchanged:: 2018.3.1

    .. warning::

        As of 2018.3.1 the tag parameter no longer accepts a comma-separated value.
        It's is now possible to create a tag that contains a comma, this was impossible before.

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.release mytag myzpool/mydataset@mysnapshot [recursive=True]
        salt '*' zfs.release mytag myzpool/mydataset@mysnapshot myzpool/mydataset@myothersnapshot

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []
    target = []

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")

    # NOTE: update target
    target.append(tag)
    target.extend(snapshot)

    ## release snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="release",
            flags=flags,
            target=target,
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "released")


def snapshot(*snapshot, **kwargs):
    """
    Creates snapshots with the given names.

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

    .. note::

        ZFS properties can be specified at the time of creation of the filesystem by
        passing an additional argument called "properties" and specifying the properties
        with their respective values in the form of a python dictionary::

            properties="{'property1': 'value1', 'property2': 'value2'}"

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.snapshot myzpool/mydataset@yesterday [recursive=True]
        salt '*' zfs.snapshot myzpool/mydataset@yesterday myzpool/myotherdataset@yesterday [recursive=True]

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = []

    # NOTE: push filesystem properties
    filesystem_properties = kwargs.get("properties", {})

    # NOTE: set extra config from kwargs
    if kwargs.get("recursive", False):
        flags.append("-r")

    ## Create snapshot
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="snapshot",
            flags=flags,
            filesystem_properties=filesystem_properties,
            target=list(snapshot),
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "snapshotted")


def set(*dataset, **kwargs):
    """
    Sets the property or list of properties to the given value(s) for each dataset.

    dataset : string
        name of snapshot(s), filesystem(s), or volume(s)
    properties : string
        additional zfs properties pairs

    .. note::

        properties are passed as key-value pairs. e.g.

            compression=off

    .. note::

        Only some properties can be edited.

        See the Properties section for more information on what properties
        can be set and acceptable values.

        Numeric values can be specified as exact values, or in a human-readable
        form with a suffix of B, K, M, G, T, P, E (for bytes, kilobytes,
        megabytes, gigabytes, terabytes, petabytes, or exabytes respectively).

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.set myzpool/mydataset compression=off
        salt '*' zfs.set myzpool/mydataset myzpool/myotherdataset compression=off
        salt '*' zfs.set myzpool/mydataset myzpool/myotherdataset compression=lz4 canmount=off

    """
    ## Configure command
    # NOTE: push filesystem properties
    filesystem_properties = salt.utils.args.clean_kwargs(**kwargs)

    ## Set property
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="set",
            property_name=list(filesystem_properties.keys()),
            property_value=list(filesystem_properties.values()),
            target=list(dataset),
        ),
        python_shell=False,
    )

    return __utils__["zfs.parse_command_result"](res, "set")


def get(*dataset, **kwargs):
    """
    Displays properties for the given datasets.

    dataset : string
        name of snapshot(s), filesystem(s), or volume(s)
    properties : string
        comma-separated list of properties to list, defaults to all
    recursive : boolean
        recursively list children
    depth : int
        recursively list children to depth
    fields : string
        comma-separated list of fields to include, the name and property field will always be added
    type : string
        comma-separated list of types to display, where type is one of
        filesystem, snapshot, volume, bookmark, or all.

        .. versionchanged:: 3004

        type is ignored on Solaris 10 and 11 since not a valid parameter on those platforms

    source : string
        comma-separated list of sources to display. Must be one of the following:
        local, default, inherited, temporary, and none. The default value is all sources.
    parsable : boolean
        display numbers in parsable (exact) values (default = True)
        .. versionadded:: 2018.3.0

    .. note::
        If no datasets are specified, then the command displays properties
        for all datasets on the system.

    .. versionadded:: 2016.3.0

    CLI Example:

    .. code-block:: bash

        salt '*' zfs.get
        salt '*' zfs.get myzpool/mydataset [recursive=True|False]
        salt '*' zfs.get myzpool/mydataset properties="sharenfs,mountpoint" [recursive=True|False]
        salt '*' zfs.get myzpool/mydataset myzpool/myotherdataset properties=available fields=value depth=1

    """
    ## Configure command
    # NOTE: initialize the defaults
    flags = ["-H"]
    opts = {}

    # NOTE: set extra config from kwargs
    if kwargs.get("depth", False):
        opts["-d"] = kwargs.get("depth")
    elif kwargs.get("recursive", False):
        flags.append("-r")
    fields = kwargs.get("fields", "value,source").split(",")
    if "name" in fields:  # ensure name is first
        fields.remove("name")
    if "property" in fields:  # ensure property is second
        fields.remove("property")
    fields.insert(0, "name")
    fields.insert(1, "property")
    opts["-o"] = ",".join(fields)

    if not salt.utils.platform.is_sunos():
        if kwargs.get("type", False):
            opts["-t"] = kwargs.get("type")

    if kwargs.get("source", False):
        opts["-s"] = kwargs.get("source")

    # NOTE: set property_name
    property_name = kwargs.get("properties", "all")

    ## Get properties
    res = __salt__["cmd.run_all"](
        __utils__["zfs.zfs_command"](
            command="get",
            flags=flags,
            opts=opts,
            property_name=property_name,
            target=list(dataset),
        ),
        python_shell=False,
    )

    ret = __utils__["zfs.parse_command_result"](res)
    if res["retcode"] == 0:
        for ds in res["stdout"].splitlines():
            ds_data = OrderedDict(list(zip(fields, ds.split("\t"))))

            if "value" in ds_data:
                if kwargs.get("parsable", True):
                    ds_data["value"] = __utils__["zfs.from_auto"](
                        ds_data["property"],
                        ds_data["value"],
                    )
                else:
                    ds_data["value"] = __utils__["zfs.to_auto"](
                        ds_data["property"],
                        ds_data["value"],
                        convert_to_human=True,
                    )

            if ds_data["name"] not in ret:
                ret[ds_data["name"]] = OrderedDict()

            ret[ds_data["name"]][ds_data["property"]] = ds_data
            del ds_data["name"]
            del ds_data["property"]

    return ret
