FM / ubuntu-advantage

/usr/lib/ubuntu-advantage

Name	Size	Mode	Actions
add_esm_snapshot_auth.py	1924	0644	edit dl rm
apt-esm-json-hook	51528	0755	edit dl rm
apt_news.py	565	0644	edit dl rm
auto_attach.py	3766	0644	edit dl rm
cloud-id-shim.sh	500	0755	edit dl rm
convert_list_to_deb822.py	2424	0644	edit dl rm
daemon.py	2549	0644	edit dl rm
esm_cache.py	491	0755	edit dl rm
migrate_user_config.py	5501	0644	edit dl rm
patch_status_json.py	2534	0755	edit dl rm
postinst-migrations.sh	3617	0755	edit dl rm
reboot_cmds.py	5018	0644	edit dl rm
timer.py	6122	0644	edit dl rm
upgrade_lts_contract.py	621	0755	edit dl rm

Edit: /usr/lib/ubuntu-advantage/reboot_cmds.py (5018B)

#!/usr/bin/env python3

"""
Run configuration operations during system boot.

Some uaclient operations cannot be fully completed by running a single
command. For example, when upgrading uaclient from trusty to xenial,
we may have a livepatch change in the contract, allowing livepatch to be
enabled on xenial. However, during the upgrade we cannot install livepatch on
the system because the running kernel version will not be updated until reboot.

Pro client touches a flag file
/var/lib/ubuntu-advantage/marker-reboot-cmds-required to indicate this script
should run at next boot to process any pending/unresovled config operations.
"""

import logging
import sys

from uaclient import (
    api,
    config,
    contract,
    exceptions,
    http,
    lock,
    log,
    update_contract_info,
    upgrade_lts_contract,
)
from uaclient.api.u.pro.status.is_attached.v1 import _is_attached
from uaclient.entitlements.fips import FIPSEntitlement
from uaclient.files import machine_token, notices, state_files

LOG = logging.getLogger("ubuntupro.lib.reboot_cmds")

def fix_pro_pkg_holds(cfg: config.UAConfig):
    status_cache = state_files.status_cache_file.read()
    if not status_cache:
        return
    for service in status_cache.get("services", []):
        if service.get("name") == "fips":
            if service.get("status") == "enabled":
                # fips was enabled, fix the holds
                break
            else:
                # fips was not enabled, don't do anything
                return

LOG.info("Attempting to remove Ubuntu Pro FIPS package holds")
    fips = FIPSEntitlement(cfg)

try:
        fips.setup_apt_config(
            progress=api.ProgressWrapper()
        )  # Removes package holds
        LOG.info("Successfully removed Ubuntu Pro FIPS package holds")
    except Exception as e:
        LOG.error(e)
        LOG.warning("Could not remove Ubuntu Pro FIPS package holds")

try:
        fips.install_packages(
            progress=api.ProgressWrapper(), cleanup_on_failure=False
        )
    except exceptions.UbuntuProError:
        LOG.warning("Failed to install packages at boot: %r", fips.packages)
        raise

def refresh_contract(cfg: config.UAConfig):
    try:
        contract.refresh(cfg)
    except exceptions.ConnectivityError:
        LOG.warning("Failed to refresh contract")
        raise

def handle_unattached_state(cfg: config.UAConfig):
    if not _is_attached(cfg).is_attached:
        LOG.info("Skipping reboot_cmds. Machine is unattached")
        if state_files.reboot_cmd_marker_file.is_present:
            state_files.reboot_cmd_marker_file.delete()
        notices.remove(notices.Notice.REBOOT_SCRIPT_FAILED)
        return 0
    return None

def run_reboot_commands(cfg: config.UAConfig):
    fix_pro_pkg_holds(cfg)
    refresh_contract(cfg)
    upgrade_lts_contract.process_contract_delta_after_apt_lock(cfg)
    state_files.reboot_cmd_marker_file.delete()
    notices.remove(notices.Notice.REBOOT_SCRIPT_FAILED)

def handle_only_series_marker_file(cfg: config.UAConfig):
    """Handle the only_series marker file.
    Checks if the marker file is present,
    validates the release series and
    deletes the marker file if the field is not present.""
    """
    if state_files.only_series_check_marker_file.is_present:
        machine_token_file = machine_token.get_machine_token_file()
        only_series = machine_token_file.only_series
        if only_series:
            update_contract_info.validate_release_series(cfg, only_series)
        else:
            state_files.only_series_check_marker_file.delete()

def main(cfg: config.UAConfig) -> int:
    ret = handle_unattached_state(cfg)
    if ret is not None:
        return ret
    try:
        LOG.info("Running commands on reboot")
        with lock.RetryLock(lock_holder="pro-reboot-cmds"):
            handle_only_series_marker_file(cfg)
            if state_files.reboot_cmd_marker_file.is_present:
                run_reboot_commands(cfg)
            else:
                LOG.info("Skipping reboot_cmds. Marker file not present")
                notices.remove(notices.Notice.REBOOT_SCRIPT_FAILED)
                return 0

except exceptions.LockHeldError as e:
        LOG.warning("Lock not released. %s", str(e.msg))
        notices.add(notices.Notice.REBOOT_SCRIPT_FAILED)
        return 1
    except exceptions.UbuntuProError as e:
        LOG.error(
            "Error while running commands on reboot: %s, %s", e.msg_code, e.msg
        )
        notices.add(notices.Notice.REBOOT_SCRIPT_FAILED)
        return 1
    except Exception as e:
        LOG.error("Failed running commands on reboot. Error: %s", str(e))
        notices.add(notices.Notice.REBOOT_SCRIPT_FAILED)
        return 1

LOG.info("Successfully ran all commands on reboot.")
    return 0

if __name__ == "__main__":
    log.setup_journald_logging()
    cfg = config.UAConfig()
    http.configure_web_proxy(cfg.http_proxy, cfg.https_proxy)
    sys.exit(main(cfg=cfg))

cmd: