def run(self): """Execute the command.""" path = self.opts.filename[0] try: packages = parse_kickstart_packages(path) except pykickstart.errors.KickstartError: raise dnf.exceptions.Error(_('file cannot be parsed: %s') % path) group_names = [group.name for group in packages.groupList] if group_names: self.base.read_comps() try: self.base.install_grouplist(group_names) except dnf.exceptions.Error: are_groups_installed = False else: are_groups_installed = True are_packages_installed = False for pattern in packages.packageList: try: self.base.install(pattern) except dnf.exceptions.MarkingError: logger.info(_('No package %s available.'), pattern) else: are_packages_installed = True if not are_groups_installed and not are_packages_installed: raise dnf.exceptions.Error(_('Nothing to do.'))
def run(self): """Execute the command.""" path = self.opts.filename[0] try: packages = parse_kickstart_packages(path) except pykickstart.errors.KickstartError: raise dnf.exceptions.Error(_('file cannot be parsed: %s') % path) group_names = [group.name for group in packages.groupList] if group_names: self.base.read_comps() try: self.base.install_grouplist(group_names) are_groups_installed = True except dnf.exceptions.Error: are_groups_installed = False are_packages_installed = False for pattern in packages.packageList: try: self.base.install(pattern) except dnf.exceptions.MarkingError: logger.info(_('No package %s available.'), pattern) else: are_packages_installed = True if not are_groups_installed and not are_packages_installed: raise dnf.exceptions.Error(_('Nothing to do.'))
def configure_download(self): if 'system-upgrade' == self.opts.command or 'fedup' == self.opts.command: help_url = get_url_from_os_release() if help_url: msg = _('Additional information for System Upgrade: {}') logger.info(msg.format(ucd(help_url))) if self.base._promptWanted(): msg = _( 'Before you continue ensure that your system is fully upgraded by running ' '"dnf --refresh upgrade". Do you want to continue') if self.base.conf.assumeno or not self.base.output.userconfirm( msg='{} [y/N]: '.format(msg), defaultyes_msg='{} [Y/n]: '.format(msg)): logger.error(_("Operation aborted.")) sys.exit(1) check_release_ver(self.base.conf, target=self.opts.releasever) self.cli.demands.root_user = True self.cli.demands.resolving = True self.cli.demands.available_repos = True self.cli.demands.sack_activation = True self.cli.demands.freshest_metadata = True # We want to do the depsolve / download / transaction-test, but *not* # run the actual RPM transaction to install the downloaded packages. # Setting the "test" flag makes the RPM transaction a test transaction, # so nothing actually gets installed. # (It also means that we run two test transactions in a row, which is # kind of silly, but that's something for DNF to fix...) self.base.conf.tsflags += ["test"]
def transaction_download(self): install_packages, remove_packages = self._get_forward_reverse_pkg_reason_pairs( ) # Okay! Write out the state so the upgrade can use it. system_ver = dnf.rpm.detect_releasever(self.base.conf.installroot) with self.state as state: state.download_status = 'complete' state.state_version = STATE_VERSION state.distro_sync = self.opts.distro_sync state.allow_erasing = self.cli.demands.allow_erasing state.gpgcheck = self.base.conf.gpgcheck state.gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.gpgcheck ] state.repo_gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.repo_gpgcheck ] state.best = self.base.conf.best state.system_releasever = system_ver state.target_releasever = self.base.conf.releasever state.install_packages = install_packages state.remove_packages = remove_packages state.install_weak_deps = self.base.conf.install_weak_deps state.module_platform_id = self.base.conf.module_platform_id state.enable_disable_repos = self.opts.repos_ed state.destdir = self.base.conf.destdir state.upgrade_command = self.opts.command msg = DOWNLOAD_FINISHED_MSG.format(command=self.opts.command) logger.info(msg) self.log_status(_("Download finished."), DOWNLOAD_FINISHED_ID)
def run_clean(self): logger.info(_("Cleaning up downloaded data...")) clear_dir(DEFAULT_DATADIR) with self.state as state: state.download_status = None state.upgrade_status = None state.install_packages = {}
def transaction_download(self): downloads = self.cli.base.transaction.install_set install_packages = {} for pkg in downloads: install_packages.setdefault(pkg.repo.id, []).append(str(pkg)) remove_packages = [ str(pkg) for pkg in self.cli.base.transaction.remove_set ] # Okay! Write out the state so the upgrade can use it. system_ver = dnf.rpm.detect_releasever(self.base.conf.installroot) with self.state as state: state.download_status = 'complete' state.distro_sync = self.opts.distro_sync state.allow_erasing = self.cli.demands.allow_erasing state.gpgcheck = self.base.conf.gpgcheck state.gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.gpgcheck ] state.repo_gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.repo_gpgcheck ] state.best = self.base.conf.best state.system_releasever = system_ver state.target_releasever = self.base.conf.releasever state.install_packages = install_packages state.remove_packages = remove_packages state.install_weak_deps = self.base.conf.install_weak_deps state.module_platform_id = self.base.conf.module_platform_id state.enable_disable_repos = self.opts.repos_ed state.destdir = self.base.conf.destdir logger.info(DOWNLOAD_FINISHED_MSG) self.log_status(_("Download finished."), DOWNLOAD_FINISHED_ID)
def run_upgrade(self): # change the upgrade status (so we can detect crashed upgrades later) command = '' with self.state as state: state.upgrade_status = 'incomplete' command = state.upgrade_command if command == 'offline-upgrade': msg = _("Starting offline upgrade. This will take a while.") elif command == 'offline-distrosync': msg = _("Starting offline distrosync. This will take a while.") else: msg = _("Starting system upgrade. This will take a while.") self.log_status(msg, UPGRADE_STARTED_ID) # reset the splash mode and let the user know we're running Plymouth.set_mode() Plymouth.progress(0) Plymouth.message(msg) # disable screen blanking disable_blanking() # NOTE: We *assume* that depsolving here will yield the same # transaction as it did during the download, but we aren't doing # anything to *ensure* that; if the metadata changed, or if depsolving # is non-deterministic in some way, we could end up with a different # transaction and then the upgrade will fail due to missing packages. # # One way to *guarantee* that we have the same transaction would be # to save & restore the Transaction object, but there's no documented # way to save a Transaction to disk. # # So far, though, the above assumption seems to hold. So... onward! # add the downloaded RPMs to the sack errs = [] for pkgspec in self.state.remove_packages.keys(): try: self.base.remove(pkgspec) except dnf.exceptions.MarkingError: msg = _('Unable to match package: %s') logger.info(msg, self.base.output.term.bold(pkgspec)) errs.append(pkgspec) for repo_id, pkg_spec_dict in self.state.install_packages.items(): for pkgspec in pkg_spec_dict.keys(): try: self.base.install(pkgspec, reponame=repo_id) except dnf.exceptions.MarkingError: msg = _('Unable to match package: %s') logger.info(msg, self.base.output.term.bold(pkgspec + " " + repo_id)) errs.append(pkgspec) if errs: raise dnf.exceptions.MarkingError(_("Unable to match some of packages"))
def check_upgrade(self): if not self.state.upgrade_status == 'ready': raise CliError( # Translators: do not change "reboot" here _("use 'dnf system-upgrade reboot' to begin the upgrade")) if os.readlink(MAGIC_SYMLINK) != DEFAULT_DATADIR: logger.info(_("another upgrade tool is running. exiting quietly.")) raise SystemExit(0) # Delete symlink ASAP to avoid reboot loops dnf.yum.misc.unlink_f(MAGIC_SYMLINK)
def run_clean(self): logger.info(_("Cleaning up downloaded data...")) clear_dir(self.base.conf.cachedir) if self.base.conf.destdir: clear_dir(self.base.conf.destdir) with self.state as state: state.download_status = None state.upgrade_status = None state.destdir = None state.install_packages = {}
def run_clean(self): logger.info(_("Cleaning up downloaded data...")) # Don't delete persistor, it contains paths for downloaded packages # that are used by dnf during finalizing base to clean them up clear_dir( self.base.conf.cachedir, [dnf.persistor.TempfilePersistor(self.base.conf.cachedir).db_path]) with self.state as state: state.download_status = None state.state_version = None state.upgrade_status = None state.upgrade_command = None state.destdir = None
def run(self, args): cmd = 'list' if args: if args[0] not in ALL_CMDS: cmd = 'add' elif args[0] in EXC_CMDS: cmd = 'exclude' args = args[1:] elif args[0] in DEL_CMDS: cmd = 'delete' args = args[1:] else: cmd = args[0] args = args[1:] if cmd == 'add': _write_locklist(self.base, args, True, "\n# Added locks on %s\n" % time.ctime(), ADDING_SPEC, '') elif cmd == 'exclude': _write_locklist(self.base, args, False, "\n# Added exclude on %s\n" % time.ctime(), EXCLUDING_SPEC, '!') elif cmd == 'list': for pat in _read_locklist(): logger.info(pat) elif cmd == 'clear': with open(locklist_fn, 'w') as f: # open in write mode truncates file pass elif cmd == 'delete': dirname = os.path.dirname(locklist_fn) (out, tmpfilename) = tempfile.mkstemp(dir=dirname, suffix='.tmp') locked_specs = _read_locklist() count = 0 with os.fdopen(out, 'w', -1) as out: for ent in locked_specs: if _match(ent, args): logger.info("%s %s", DELETING_SPEC, ent) count += 1 continue out.write(ent) out.write('\n') if not count: os.unlink(tmpfilename) else: os.chmod(tmpfilename, 0o644) os.rename(tmpfilename, locklist_fn)
def check_upgrade(self): if not os.path.lexists(MAGIC_SYMLINK): logger.info(_("trigger file does not exist. exiting quietly.")) raise SystemExit(0) if os.readlink(MAGIC_SYMLINK) != DEFAULT_DATADIR: logger.info(_("another upgrade tool is running. exiting quietly.")) raise SystemExit(0) # Delete symlink ASAP to avoid reboot loops dnf.yum.misc.unlink_f(MAGIC_SYMLINK) command = self.state.upgrade_command if not command: command = self.opts.command self._check_state_version(command) if not self.state.upgrade_status == 'ready': msg = _("use 'dnf {command} reboot' to begin the upgrade").format(command=command) raise CliError(msg)
def transaction_download(self): transaction = self.base.history.get_current() if not transaction.packages(): logger.info( _("The system-upgrade transaction is empty, your system is already up-to-date." )) return data = serialize_transaction(transaction) try: with open(self.transaction_file, "w") as f: json.dump(data, f, indent=4, sort_keys=True) f.write("\n") print(_("Transaction saved to {}.").format(self.transaction_file)) except OSError as e: raise dnf.cli.CliError( _('Error storing transaction: {}').format(str(e))) # Okay! Write out the state so the upgrade can use it. system_ver = dnf.rpm.detect_releasever(self.base.conf.installroot) with self.state as state: state.download_status = 'complete' state.state_version = STATE_VERSION state.distro_sync = self.opts.distro_sync state.gpgcheck = self.base.conf.gpgcheck state.gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.gpgcheck ] state.repo_gpgcheck_repos = [ repo.id for repo in self.base.repos.values() if repo.repo_gpgcheck ] state.system_releasever = system_ver state.target_releasever = self.base.conf.releasever state.module_platform_id = self.base.conf.module_platform_id state.enable_disable_repos = self.opts.repos_ed state.destdir = self.base.conf.destdir state.upgrade_command = self.opts.command msg = DOWNLOAD_FINISHED_MSG.format(command=self.opts.command) logger.info(msg) self.log_status(_("Download finished."), DOWNLOAD_FINISHED_ID)
def _write_locklist(base, args, try_installed, comment, info, prefix): specs = set() for pat in args: subj = dnf.subject.Subject(pat) pkgs = None if try_installed: pkgs = subj.get_best_query(dnf.sack._rpmdb_sack(base)) if not pkgs: pkgs = subj.get_best_query(base.sack) if not pkgs: logger.info("%s %s", NOTFOUND_SPEC, pat) for pkg in pkgs: specs.add(pkgtup2spec(*pkg.pkgtup)) with open(locklist_fn, 'a') as f: f.write(comment) for spec in specs: logger.info("%s %s", info, spec) f.write("%s%s\n" % (prefix, spec))
def _write_locklist(base, args, try_installed, comment, info, prefix): specs = set() for pat in args: subj = dnf.subject.Subject(pat) pkgs = None if try_installed: pkgs = subj.get_best_query(dnf.sack.rpmdb_sack(base)) if not pkgs: pkgs = subj.get_best_query(base.sack) if not pkgs: logger.info("%s %s", NOTFOUND_SPEC, pat) for pkg in pkgs: specs.add(pkgtup2spec(*pkg.pkgtup)) with open(locklist_fn, 'a') as f: f.write(comment) for spec in specs: logger.info("%s %s", info, spec) f.write("%s%s\n" % (prefix, spec))
def transaction_download(self): # sanity check: we got a kernel, right? downloads = self.cli.base.transaction.install_set if not any(p.name.startswith('kernel') for p in downloads): raise CliError(NO_KERNEL_MSG) install_packages = {} for pkg in downloads: install_packages.setdefault(pkg.repo.id, []).append(str(pkg)) # Okay! Write out the state so the upgrade can use it. system_ver = dnf.rpm.detect_releasever(self.base.conf.installroot) with self.state as state: state.download_status = 'complete' state.distro_sync = self.opts.distro_sync state.allow_erasing = self.cli.demands.allow_erasing state.best = self.base.conf.best state.system_releasever = system_ver state.target_releasever = self.base.conf.releasever state.install_packages = install_packages state.enable_disable_repos = self.opts.repos_ed logger.info(DOWNLOAD_FINISHED_MSG) self.log_status(_("Download finished."), DOWNLOAD_FINISHED_ID)
def reboot(): if os.getenv("DNF_SYSTEM_UPGRADE_NO_REBOOT", default=False): logger.info(_("Reboot turned off, not rebooting.")) else: Popen(["systemctl", "reboot"])