Mini Shell
"""
Utility functions for zfs
These functions are for dealing with type conversion and basic execution
:maintainer: Jorge Schrauwen <sjorge@blackdot.be>
:maturity: new
:depends: salt.utils.stringutils, salt.ext, salt.module.cmdmod
:platform: illumos,freebsd,linux
.. versionadded:: 2018.3.1
"""
import logging
import math
import os
import re
from numbers import Number
import salt.modules.cmdmod
from salt.utils.decorators import memoize as real_memoize
from salt.utils.odict import OrderedDict
from salt.utils.stringutils import to_num as str_to_num
# Size conversion data
re_zfs_size = re.compile(r"^(\d+|\d+(?=\d*)\.\d+)([KkMmGgTtPpEe][Bb]?)$")
zfs_size = ["K", "M", "G", "T", "P", "E"]
log = logging.getLogger(__name__)
def _check_retcode(cmd):
"""
Simple internal wrapper for cmdmod.retcode
"""
return (
salt.modules.cmdmod.retcode(cmd, output_loglevel="quiet", ignore_retcode=True)
== 0
)
def _exec(**kwargs):
"""
Simple internal wrapper for cmdmod.run
"""
if "ignore_retcode" not in kwargs:
kwargs["ignore_retcode"] = True
if "output_loglevel" not in kwargs:
kwargs["output_loglevel"] = "quiet"
return salt.modules.cmdmod.run_all(**kwargs)
def _merge_last(values, merge_after, merge_with=" "):
"""
Merge values all values after X into the last value
"""
if len(values) > merge_after:
values = values[0 : (merge_after - 1)] + [
merge_with.join(values[(merge_after - 1) :])
]
return values
def _property_normalize_name(name):
"""
Normalizes property names
"""
if "@" in name:
name = name[: name.index("@") + 1]
return name
def _property_detect_type(name, values):
"""
Detect the datatype of a property
"""
value_type = "str"
if values.startswith("on | off"):
value_type = "bool"
elif values.startswith("yes | no"):
value_type = "bool_alt"
elif values in ["<size>", "<size> | none"]:
value_type = "size"
elif values in ["<count>", "<count> | none", "<guid>"]:
value_type = "numeric"
elif name in ["sharenfs", "sharesmb", "canmount"]:
value_type = "bool"
elif name in ["version", "copies"]:
value_type = "numeric"
return value_type
def _property_create_dict(header, data):
"""
Create a property dict
"""
prop = dict(zip(header, _merge_last(data, len(header))))
prop["name"] = _property_normalize_name(prop["property"])
prop["type"] = _property_detect_type(prop["name"], prop["values"])
prop["edit"] = from_bool(prop["edit"])
if "inherit" in prop:
prop["inherit"] = from_bool(prop["inherit"])
del prop["property"]
return prop
def _property_parse_cmd(cmd, alias=None):
"""
Parse output of zpool/zfs get command
"""
if not alias:
alias = {}
properties = {}
# NOTE: append get to command
if cmd[-3:] != "get":
cmd += " get"
# NOTE: parse output
prop_hdr = []
for prop_data in _exec(cmd=cmd)["stderr"].split("\n"):
# NOTE: make the line data more manageable
prop_data = prop_data.lower().split()
# NOTE: skip empty lines
if not prop_data:
continue
# NOTE: parse header
elif prop_data[0] == "property":
prop_hdr = prop_data
continue
# NOTE: skip lines after data
elif not prop_hdr or prop_data[1] not in ["no", "yes"]:
continue
# NOTE: create property dict
prop = _property_create_dict(prop_hdr, prop_data)
# NOTE: add property to dict
properties[prop["name"]] = prop
if prop["name"] in alias:
properties[alias[prop["name"]]] = prop
# NOTE: cleanup some duplicate data
del prop["name"]
return properties
def _auto(direction, name, value, source="auto", convert_to_human=True):
"""
Internal magic for from_auto and to_auto
"""
# NOTE: check direction
if direction not in ["to", "from"]:
return value
# NOTE: collect property data
props = property_data_zpool()
if source == "zfs":
props = property_data_zfs()
elif source == "auto":
props.update(property_data_zfs())
# NOTE: figure out the conversion type
value_type = props[name]["type"] if name in props else "str"
# NOTE: convert
if value_type == "size" and direction == "to":
return globals()[f"{direction}_{value_type}"](value, convert_to_human)
return globals()[f"{direction}_{value_type}"](value)
@real_memoize
def _zfs_cmd():
"""
Return the path of the zfs binary if present
"""
# Get the path to the zfs binary.
return salt.utils.path.which("zfs")
@real_memoize
def _zpool_cmd():
"""
Return the path of the zpool binary if present
"""
# Get the path to the zfs binary.
return salt.utils.path.which("zpool")
def _command(
source,
command,
flags=None,
opts=None,
property_name=None,
property_value=None,
filesystem_properties=None,
pool_properties=None,
target=None,
):
"""
Build and properly escape a zfs command
.. note::
Input is not considered safe and will be passed through
to_auto(from_auto('input_here')), you do not need to do so
your self first.
"""
# NOTE: start with the zfs binary and command
cmd = [_zpool_cmd() if source == "zpool" else _zfs_cmd(), command]
# NOTE: append flags if we have any
if flags is None:
flags = []
for flag in flags:
cmd.append(flag)
# NOTE: append options
# we pass through 'sorted' to guarantee the same order
if opts is None:
opts = {}
for opt in sorted(opts):
if not isinstance(opts[opt], list):
opts[opt] = [opts[opt]]
for val in opts[opt]:
cmd.append(opt)
cmd.append(to_str(val))
# NOTE: append filesystem properties (really just options with a key/value)
# we pass through 'sorted' to guarantee the same order
if filesystem_properties is None:
filesystem_properties = {}
for fsopt in sorted(filesystem_properties):
cmd.append("-O" if source == "zpool" else "-o")
cmd.append(
"{key}={val}".format(
key=fsopt,
val=to_auto(
fsopt,
filesystem_properties[fsopt],
source="zfs",
convert_to_human=False,
),
)
)
# NOTE: append pool properties (really just options with a key/value)
# we pass through 'sorted' to guarantee the same order
if pool_properties is None:
pool_properties = {}
for fsopt in sorted(pool_properties):
cmd.append("-o")
cmd.append(
"{key}={val}".format(
key=fsopt,
val=to_auto(
fsopt,
pool_properties[fsopt],
source="zpool",
convert_to_human=False,
),
)
)
# NOTE: append property and value
# the set command takes a key=value pair, we need to support this
if property_name is not None:
if property_value is not None:
if not isinstance(property_name, list):
property_name = [property_name]
if not isinstance(property_value, list):
property_value = [property_value]
for key, val in zip(property_name, property_value):
cmd.append(
"{key}={val}".format(
key=key,
val=to_auto(key, val, source=source, convert_to_human=False),
)
)
else:
cmd.append(property_name)
# NOTE: append the target(s)
if target is not None:
if not isinstance(target, list):
target = [target]
for tgt in target:
# NOTE: skip None list items
# we do not want to skip False and 0!
if tgt is None:
continue
cmd.append(to_str(tgt))
return " ".join(cmd)
def is_supported():
"""
Check the system for ZFS support
"""
# Check for supported platforms
# NOTE: ZFS on Windows is in development
# NOTE: ZFS on NetBSD is in development
on_supported_platform = False
if salt.utils.platform.is_sunos():
on_supported_platform = True
elif salt.utils.platform.is_freebsd() and _check_retcode("kldstat -q -m zfs"):
on_supported_platform = True
elif salt.utils.platform.is_linux() and os.path.exists("/sys/module/zfs"):
on_supported_platform = True
elif salt.utils.platform.is_linux() and salt.utils.path.which("zfs-fuse"):
on_supported_platform = True
elif (
salt.utils.platform.is_darwin()
and os.path.exists("/Library/Extensions/zfs.kext")
and os.path.exists("/dev/zfs")
):
on_supported_platform = True
# Additional check for the zpool command
return (salt.utils.path.which("zpool") and on_supported_platform) is True
@real_memoize
def has_feature_flags():
"""
Check if zpool-features is available
"""
# get man location
man = salt.utils.path.which("man")
return _check_retcode(f"{man} zpool-features") if man else False
@real_memoize
def property_data_zpool():
"""
Return a dict of zpool properties
.. note::
Each property will have an entry with the following info:
- edit : boolean - is this property editable after pool creation
- type : str - either bool, bool_alt, size, numeric, or string
- values : str - list of possible values
.. warning::
This data is probed from the output of 'zpool get' with some supplemental
data that is hardcoded. There is no better way to get this information aside
from reading the code.
"""
# NOTE: man page also mentions a few short forms
property_data = _property_parse_cmd(
_zpool_cmd(),
{
"allocated": "alloc",
"autoexpand": "expand",
"autoreplace": "replace",
"listsnapshots": "listsnaps",
"fragmentation": "frag",
},
)
# NOTE: zpool status/iostat has a few extra fields
zpool_size_extra = [
"capacity-alloc",
"capacity-free",
"operations-read",
"operations-write",
"bandwidth-read",
"bandwidth-write",
"read",
"write",
]
zpool_numeric_extra = [
"cksum",
"cap",
]
for prop in zpool_size_extra:
property_data[prop] = {
"edit": False,
"type": "size",
"values": "<size>",
}
for prop in zpool_numeric_extra:
property_data[prop] = {
"edit": False,
"type": "numeric",
"values": "<count>",
}
return property_data
@real_memoize
def property_data_zfs():
"""
Return a dict of zfs properties
.. note::
Each property will have an entry with the following info:
- edit : boolean - is this property editable after pool creation
- inherit : boolean - is this property inheritable
- type : str - either bool, bool_alt, size, numeric, or string
- values : str - list of possible values
.. warning::
This data is probed from the output of 'zfs get' with some supplemental
data that is hardcoded. There is no better way to get this information aside
from reading the code.
"""
return _property_parse_cmd(
_zfs_cmd(),
{
"available": "avail",
"logicalreferenced": "lrefer.",
"logicalused": "lused.",
"referenced": "refer",
"volblocksize": "volblock",
"compression": "compress",
"readonly": "rdonly",
"recordsize": "recsize",
"refreservation": "refreserv",
"reservation": "reserv",
},
)
def from_numeric(value):
"""
Convert zfs numeric to python int
"""
if value == "none":
value = None
elif value:
value = str_to_num(value)
return value
def to_numeric(value):
"""
Convert python int to zfs numeric
"""
value = from_numeric(value)
if value is None:
value = "none"
return value
def from_bool(value):
"""
Convert zfs bool to python bool
"""
if value in ["on", "yes"]:
value = True
elif value in ["off", "no"]:
value = False
elif value == "none":
value = None
return value
def from_bool_alt(value):
"""
Convert zfs bool_alt to python bool
"""
return from_bool(value)
def to_bool(value):
"""
Convert python bool to zfs on/off bool
"""
value = from_bool(value)
if isinstance(value, bool):
value = "on" if value else "off"
elif value is None:
value = "none"
return value
def to_bool_alt(value):
"""
Convert python to zfs yes/no value
"""
value = from_bool_alt(value)
if isinstance(value, bool):
value = "yes" if value else "no"
elif value is None:
value = "none"
return value
def from_size(value):
"""
Convert zfs size (human readable) to python int (bytes)
"""
match_size = re_zfs_size.match(str(value))
if match_size:
v_unit = match_size.group(2).upper()[0]
v_size = float(match_size.group(1))
v_multiplier = math.pow(1024, zfs_size.index(v_unit) + 1)
value = v_size * v_multiplier
if int(value) == value:
value = int(value)
elif value is not None:
value = str(value)
return from_numeric(value)
def to_size(value, convert_to_human=True):
"""
Convert python int (bytes) to zfs size
NOTE: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/pyzfs/common/util.py#114
"""
value = from_size(value)
if value is None:
value = "none"
if isinstance(value, Number) and value > 1024 and convert_to_human:
v_power = int(math.floor(math.log(value, 1024)))
v_multiplier = math.pow(1024, v_power)
# NOTE: zfs is a bit odd on how it does the rounding,
# see libzfs implementation linked above
v_size_float = float(value) / v_multiplier
if v_size_float == int(v_size_float):
value = "{:.0f}{}".format(
v_size_float,
zfs_size[v_power - 1],
)
else:
for v_precision in ["{:.2f}{}", "{:.1f}{}", "{:.0f}{}"]:
v_size = v_precision.format(
v_size_float,
zfs_size[v_power - 1],
)
if len(v_size) <= 5:
value = v_size
break
return value
def from_str(value):
"""
Decode zfs safe string (used for name, path, ...)
"""
if value == "none":
value = None
if value:
value = str(value)
if value.startswith('"') and value.endswith('"'):
value = value[1:-1]
value = value.replace('\\"', '"')
return value
def to_str(value):
"""
Encode zfs safe string (used for name, path, ...)
"""
value = from_str(value)
if value:
value = value.replace('"', '\\"')
if " " in value:
value = '"' + value + '"'
elif value is None:
value = "none"
return value
def from_auto(name, value, source="auto"):
"""
Convert zfs value to python value
"""
return _auto("from", name, value, source)
def to_auto(name, value, source="auto", convert_to_human=True):
"""
Convert python value to zfs value
"""
return _auto("to", name, value, source, convert_to_human)
def from_auto_dict(values, source="auto"):
"""
Pass an entire dictionary to from_auto
.. note::
The key will be passed as the name
"""
for name, value in values.items():
values[name] = from_auto(name, value, source)
return values
def to_auto_dict(values, source="auto", convert_to_human=True):
"""
Pass an entire dictionary to to_auto
.. note::
The key will be passed as the name
"""
for name, value in values.items():
values[name] = to_auto(name, value, source, convert_to_human)
return values
def is_snapshot(name):
"""
Check if name is a valid snapshot name
"""
return from_str(name).count("@") == 1
def is_bookmark(name):
"""
Check if name is a valid bookmark name
"""
return from_str(name).count("#") == 1
def is_dataset(name):
"""
Check if name is a valid filesystem or volume name
"""
return not is_snapshot(name) and not is_bookmark(name)
def zfs_command(
command,
flags=None,
opts=None,
property_name=None,
property_value=None,
filesystem_properties=None,
target=None,
):
"""
Build and properly escape a zfs command
.. note::
Input is not considered safe and will be passed through
to_auto(from_auto('input_here')), you do not need to do so
your self first.
"""
return _command(
"zfs",
command=command,
flags=flags,
opts=opts,
property_name=property_name,
property_value=property_value,
filesystem_properties=filesystem_properties,
pool_properties=None,
target=target,
)
def zpool_command(
command,
flags=None,
opts=None,
property_name=None,
property_value=None,
filesystem_properties=None,
pool_properties=None,
target=None,
):
"""
Build and properly escape a zpool command
.. note::
Input is not considered safe and will be passed through
to_auto(from_auto('input_here')), you do not need to do so
your self first.
"""
return _command(
"zpool",
command=command,
flags=flags,
opts=opts,
property_name=property_name,
property_value=property_value,
filesystem_properties=filesystem_properties,
pool_properties=pool_properties,
target=target,
)
def parse_command_result(res, label=None):
"""
Parse the result of a zpool/zfs command
.. note::
Output on failure is rather predictable.
- retcode > 0
- each 'error' is a line on stderr
- optional 'Usage:' block under those with hits
We simple check those and return a OrderedDict were
we set label = True|False and error = error_messages
"""
ret = OrderedDict()
if label:
ret[label] = res["retcode"] == 0
if res["retcode"] != 0:
ret["error"] = []
for error in res["stderr"].splitlines():
if error.lower().startswith("usage:"):
break
if error.lower().startswith("use '-f'"):
error = error.replace("-f", "force=True")
if error.lower().startswith("use '-r'"):
error = error.replace("-r", "recursive=True")
ret["error"].append(error)
if ret["error"]:
ret["error"] = "\n".join(ret["error"])
else:
del ret["error"]
return ret
Zerion Mini Shell 1.0