Dashboard

Editing: actions.py

#   Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
#   Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.org/licenses/UPL.

import logging
import subprocess
import time

from osms import config
from osms import distro
from osms import utils
from osms import alxutils
from osms.server import OsmsServer

def package_remove(package_list, cache_only=None):
    """Remove packages from this system
    """
    if cache_only:
        return (0, "no-ops for caching", {})
    logging.debug("Called package_remove: %s", package_list)
    if not isinstance(package_list, list):
        return (13, "Invalid arguments: list is required", {})
    time_started = time.time()
    try:
        result = distro.package_remove(package_list)
        if result and result[0] != 0 and utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result or (0, "Packages remove OK", {})
    except Exception as err:
        msg = "Packages remove failed: %s" % err
        logging.debug(msg)
        result = (1, msg, {})
        if utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result

def package_update(package_list, cache_only=None):
    """Install packages on the system
    """
    logging.debug("Called package_update: %s", package_list)
    if not isinstance(package_list, list):
        return (13, "Invalid arguments: list is required ", {})
    try:
        time_started = time.time()
        result = distro.package_update(package_list, cache_only)
        logging.info(result)
        if result and result[0] != 0 and utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result or (0, "Packages update OK", {})
    except Exception as err:
        msg = "Packages update failed: %s" % err
        logging.debug(msg)
        result = (1, msg, {})
        if utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result

def package_full_update(cache_only=None):
    """Update all packages on the system
    """
    logging.debug("Called package_full_update")
    time_started = time.time()
    try:
        result = distro.package_full_update(cache_only)
        if result and result[0] != 0 and utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result or (0, "Packages full update OK", {})
    except Exception as err:
        msg = "Packages full update failed: %s" % err
        logging.debug(msg)
        result = (1, msg, {})
        if utils.is_alx():
            alxutils.send_failed_yum_result(result, time_started)
        return result

def package_check_need_update(cache_only=None):
    """Check and refresh installed packages on the system
    """
    if cache_only:
        return (0, "no-ops for caching", {})
    logging.debug("Called package_check_need_update")
    if utils.check_packages_last_update_timestamp():
        return (0, "Package database not modified since last update", {})
    return package_refresh_list()

def package_refresh_list(cache_only=None, timeout=None):
    """Refresh package list of the system on the server
    """
    if cache_only:
        return (0, "no-ops for caching", {})
    logging.debug("Called package_refresh_list")
    try:
        system_id = config.getSystemId()
        if not system_id:
            raise Exception('The system is not registered')
        package_list = distro.get_installed_package_list()
        OsmsServer().registration.update_packages(system_id, package_list)
        utils.touch_packages_last_update_timestamp()
        return (0, "Packages refresh OK", {})
    except Exception as err:
        msg = "Packages refresh failed: %s" % err
        logging.debug(msg)
        return (20, msg, {})

def package_verify(package_list, cache_only=None):
    """Verify and report missing packages on the system
    """
    if cache_only:
        return (0, "no-ops for caching", {})
    logging.debug("Called package_verify: %s", package_list)
    if not isinstance(package_list, list):
        return (13, "Invalid arguments: list is required", {})
    data = {}
    data['name'] = "packages.verify"
    data['version'] = 0
    ret, missing_packages = distro.verify_packages(package_list)
    data['verify_info'] = ret
    if missing_packages:
        data['name'] = "packages.verify.missing_packages"
        data['version'] = 0
        data['missing_packages'] = missing_packages
        return(43, "Packages requested to be verified are missing", data)
    return (0, "Packages verify OK", data)

def errata_update(errata_id_list, cache_only=None):
    logging.debug("Called errata_update: %s", errata_id_list)
    package_list = []
    try:
        if not isinstance(errata_id_list, (list, tuple)):
            errata_id_list = [errata_id_list]

system_id = config.getSystemId()
        if not system_id:
            raise Exception('The system is not registered')

errata_package_list = []
        for errata_id in errata_id_list:
            errata_package_list += OsmsServer().errata.getErrataInfo(system_id, errata_id)

installed_packages = {}
        for package in distro.get_installed_package_list():
            installed_packages[package['name'] + package['arch']] = package

for package in errata_package_list:
            if (package[0] + package[4] in installed_packages or
                package[0] + 'noarch' in installed_packages or
                package[4] == 'noarch' and package[0] in installed_packages):
                package_list.append(package)
    except Exception as err:
        msg = "Errata update failed: %s" % err
        logging.debug(msg)
        return (20, msg, {})

if not package_list:
        data = {}
        data['version'] = "0"
        data['name'] = "errata.update.no_packages"
        data['erratas'] = errata_id_list
        return (39, "No packages from that errata are available", data)

return package_update(package_list, cache_only)

def ksplice_upgrade(cache_only=None):
    """Perform Ksplice upgrade
    """
    logging.debug("Called ksplice_upgrade")
    if cache_only:
        return (0, "no-ops for caching", {})
    try:
        utils.run_cmd(["rpm", "-q", "ksplice-tools"])
    except Exception as err:
        logging.debug("ksplice-tools is not installed: %s", err)
        return (0, "ksplice-tools is not installed", {})
    time_started = time.time()
    try:
        # call subprocess directly because alx needs exit code
        args = ["ksplice", "-y", "all", "upgrade", "--no-yum"]
        logging.debug('run_cmd args: %s', args)
        proc = subprocess.Popen(
            args,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            close_fds=True,
        )
        stdoutdata, stderrdata = proc.communicate()
        stdoutdata = stdoutdata.decode("utf-8")
        stderrdata = stderrdata.decode("utf-8")

# failed, send to alx and raise exception as in run_cmd
        if proc.returncode != 0:
            output = 'Command: %s failed (%s): stderr: %s stdout: %s' % \
                     (args, proc.returncode, stderrdata, stdoutdata)
            exception = Exception(output)
            if utils.is_alx():
                alxutils.send_ksplice_updates(alxutils.FAILURE, proc.returncode, output,
                                              time_started, time.time())
            raise exception
        # success
        else:
            logging.debug('ksplice upgrade return code: %s, stdout: %s, stderr: %s',
                          proc.returncode, stdoutdata, stderrdata)
            output = stdoutdata
            if utils.is_alx():
                alxutils.send_ksplice_updates(alxutils.SUCCESS, proc.returncode, output,
                                              time_started, time.time())
            return (0, output, {})
    except Exception as err:
        msg = "Ksplice upgrade failed: %s" % err
        logging.debug(msg)
        return (1, msg, {})

Cancel