#!/usr/bin/python3
import optparse
import datetime
import distro_info
import os
import re
import subprocess
import sys
import apt
from UpdateManager.Core.utils import twrap, get_dist
# set locale early so that the subsequent imports have localized
# strings
import locale
try:
locale.setlocale(locale.LC_ALL, "")
except:
pass
from gettext import gettext as _
import gettext
gettext.textdomain("update-manager")
from HweSupportStatus.consts import (
Messages,
LTS_EOL_DATE,
HWE_EOL_DATE,
NEXT_LTS_DOT1_DATE,
)
# HWE stack with a short support period
HWE_UNSUPPORTED_BACKPORTS = ("-lts-utopic", "-lts-vivid", "-lts-wily")
# from https://wiki.ubuntu.com/Kernel/LTSEnablementStack
UNSUPPORTED_KERNEL_IMAGE_REGEX = (
r"linux-image.*-(3\.16|3\.19|4\.2)(\.[0-9]+)?-.*"
)
# HWE stack with a long support period
HWE_SUPPORTED_BACKPORT = "-hwe-24.04"
SUPPORTED_KERNEL_IMAGE_REGEX = r"^$" # No fixed backported kernel yet
KERNEL_METAPKGS = (
"linux-generic",
"linux-image-generic",
"linux-signed-generic",
"linux-signed-image-generic",
)
XORG_METAPKGS = (
"xserver-xorg",
"libgl1-mesa-glx",
# LP: #1610434 - Ubuntu GNOME needed libwayland
"libwayland-egl1-mesa",
)
VBOX_METAPKGS = ("virtualbox-guest-utils", "virtualbox-guest-source")
METAPKGS = KERNEL_METAPKGS + XORG_METAPKGS + VBOX_METAPKGS
class Package:
"""A lightweight apt package"""
def __init__(self, name, version, arch, foreign=False):
self.name = name
self.installed_version = version
self.arch = arch
self.foreign = foreign
def find_hwe_packages(installed_packages):
unsupported_hwe_packages = set()
supported_hwe_packages = set()
for pkg in installed_packages:
# metapackages and X are marked with the -lts-$distro string
for name in HWE_UNSUPPORTED_BACKPORTS:
if pkg.name.endswith(name):
unsupported_hwe_packages.add(pkg)
# The individual backported kernels have names like
# linux-image-3.11.0-17-generic
# so we match via a regexp.
#
# The linux-image-generic-lts-$distro metapkg has additional
# dependencies (like linux-firmware) so we can't just walk the
# dependency chain.
if re.match(UNSUPPORTED_KERNEL_IMAGE_REGEX, pkg.name):
unsupported_hwe_packages.add(pkg)
# SUPPORTED
if pkg.name.endswith(HWE_SUPPORTED_BACKPORT):
supported_hwe_packages.add(pkg)
if re.match(SUPPORTED_KERNEL_IMAGE_REGEX, pkg.name):
supported_hwe_packages.add(pkg)
return unsupported_hwe_packages, supported_hwe_packages
def is_unsupported_hwe_kernel_running(unsupported_hwe_package):
# kernels do not conflict with each other, so we need to check
# what version is actually running
running_kernel_ver = os.uname()[2]
# the running kernel without the abi or buildver
running_kernel_ver = running_kernel_ver.split("-")[0]
for pkg in unsupported_hwe_package:
if not pkg.name.startswith("linux-"):
continue
# we only care about the version, not abi or build
if pkg.installed_version.startswith(running_kernel_ver):
return True
return False
def is_unsupported_xstack_running(unsupported_hwe_packages):
# the HWE xstacks conflict with each other, so we can simply test
# for existence in the installed unsupported hwe packages
for pkg in unsupported_hwe_packages:
for xorg_meta in XORG_METAPKGS:
if pkg.name.startswith(xorg_meta):
return True
return False
def find_supported_replacement_hwe_packages(
unsupported_hwe_packages, installed_packages
):
unsupported_metapkg_names = set()
replacement_names = set()
for metapkg in METAPKGS:
for unsupported_backport in HWE_UNSUPPORTED_BACKPORTS:
metapkg_name = metapkg + unsupported_backport
for pkg in unsupported_hwe_packages:
if pkg.name == metapkg_name:
replacement_name = metapkg + HWE_SUPPORTED_BACKPORT
if (replacement_name, pkg.arch) not in [
(p.name, p.arch) for p in installed_packages
]:
if pkg.foreign:
replacement_name += ":" + pkg.arch
replacement_names.add(replacement_name)
unsupported_metapkg_names.add(metapkg_name)
return unsupported_metapkg_names, replacement_names
def is_unsupported_hwe_running(unsupported_hwe_packages):
return is_unsupported_hwe_kernel_running(
unsupported_hwe_packages
) or is_unsupported_xstack_running(unsupported_hwe_packages)
def advice_about_hwe_status(
unsupported_hwe_packages,
supported_hwe_packages,
installed_packages,
has_update_manager,
today,
verbose,
):
unsupported_hwe_stack_running = is_unsupported_hwe_running(
unsupported_hwe_packages
)
(
unsupported_hwe_metapkgs,
supported_replacement_hwe,
) = find_supported_replacement_hwe_packages(
unsupported_hwe_packages, installed_packages
)
# we need the "-p" option until the next LTS point release is available
if today < NEXT_LTS_DOT1_DATE:
do_release_upgrade_option = "-p"
else:
do_release_upgrade_option = ""
if unsupported_hwe_stack_running:
if today < HWE_EOL_DATE:
s = Messages.HWE_SUPPORT_ENDS
else:
s = Messages.HWE_SUPPORT_HAS_ENDED
if has_update_manager:
print(s + Messages.UM_UPGRADE)
else:
# bug #1341320 - if no metapkg is left we need to show
# what is no longer supported
if supported_replacement_hwe:
print(
s
+ Messages.APT_UPGRADE
% (
do_release_upgrade_option,
" ".join(supported_replacement_hwe),
)
)
else:
print(
s
+ Messages.APT_SHOW_UNSUPPORTED
% (
" ".join(
[pkg.name for pkg in unsupported_hwe_packages]
)
)
)
# some unsupported package installed but not running and not superseded
# - this is worth reporting
elif (
unsupported_hwe_packages
and not supported_hwe_packages
and not unsupported_hwe_stack_running
):
s = (
_(
"""
You have packages from the Hardware Enablement Stack (HWE) installed that
are going out of support on %s.
"""
)
% HWE_EOL_DATE
)
if has_update_manager:
print(s + Messages.UM_UPGRADE)
else:
print(
s
+ Messages.APT_UPGRADE
% (
do_release_upgrade_option,
" ".join(supported_replacement_hwe),
)
)
elif supported_hwe_packages:
print(Messages.HWE_SUPPORTED)
elif verbose:
print(
_(
"You are not running a system with a Hardware Enablement "
"Stack. Your system is supported until %(month)s %(year)s."
)
% {"month": LTS_EOL_DATE.strftime("%B"), "year": LTS_EOL_DATE.year}
)
if __name__ == "__main__":
parser = optparse.OptionParser(description=_("Check HWE support status"))
parser.add_option(
"--quiet",
action="store_true",
default=False,
help="No output, exit code 10 on unsupported HWE packages",
)
parser.add_option(
"--verbose",
action="store_true",
default=False,
help="more verbose output",
)
parser.add_option(
"--show-all-unsupported",
action="store_true",
default=False,
help="Show unsupported HWE packages",
)
parser.add_option(
"--show-replacements",
action="store_true",
default=False,
help="show what packages need installing to be supported",
)
# hidden, only useful for testing
parser.add_option(
"--disable-hwe-check-semaphore-file",
default="/var/lib/update-notifier/disable-hwe-eol-messages",
help=optparse.SUPPRESS_HELP,
)
options, args = parser.parse_args()
if options.quiet:
nullfd = os.open(os.devnull, os.O_WRONLY)
os.dup2(nullfd, sys.stdout.fileno())
# Check to see if we are an LTS release
di = distro_info.UbuntuDistroInfo()
codename = get_dist()
lts = di.is_lts(codename)
if not lts:
if options.verbose:
print(
"Only LTS releases have Hardware Enablement stacks",
file=sys.stderr,
)
sys.exit(0)
# request from PSE to be able to disable the hwe check via a special
# semaphore file
HWE_CHECK_DISABLED_FILE = options.disable_hwe_check_semaphore_file
if os.path.exists(HWE_CHECK_DISABLED_FILE):
if options.verbose:
print(
"Forcefully disabled hwe-support-status via file %s"
% HWE_CHECK_DISABLED_FILE,
file=sys.stderr,
)
sys.exit(0)
foreign_archs = set(
subprocess.check_output(
["dpkg", "--print-foreign-architectures"], universal_newlines=True
).split()
)
# do the actual check
installed_packages = set()
today = datetime.date.today()
tagf = apt.apt_pkg.TagFile("/var/lib/dpkg/status")
while tagf.step():
if tagf.section.find("Status", "") != "install ok installed":
continue
pkgname = tagf.section.find("Package")
version = tagf.section.find("Version")
arch = tagf.section.find("Architecture")
foreign = arch in foreign_archs
installed_packages.add(Package(pkgname, version, arch, foreign))
has_update_manager = "update-manager" in [
pkg.name for pkg in installed_packages
]
unsupported_hwe_packages, supported_hwe_packages = find_hwe_packages(
installed_packages
)
if options.show_all_unsupported:
if today > HWE_EOL_DATE:
print(
twrap(
" ".join(
[
pkg.foreign
and pkg.name + ":" + pkg.arch
or pkg.name
for pkg in unsupported_hwe_packages
]
)
)
)
if options.show_replacements:
unsupported, replacements = find_supported_replacement_hwe_packages(
unsupported_hwe_packages, installed_packages
)
if replacements:
print(" ".join(replacements))
if not options.show_all_unsupported and not options.show_replacements:
advice_about_hwe_status(
unsupported_hwe_packages,
supported_hwe_packages,
installed_packages,
has_update_manager,
today,
options.verbose,
)
if (
is_unsupported_hwe_running(unsupported_hwe_packages)
and today > HWE_EOL_DATE
):
sys.exit(10)
sys.exit(0)
Mini Shell