Mini Shell

"""
Common functions for managing package refreshes during states
"""

import errno
import fnmatch
import logging
import os
import re
import sys

import salt.utils.data
import salt.utils.files
import salt.utils.versions

log = logging.getLogger(__name__)


def rtag(opts):
    """
    Return the rtag file location. This file is used to ensure that we don't
    refresh more than once (unless explicitly configured to do so).
    """
    return os.path.join(opts["cachedir"], "pkg_refresh")


def clear_rtag(opts):
    """
    Remove the rtag file
    """
    try:
        os.remove(rtag(opts))
    except OSError as exc:
        if exc.errno != errno.ENOENT:
            # Using __str__() here to get the fully-formatted error message
            # (error number, error message, path)
            log.warning("Encountered error removing rtag: %s", exc)


def write_rtag(opts):
    """
    Write the rtag file
    """
    rtag_file = rtag(opts)
    if not os.path.exists(rtag_file):
        try:
            with salt.utils.files.fopen(rtag_file, "w+"):
                pass
        except OSError as exc:
            log.warning("Encountered error writing rtag: %s", exc)


def check_refresh(opts, refresh=None):
    """
    Check whether or not a refresh is necessary

    Returns:

    - True if refresh evaluates as True
    - False if refresh is False
    - A boolean if refresh is not False and the rtag file exists
    """
    return bool(
        salt.utils.data.is_true(refresh)
        or (os.path.isfile(rtag(opts)) and refresh is not False)
    )


def split_comparison(version):
    match = re.match(r"^(<=>|!=|>=|<=|>>|<<|<>|>|<|=)?\s?([^<>=]+)$", version)
    if match:
        comparison = match.group(1) or ""
        version = match.group(2)
    else:
        comparison = ""
    return comparison, version


def match_version(desired, available, cmp_func=None, ignore_epoch=False):
    """
    Returns the first version of the list of available versions which matches
    the desired version comparison expression, or None if no match is found.
    """
    oper, version = split_comparison(desired)
    if not oper:
        oper = "=="
    for candidate in available:
        if salt.utils.versions.compare(
            ver1=candidate,
            oper=oper,
            ver2=version,
            cmp_func=cmp_func,
            ignore_epoch=ignore_epoch,
        ):
            return candidate
    return None


def check_bundled():
    """
    Gather run-time information to indicate if we are running from source or bundled.
    """
    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
        return True
    return False


def match_wildcard(current_pkgs, pkg_params):
    """
    Loop through pkg_params looking for any which contains a wildcard and get
    the real package names from the packages which are currently installed.

    current_pkgs
        List of currently installed packages as output by ``list_pkgs``

    pkg_params
        List of packages as processed by ``pkg_resource.parse_targets``
    """
    pkg_matches = {}

    for pkg_param in list(pkg_params):
        if "*" in pkg_param:
            pkg_matches = {
                pkg: pkg_params[pkg_param]
                for pkg in current_pkgs
                if fnmatch.fnmatch(pkg, pkg_param)
            }

            # Remove previous pkg_param
            pkg_params.pop(pkg_param)

    # Update pkg_params with the matches
    pkg_params.update(pkg_matches)

    return pkg_params