"""crossgrader entrypoint""" import os from glob import glob import subprocess import argparse import shutil from debian_crossgrader.crossgrader import Crossgrader from debian_crossgrader.utils import apt as apt_utils def first_stage(args): """Runs first stage of the crossgrade process. Installs initramfs packages and packages with Priority: required/important. Does not need to be run if the target architecture can run the existing architecture. """ with Crossgrader(args.target_arch) as crossgrader: if args.packages: targets = crossgrader.find_package_objs(args.packages, default_arch=args.target_arch) else: targets = crossgrader.list_first_stage_targets( ignore_initramfs_remnants=args.force_initramfs, ignore_unavailable_targets=args.force_unavailable ) print('{} targets found.'.format(len(targets))) for pkg_name in sorted(map(lambda pkg: pkg.fullname, targets)): print(pkg_name) if args.dry_run: return cont = input('Do you want to continue [y/N]? ').lower() if cont == 'y': # cache qemu debs first because internet access might go down # after crossgrade # crossgrade qemu just if qemu-user-static exists for any arch # pairs that can be run on the current arch but the current can't # be run on the foreign arch qemu_path_exists = os.path.isdir(crossgrader.qemu_deb_path) crossgrade_qemu = crossgrader.qemu_installed or crossgrader.non_supported_arch if crossgrade_qemu and not qemu_path_exists: print('Saving qemu-user-static debs for second stage...') qemu_pkgs = crossgrader.find_package_objs(['qemu-user-static', 'binfmt-support'], default_arch=args.target_arch) crossgrader.cache_package_debs(qemu_pkgs, crossgrader.qemu_deb_path) print('qemu-user-static saved.') if args.download_only: crossgrader.cache_package_debs(targets) else: # crossgrade dpkg/apt for correct crossgrading of Architecture: all packages that # aren't marked M-A: foreign pkg_packages = crossgrader.find_package_objs( ['dpkg', 'apt', 'python3', 'python3-apt'], default_arch=args.target_arch ) if not all(pkg.is_installed for pkg in pkg_packages): crossgrader.cache_package_debs(pkg_packages) crossgrader.install_packages(fix_broken=False) # Force restart of the crossgrader so new version of python3 # and python3-apt is used print('Crossgraded dpkg, apt, python3, and python3-apt.') print('Please re-run the first stage to continue the crossgrade.') return crossgrader.cache_package_debs(targets) # fix_broken should be disabled for first stage so apt doesn't # decide to uninstall some necessary packages crossgrader.install_packages(fix_broken=False) subprocess.call(['update-initramfs', '-u', '-k', 'all']) else: print('Aborted.') def second_stage(args): """Runs the second stage of the crossgrade process. Crossgrades all packages that are not in the target architecture. """ with Crossgrader(args.target_arch) as crossgrader: # crossgrade qemu-user-static first to prevent list_second_stage_targets # from finding it if os.path.isdir(crossgrader.qemu_deb_path): print('qemu-user-static must be crossgraded.') if not args.dry_run: cont = input('Do you want to continue [y/N]? ').lower() if cont == 'y': print('Crossgrading saved qemu-user-static...') crossgrader.install_packages( glob(os.path.join(crossgrader.qemu_deb_path, '*.deb')), fix_broken=False ) os.rmdir(crossgrader.qemu_deb_path) print('qemu-user-static successfully crossgraded.') else: print('qemu-user-static crossgrade skipped.') targets = crossgrader.list_second_stage_targets( ignore_unavailable_targets=args.force_unavailable ) print('{} targets found.'.format(len(targets))) if args.dry_run: return cont = input('Do you want to continue [y/N]? ').lower() if cont == 'y': crossgrader.cache_package_debs(targets) if not args.download_only: crossgrader.install_packages() else: print('Aborted') def third_stage(args): """Runs the third stage of the crossgrading process. Removes all packages from the given architecture, excluding ones contained by args.packages. """ with Crossgrader(args.target_arch) as crossgrader: foreign_arch = args.third_stage[0] targets = apt_utils.get_arch_packages(foreign_arch) if args.packages: targets = [pkg_name for pkg_name in targets if pkg_name not in args.packages] print('{} targets found.'.format(len(targets))) for pkg_name in sorted(targets): print(pkg_name) cont = input('Do you want to continue [y/N]? ').lower() if args.dry_run: return if cont == 'y': subprocess.check_call(['dpkg', '--purge', '--force-remove-protected'] + targets) remaining = apt_utils.get_arch_packages(foreign_arch) if args.packages: remaining = [pkg_name for pkg_name in remaining if pkg_name not in args.packages] if remaining: print('The following packages could not be successfully purged:') for pkg_name in remaining: print('\t{}'.format(pkg_name)) else: print('All targets successfully purged.') print(('If desired, run dpkg --remove-architecture {} ' 'to complete the crossgrade.').format(foreign_arch)) print('Removing initramfs binary architecture check hook...') if crossgrader.remove_initramfs_arch_check(): print('Hook successfully removed.') else: print('Hook could not be removed.') def install_from(args): """Installs all .debs from the specified location.""" with Crossgrader(args.target_arch) as crossgrader: debs = glob(os.path.join(args.install_from, '*.deb')) print('Installing the following .debs:') for deb in debs: print('\t{}'.format(deb)) if args.dry_run: return cont = input('Do you want to continue [y/N]? ').lower() if cont == 'y': crossgrader.install_packages(debs) else: print('Aborted.') def cleanup(): """Cleans up any extra files, namely Crossgrader's storage_dir""" if os.path.isdir(Crossgrader.storage_dir): shutil.rmtree(Crossgrader.storage_dir) print('crossgrader data folder removed.') else: print('crossgrader data folder did not exist.') print('Removing initramfs binary architecture check hook...') if Crossgrader.remove_initramfs_arch_check(): print('Hook successfully removed.') else: print('Hook could not be removed.') def get_argparser(): """Returns the ArgumentParser object used in main. Used in main() and by python3-argparse-manpage to generate the manpage for crossgrader. """ parser = argparse.ArgumentParser() parser.add_argument('target_arch', help='Target architecture of the crossgrade') parser.add_argument('--second-stage', help=('Run the second stage of the crossgrading process ' '(crossgrading all remaining packages)'), action='store_true') parser.add_argument('--third-stage', help=('Run the third stage of the crossgrading process ' '(removing all packages under specified arch)'), metavar='OLD_ARCH', nargs=1) parser.add_argument('--download-only', help='Perform target package listing and download, but not installation', action='store_true') parser.add_argument('--install-from', help=('Perform .deb installation from a specified location ' '(default: {}), but not package listing ' 'and download').format(Crossgrader.APT_CACHE_DIR), nargs='?', const=Crossgrader.APT_CACHE_DIR) parser.add_argument('--force-unavailable', help=('Force crossgrade even if not all packages to be crossgraded' ' are available in the target architecture'), action='store_true') parser.add_argument('--force-initramfs', help=('Force crossgrade even if not all initramfs' ' hooks could be crossgraded'), action='store_true') parser.add_argument('-f', '--force-all', help='Equivalent to --force-install --force-initramfs', action='store_true') parser.add_argument('-p', '--packages', help=('Crossgrade the subsequent package names and nothing else. ' 'If used with --third-stage, the subsequent packages will ' 'be excluded from removal'), nargs='+') parser.add_argument('--dry-run', help='Run the crossgrader, but do not change anything', action='store_true') parser.add_argument('--cleanup', help=('Clean up any extra files stored by the crossgrader. ' 'The given architecture will be ignored.'), action='store_true') return parser def main(): """Crossgrade driver""" parser = get_argparser() args = parser.parse_args() if args.force_all: args.force_initramfs = True args.force_unavailable = True if args.cleanup: cleanup() elif args.install_from: install_from(args) elif args.second_stage: second_stage(args) elif args.third_stage: third_stage(args) else: first_stage(args) # __name_ is debian_crossgrader.__main__ usually, __main__ if # called with -m flag # include __main__ guard to prevent main() from being called twice from console # script entrypoint if __name__ == '__main__': main()