# -*- coding: utf-8 -*-
'''
Module for managing BCache sets

BCache is a block-level caching mechanism similar to ZFS L2ARC/ZIL, dm-cache and fscache.
It works by formatting one block device as a cache set, then adding backend devices
(which need to be formatted as such) to the set and activating them.

It's available in Linux mainline kernel since 3.10

https://www.kernel.org/doc/Documentation/bcache.txt

This module needs the bcache userspace tools to function.

.. versionadded: 2016.3.0

'''
# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import logging
import os
import time
import re

from salt.ext import six

# Import salt libs
import salt.utils.path

log = logging.getLogger(__name__)

LOG = {
    'trace': logging.TRACE,
    'debug': logging.DEBUG,
    'info': logging.INFO,
    'warn': logging.WARNING,
    'error': logging.ERROR,
    'crit': logging.CRITICAL,
}

__func_alias__ = {
    'attach_': 'attach',
    'config_': 'config',
    'super_': 'super',
}

HAS_BLKDISCARD = salt.utils.path.which('blkdiscard') is not None


def __virtual__():
    '''
    Only work when make-bcache is installed
    '''
    return salt.utils.path.which('make-bcache') is not None


def uuid(dev=None):
    '''
    Return the bcache UUID of a block device.
    If no device is given, the Cache UUID is returned.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.uuid
        salt '*' bcache.uuid /dev/sda
        salt '*' bcache.uuid bcache0

    '''
    try:
        if dev is None:
            # take the only directory in /sys/fs/bcache and return it's basename
            return list(salt.utils.path.os_walk('/sys/fs/bcache/'))[0][1][0]
        else:
            # basename of the /sys/block/{dev}/bcache/cache symlink target
            return os.path.basename(_bcsys(dev, 'cache'))
    except:  # pylint: disable=bare-except
        return False


def attach_(dev=None):
    '''
    Attach a backing devices to a cache set
    If no dev is given, all backing devices will be attached.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.attach sdc
        salt '*' bcache.attach /dev/bcache1


    :return: bool or None if nuttin' happened
    '''
    cache = uuid()
    if not cache:
        log.error('No cache to attach %s to', dev)
        return False

    if dev is None:
        res = {}
        for dev, data in status(alldevs=True).items():
            if 'cache' in data:
                res[dev] = attach_(dev)

        if len(res):
            return res
        else:
            return None

    bcache = uuid(dev)
    if bcache:
        if bcache == cache:
            log.info('%s is already attached to bcache %s, doing nothing', dev, cache)
            return None
        elif not detach(dev):
            return False

    log.debug('Attaching %s to bcache %s', dev, cache)

    if not _bcsys(dev, 'attach', cache,
                  'error', 'Error attaching {0} to bcache {1}'.format(dev, cache)):
        return False

    return _wait(lambda: uuid(dev) == cache,
                 'error', '{0} received attach to bcache {1}, but did not comply'.format(dev, cache))


def detach(dev=None):
    '''
    Detach a backing device(s) from a cache set
    If no dev is given, all backing devices will be attached.

    Detaching a backing device will flush it's write cache.
    This should leave the underlying device in a consistent state, but might take a while.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.detach sdc
        salt '*' bcache.detach bcache1

    '''
    if dev is None:
        res = {}
        for dev, data in status(alldevs=True).items():
            if 'cache' in data:
                res[dev] = detach(dev)

        if len(res):
            return res
        else:
            return None

    log.debug('Detaching %s', dev)
    if not _bcsys(dev, 'detach', 'goaway', 'error', 'Error detaching {0}'.format(dev)):
        return False
    return _wait(lambda: uuid(dev) is False, 'error', '{0} received detach, but did not comply'.format(dev), 300)


def start():
    '''
    Trigger a start of the full bcache system through udev.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.start

    '''
    if not _run_all('udevadm trigger', 'error', 'Error starting bcache: %s'):
        return False
    elif not _wait(lambda: uuid() is not False, 'warn', 'Bcache system started, but no active cache set found.'):
        return False
    return True


def stop(dev=None):
    '''
    Stop a bcache device
    If no device is given, all backing devices will be detached from the cache, which will subsequently be stopped.

    .. warning::
        'Stop' on an individual backing device means hard-stop;
        no attempt at flushing will be done and the bcache device will seemingly 'disappear' from the device lists

    CLI example:

    .. code-block:: bash

        salt '*' bcache.stop

    '''
    if dev is not None:
        log.warning('Stopping %s, device will only reappear after reregistering!', dev)
        if not _bcsys(dev, 'stop', 'goaway', 'error', 'Error stopping {0}'.format(dev)):
            return False
        return _wait(lambda: _sysfs_attr(_bcpath(dev)) is False, 'error', 'Device {0} did not stop'.format(dev), 300)
    else:
        cache = uuid()
        if not cache:
            log.warning('bcache already stopped?')
            return None

        if not _alltrue(detach()):
            return False
        elif not _fssys('stop', 'goaway', 'error', 'Error stopping cache'):
            return False

        return _wait(lambda: uuid() is False, 'error', 'Cache did not stop', 300)


def back_make(dev, cache_mode='writeback', force=False, attach=True, bucket_size=None):
    '''
    Create a backing device for attachment to a set.
    Because the block size must be the same, a cache set already needs to exist.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.back_make sdc cache_mode=writeback attach=True


    :param cache_mode: writethrough, writeback, writearound or none.
    :param force: Overwrite existing bcaches
    :param attach: Immediately attach the backing device to the set
    :param bucket_size: Size of a bucket (see kernel doc)
    '''
    # pylint: disable=too-many-return-statements
    cache = uuid()

    if not cache:
        log.error('No bcache set found')
        return False
    elif _sysfs_attr(_bcpath(dev)):
        if not force:
            log.error('%s already contains a bcache. Wipe it manually or use force', dev)
            return False
        elif uuid(dev) and not detach(dev):
            return False
        elif not stop(dev):
            return False

    dev = _devpath(dev)
    block_size = _size_map(_fssys('block_size'))
    # You might want to override, we pick the cache set's as sane default
    if bucket_size is None:
        bucket_size = _size_map(_fssys('bucket_size'))

    cmd = 'make-bcache --block {0} --bucket {1} --{2} --bdev {3}'.format(block_size, bucket_size, cache_mode, dev)
    if force:
        cmd += ' --wipe-bcache'

    if not _run_all(cmd, 'error', 'Error creating backing device {0}: %s'.format(dev)):
        return False
    elif not _sysfs_attr('fs/bcache/register', _devpath(dev),
                         'error', 'Error registering backing device {0}'.format(dev)):
        return False
    elif not _wait(lambda: _sysfs_attr(_bcpath(dev)) is not False,
                   'error', 'Backing device {0} did not register'.format(dev)):
        return False
    elif attach:
        return attach_(dev)

    return True


def cache_make(dev, reserved=None, force=False, block_size=None, bucket_size=None, attach=True):
    '''
    Create BCache cache on a block device.
    If blkdiscard is available the entire device will be properly cleared in advance.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.cache_make sdb reserved=10% block_size=4096


    :param reserved: if dev is a full device, create a partition table with this size empty.

        .. note::
              this increases the amount of reserved space available to SSD garbage collectors,
              potentially (vastly) increasing performance
    :param block_size: Block size of the cache; defaults to devices' logical block size
    :param force: Overwrite existing BCache sets
    :param attach: Attach all existing backend devices immediately
    '''
    # TODO: multiple devs == md jbod

    # pylint: disable=too-many-return-statements
    # ---------------- Preflight checks ----------------
    cache = uuid()
    if cache:
        if not force:
            log.error('BCache cache %s is already on the system', cache)
            return False
        cache = _bdev()

    dev = _devbase(dev)
    udev = __salt__['udev.env'](dev)

    if ('ID_FS_TYPE' in udev or (udev.get('DEVTYPE', None) != 'partition' and 'ID_PART_TABLE_TYPE' in udev)) \
            and not force:
        log.error('%s already contains data, wipe first or force', dev)
        return False
    elif reserved is not None and udev.get('DEVTYPE', None) != 'disk':
        log.error('Need a partitionable blockdev for reserved to work')
        return False

    _, block, bucket = _sizes(dev)

    if bucket_size is None:
        bucket_size = bucket
        # TODO: bucket from _sizes() makes no sense
        bucket_size = False
    if block_size is None:
        block_size = block

    # ---------------- Still here, start doing destructive stuff ----------------
    if cache:
        if not stop():
            return False
        # Wipe the current cache device as well,
        # forever ruining any chance of it accidentally popping up again
        elif not _wipe(cache):
            return False

    # Can't do enough wiping
    if not _wipe(dev):
        return False

    if reserved:
        cmd = 'parted -m -s -a optimal -- ' \
              '/dev/{0} mklabel gpt mkpart bcache-reserved 1M {1} mkpart bcache {1} 100%'.format(dev, reserved)
        # if wipe was incomplete & part layout remains the same,
        # this is one condition set where udev would make it accidentally popup again
        if not _run_all(cmd, 'error', 'Error creating bcache partitions on {0}: %s'.format(dev)):
            return False
        dev = '{0}2'.format(dev)

    # ---------------- Finally, create a cache ----------------
    cmd = 'make-bcache --cache /dev/{0} --block {1} --wipe-bcache'.format(dev, block_size)

    # Actually bucket_size should always have a value, but for testing 0 is possible as well
    if bucket_size:
        cmd += ' --bucket {0}'.format(bucket_size)

    if not _run_all(cmd, 'error', 'Error creating cache {0}: %s'.format(dev)):
        return False
    elif not _wait(lambda: uuid() is not False,
                   'error', 'Cache {0} seemingly created OK, but FS did not activate'.format(dev)):
        return False

    if attach:
        return _alltrue(attach_())
    else:
        return True


def config_(dev=None, **kwargs):
    '''
    Show or update config of a bcache device.

    If no device is given, operate on the cache set itself.

    CLI example:

    .. code-block:: bash

        salt '*' bcache.config
        salt '*' bcache.config bcache1
        salt '*' bcache.config errors=panic journal_delay_ms=150
        salt '*' bcache.config bcache1 cache_mode=writeback writeback_percent=15

    :return: config or True/False
    '''
    if dev is None:
        spath = _fspath()
    else:
        spath = _bcpath(dev)

    # filter out 'hidden' kwargs added by our favourite orchestration system
    updates = dict([(key, val) for key, val in kwargs.items() if not key.startswith('__')])

    if updates:
        endres = 0
        for key, val in updates.items():
            endres += _sysfs_attr([spath, key], val,
                                  'warn', 'Failed to update {0} with {1}'.format(os.path.join(spath, key), val))
        return endres > 0
    else:
        result = {}
        data = _sysfs_parse(spath, config=True, internals=True, options=True)
        for key in ('other_ro', 'inter_ro'):
            if key in data:
                del data[key]

        for key in data:
            result.update(data[key])

        return result


def status(stats=False, config=False, internals=False, superblock=False, alldevs=False):
    '''
    Show the full status of the BCache system and optionally all it's involved devices

    CLI example:

    .. code-block:: bash

        salt '*' bcache.status
        salt '*' bcache.status stats=True
        salt '*' bcache.status internals=True alldevs=True

    :param stats: include statistics
    :param config: include settings
    :param internals: include internals
    :param superblock: include superblock
    '''
    bdevs = []
    for _, links, _ in salt.utils.path.os_walk('/sys/block/'):
        for block in links:
            if 'bcache' in block:
                continue

            for spath, sdirs, _ in salt.utils.path.os_walk('/sys/block/{0}'.format(block), followlinks=False):
                if 'bcache' in sdirs:
                    bdevs.append(os.path.basename(spath))
    statii = {}
    for bcache in bdevs:
        statii[bcache] = device(bcache, stats, config, internals, superblock)

    cuuid = uuid()
    cdev = _bdev()
    if cdev:
        count = 0
        for dev in statii:
            if dev != cdev:
                # it's a backing dev
                if statii[dev]['cache'] == cuuid:
                    count += 1
        statii[cdev]['attached_backing_devices'] = count

        if not alldevs:
            statii = statii[cdev]

    return statii


def device(dev, stats=False, config=False, internals=False, superblock=False):
    '''
    Check the state of a single bcache device

    CLI example:

    .. code-block:: bash

        salt '*' bcache.device bcache0
        salt '*' bcache.device /dev/sdc stats=True

    :param stats: include statistics
    :param settings: include all settings
    :param internals: include all internals
    :param superblock: include superblock info
    '''
    result = {}

    if not _sysfs_attr(_bcpath(dev), None, 'error', '{0} is not a bcache fo any kind'.format(dev)):
        return False
    elif _bcsys(dev, 'set'):
        # ---------------- It's the cache itself ----------------
        result['uuid'] = uuid()
        base_attr = ['block_size', 'bucket_size', 'cache_available_percent', 'cache_replacement_policy', 'congested']

        # ---------------- Parse through both the blockdev & the FS ----------------
        result.update(_sysfs_parse(_bcpath(dev), base_attr, stats, config, internals))
        result.update(_sysfs_parse(_fspath(), base_attr, stats, config, internals))

        result.update(result.pop('base'))
    else:
        # ---------------- It's a backing device ----------------
        back_uuid = uuid(dev)
        if back_uuid is not None:
            result['cache'] = back_uuid

        try:
            result['dev'] = os.path.basename(_bcsys(dev, 'dev'))
        except:  # pylint: disable=bare-except
            pass
        result['bdev'] = _bdev(dev)

        base_attr = ['cache_mode', 'running', 'state', 'writeback_running']
        base_path = _bcpath(dev)

        result.update(_sysfs_parse(base_path, base_attr, stats, config, internals))
        result.update(result.pop('base'))

        # ---------------- Modifications ----------------
        state = [result['state']]
        if result.pop('running'):
            state.append('running')
        else:
            state.append('stopped')
        if 'writeback_running' in result:
            if result.pop('writeback_running'):
                state.append('writeback_running')
            else:
                state.append('writeback_stopped')
        result['state'] = state

    # ---------------- Statistics ----------------
    if 'stats' in result:
        replre = r'(stats|cache)_'
        statres = result['stats']
        for attr in result['stats']:
            if '/' not in attr:
                key = re.sub(replre, '', attr)
                statres[key] = statres.pop(attr)
            else:
                stat, key = attr.split('/', 1)
                stat = re.sub(replre, '', stat)
                key = re.sub(replre, '', key)
                if stat not in statres:
                    statres[stat] = {}
                statres[stat][key] = statres.pop(attr)
        result['stats'] = statres

    # ---------------- Internals ----------------
    if internals:
        interres = result.pop('inter_ro', {})
        interres.update(result.pop('inter_rw', {}))
        if len(interres):
            for key in interres:
                if key.startswith('internal'):
                    nkey = re.sub(r'internal[s/]*', '', key)
                    interres[nkey] = interres.pop(key)
                    key = nkey
                if key.startswith(('btree', 'writeback')):
                    mkey, skey = re.split(r'_', key, maxsplit=1)
                    if mkey not in interres:
                        interres[mkey] = {}
                    interres[mkey][skey] = interres.pop(key)
            result['internals'] = interres

    # ---------------- Config ----------------
    if config:
        configres = result['config']
        for key in configres:
            if key.startswith('writeback'):
                mkey, skey = re.split(r'_', key, maxsplit=1)
                if mkey not in configres:
                    configres[mkey] = {}
                configres[mkey][skey] = configres.pop(key)
        result['config'] = configres

    # ---------------- Superblock ----------------
    if superblock:
        result['superblock'] = super_(dev)

    return result


def super_(dev):
    '''
    Read out BCache SuperBlock

    CLI example:

    .. code-block:: bash

        salt '*' bcache.device bcache0
        salt '*' bcache.device /dev/sdc

    '''
    dev = _devpath(dev)
    ret = {}

    res = _run_all('bcache-super-show {0}'.format(dev), 'error', 'Error reading superblock on {0}: %s'.format(dev))
    if not res:
        return False

    for line in res.splitlines():  # pylint: disable=no-member
        line = line.strip()
        if not line:
            continue

        key, val = [val.strip() for val in re.split(r'[\s]+', line, maxsplit=1)]
        if not (key and val):
            continue

        mval = None
        if ' ' in val:
            rval, mval = [val.strip() for val in re.split(r'[\s]+', val, maxsplit=1)]
            mval = mval[1:-1]
        else:
            rval = val

        try:
            rval = int(rval)
        except:  # pylint: disable=bare-except
            try:
                rval = float(rval)
            except:  # pylint: disable=bare-except
                if rval == 'yes':
                    rval = True
                elif rval == 'no':
                    rval = False

        pkey, key = re.split(r'\.', key, maxsplit=1)
        if pkey not in ret:
            ret[pkey] = {}

        if mval is not None:
            ret[pkey][key] = (rval, mval)
        else:
            ret[pkey][key] = rval

    return ret

# -------------------------------- HELPER FUNCTIONS --------------------------------


def _devbase(dev):
    '''
    Basename of just about any dev
    '''
    dev = os.path.realpath(os.path.expandvars(dev))
    dev = os.path.basename(dev)
    return dev


def _devpath(dev):
    '''
    Return /dev name of just about any dev
    :return: /dev/devicename
    '''
    return os.path.join('/dev', _devbase(dev))


def _syspath(dev):
    '''
    Full SysFS path of a device
    '''
    dev = _devbase(dev)
    dev = re.sub(r'^([vhs][a-z]+)([0-9]+)', r'\1/\1\2', dev)

    # name = re.sub(r'^([a-z]+)(?<!(bcache|md|dm))([0-9]+)', r'\1/\1\2', name)
    return os.path.join('/sys/block/', dev)


def _bdev(dev=None):
    '''
    Resolve a bcacheX or cache to a real dev
    :return: basename of bcache dev
    '''
    if dev is None:
        dev = _fssys('cache0')
    else:
        dev = _bcpath(dev)

    if not dev:
        return False
    else:
        return _devbase(os.path.realpath(os.path.join(dev, '../')))


def _bcpath(dev):
    '''
    Full SysFS path of a bcache device
    '''
    return os.path.join(_syspath(dev), 'bcache')


def _fspath():
    '''
    :return: path of active bcache
    '''
    cuuid = uuid()
    if not cuuid:
        return False
    else:
        return os.path.join('/sys/fs/bcache/', cuuid)


def _fssys(name, value=None, log_lvl=None, log_msg=None):
    '''
    Simple wrapper to interface with bcache SysFS
    '''
    fspath = _fspath()
    if not fspath:
        return False
    else:
        return _sysfs_attr([fspath, name], value, log_lvl, log_msg)


def _bcsys(dev, name, value=None, log_lvl=None, log_msg=None):
    '''
    Simple wrapper to interface with backing devs SysFS
    '''
    return _sysfs_attr([_bcpath(dev), name], value, log_lvl, log_msg)


def _sysfs_attr(name, value=None, log_lvl=None, log_msg=None):
    '''
    Simple wrapper with logging around sysfs.attr
    '''
    if isinstance(name, six.string_types):
        name = [name]
    res = __salt__['sysfs.attr'](os.path.join(*name), value)
    if not res and log_lvl is not None and log_msg is not None:
        log.log(LOG[log_lvl], log_msg)
    return res


def _sysfs_parse(path, base_attr=None, stats=False, config=False, internals=False, options=False):
    '''
    Helper function for parsing BCache's SysFS interface
    '''
    result = {}

    # ---------------- Parse through the interfaces list ----------------
    intfs = __salt__['sysfs.interfaces'](path)

    # Actions, we ignore
    del intfs['w']

    # -------- Sorting hat --------
    binkeys = []
    if internals:
        binkeys.extend(['inter_ro', 'inter_rw'])
    if config:
        binkeys.append('config')
    if stats:
        binkeys.append('stats')

    bintf = {}
    for key in binkeys:
        bintf[key] = []

    for intf in intfs['r']:
        if intf.startswith('internal'):
            key = 'inter_ro'
        elif 'stats' in intf:
            key = 'stats'
        else:
            # What to do with these???
            # I'll utilize 'inter_ro' as 'misc' as well
            key = 'inter_ro'

        if key in bintf:
            bintf[key].append(intf)

    for intf in intfs['rw']:
        if intf.startswith('internal'):
            key = 'inter_rw'
        else:
            key = 'config'

        if key in bintf:
            bintf[key].append(intf)

    if base_attr is not None:
        for intf in bintf:
            bintf[intf] = [sintf for sintf in bintf[intf] if sintf not in base_attr]
        bintf['base'] = base_attr

    mods = {
        'stats': ['internal/bset_tree_stats', 'writeback_rate_debug', 'metadata_written', 'nbuckets', 'written',
                  'average_key_size', 'btree_cache_size'],
    }

    for modt, modlist in mods.items():
        found = []
        if modt not in bintf:
            continue
        for mod in modlist:
            for intflist in bintf.values():
                if mod in intflist:
                    found.append(mod)
                    intflist.remove(mod)
        bintf[modt] += found

    # -------- Fetch SysFS vals --------
    bintflist = [intf for iflist in bintf.values() for intf in iflist]
    result.update(__salt__['sysfs.read'](bintflist, path))

    # -------- Parse through well known string lists --------
    for strlist in ('writeback_rate_debug', 'internal/bset_tree_stats', 'priority_stats'):
        if strlist in result:
            listres = {}
            for line in result[strlist].split('\n'):
                key, val = line.split(':', 1)
                val = val.strip()
                try:
                    val = int(val)
                except:  # pylint: disable=bare-except
                    try:
                        val = float(val)
                    except:  # pylint: disable=bare-except
                        pass
                listres[key.strip()] = val
            result[strlist] = listres

    # -------- Parse through selection lists --------
    if not options:
        for sellist in ('cache_mode', 'cache_replacement_policy', 'errors'):
            if sellist in result:
                result[sellist] = re.search(r'\[(.+)\]', result[sellist]).groups()[0]

    # -------- Parse through well known bools --------
    for boolkey in ('running', 'writeback_running', 'congested'):
        if boolkey in result:
            result[boolkey] = bool(result[boolkey])

    # -------- Recategorize results --------
    bresult = {}
    for iftype, intflist in bintf.items():
        ifres = {}
        for intf in intflist:
            if intf in result:
                ifres[intf] = result.pop(intf)
        if len(ifres):
            bresult[iftype] = ifres

    return bresult


def _size_map(size):
    '''
    Map Bcache's size strings to real bytes
    '''
    try:
        # I know, I know, EAFP.
        # But everything else is reason for None
        if not isinstance(size, int):
            if re.search(r'[Kk]', size):
                size = 1024 * float(re.sub(r'[Kk]', '', size))
            elif re.search(r'[Mm]', size):
                size = 1024**2 * float(re.sub(r'[Mm]', '', size))
            size = int(size)
        return size
    except:  # pylint: disable=bare-except
        return None


def _sizes(dev):
    '''
    Return neigh useless sizing info about a blockdev
    :return: (total size in blocks, blocksize, maximum discard size in bytes)
    '''
    dev = _devbase(dev)

    # standarization yay
    block_sizes = ('hw_sector_size', 'minimum_io_size', 'physical_block_size', 'logical_block_size')
    discard_sizes = ('discard_max_bytes', 'discard_max_hw_bytes', )

    sysfs = __salt__['sysfs.read'](
        ('size',
         'queue/hw_sector_size', '../queue/hw_sector_size',
         'queue/discard_max_bytes', '../queue/discard_max_bytes'),
        root=_syspath(dev))

    # TODO: makes no sense
    # First of all, it has to be a power of 2
    # Secondly, this returns 4GiB - 512b on Intel 3500's for some weird reason
    # discard_granularity seems in bytes, resolves to 512b ???
    # max_hw_sectors_kb???
    # There's also discard_max_hw_bytes more recently
    # See: https://www.kernel.org/doc/Documentation/block/queue-sysfs.txt
    # Also, I cant find any docs yet regarding bucket sizes;
    # it's supposed to be discard_max_hw_bytes,
    # but no way to figure that one reliably out apparently

    discard = sysfs.get('queue/discard_max_bytes', sysfs.get('../queue/discard_max_bytes', None))
    block = sysfs.get('queue/hw_sector_size', sysfs.get('../queue/hw_sector_size', None))

    return 512*sysfs['size'], block, discard


def _wipe(dev):
    '''
    REALLY DESTRUCTIVE STUFF RIGHT AHEAD
    '''
    endres = 0
    dev = _devbase(dev)

    size, block, discard = _sizes(dev)

    if discard is None:
        log.error('Unable to read SysFS props for %s', dev)
        return None
    elif not discard:
        log.warning('%s seems unable to discard', dev)
        wiper = 'dd'
    elif not HAS_BLKDISCARD:
        log.warning('blkdiscard binary not available, properly wipe the dev manually for optimal results')
        wiper = 'dd'
    else:
        wiper = 'blkdiscard'

    wipe_failmsg = 'Error wiping {0}: %s'.format(dev)
    if wiper == 'dd':
        blocks = 4
        cmd = 'dd if=/dev/zero of=/dev/{0} bs=1M count={1}'.format(dev, blocks)
        endres += _run_all(cmd, 'warn', wipe_failmsg)

        # Some stuff (<cough>GPT</cough>) writes stuff at the end of a dev as well
        cmd += ' seek={0}'.format((size/1024**2) - blocks)
        endres += _run_all(cmd, 'warn', wipe_failmsg)

    elif wiper == 'blkdiscard':
        cmd = 'blkdiscard /dev/{0}'.format(dev)
        endres += _run_all(cmd, 'warn', wipe_failmsg)
        # TODO: fix annoying bug failing blkdiscard by trying to discard 1 sector past blkdev
        endres = 1

    return endres > 0


def _wait(lfunc, log_lvl=None, log_msg=None, tries=10):
    '''
    Wait for lfunc to be True
    :return: True if lfunc succeeded within tries, False if it didn't
    '''
    i = 0
    while i < tries:
        time.sleep(1)

        if lfunc():
            return True
        else:
            i += 1
    if log_lvl is not None:
        log.log(LOG[log_lvl], log_msg)
    return False


def _run_all(cmd, log_lvl=None, log_msg=None, exitcode=0):
    '''
    Simple wrapper around cmd.run_all
    log_msg can contain {0} for stderr
    :return: True or stdout, False if retcode wasn't exitcode
    '''
    res = __salt__['cmd.run_all'](cmd)
    if res['retcode'] == exitcode:
        if res['stdout']:
            return res['stdout']
        else:
            return True

    if log_lvl is not None:
        log.log(LOG[log_lvl], log_msg, res['stderr'])
    return False


def _alltrue(resdict):
    if resdict is None:
        return True
    return len([val for val in resdict.values() if val]) > 0
