#!/usr/bin/python3 # Copyright (c) 2005-2012 Canonical Ltd # # AUTHOR: # Michael Vogt # # This file is part of unattended-upgrades # # unattended-upgrades is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as published # by the Free Software Foundation; either version 2 of the License, or (at # your option) any later version. # # unattended-upgrades is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with unattended-upgrades; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # import copy import datetime import errno import email.charset import fcntl import fnmatch import gettext import locale import logging import re import os import select import signal import string import subprocess import sys from email.message import Message from gettext import gettext as _ from io import StringIO from optparse import ( OptionParser, SUPPRESS_HELP, ) from subprocess import ( Popen, PIPE, ) import apt import apt_inst import apt_pkg # the reboot required flag file used by packages REBOOT_REQUIRED_FILE = "/var/run/reboot-required" MAIL_BINARY = "/usr/bin/mail" SENDMAIL_BINARY = "/usr/sbin/sendmail" # no py3 lsb_release in debian :/ DISTRO_CODENAME = subprocess.check_output( ["lsb_release", "-c", "-s"], universal_newlines=True).strip() DISTRO_ID = subprocess.check_output( ["lsb_release", "-i", "-s"], universal_newlines=True).strip() # progress information is written here PROGRESS_LOG = "/var/run/unattended-upgrades.progress" PID_FILE = "/var/run/unattended-upgrades.pid" # set from the sigint signal handler SIGNAL_STOP_REQUEST = False class UnknownMatcherError(ValueError): pass class UnattendedUpgradesCache(apt.Cache): def __init__(self, rootdir, allowed_origins): apt.Cache.__init__(self, rootdir=rootdir) self.allowed_origins = allowed_origins # ensure we update the candidate versions self.adjust_candidate_versions() def clear(self): apt.Cache.clear(self) # ensure we update the candidate versions self.adjust_candidate_versions() def adjust_candidate_versions(self): """ Adjust candidate versions to match highest allowed origin This adjusts the origin even if the candidate has a higher version """ for pkg in self: # important! this avoids downgrades below if not pkg.is_upgradable: continue # check if the candidate is already pointing to a allowed # origin and if so, do not mess with it if is_allowed_origin(pkg.candidate, self.allowed_origins): continue # check if we have a version in a allowed origin that is # not the candidate new_cand = None for ver in pkg.versions: # ignore versions that the user marked with priority < 0 # (and ensure we have a python-apt that supports this) if hasattr(ver, "policy_priority") and ver.policy_priority < 0: logging.debug("ignoring ver '%s' with priority < 0" % ver) continue if is_allowed_origin(ver, self.allowed_origins): # leave as soon as we have the highest new candidate new_cand = ver break if new_cand and new_cand != pkg.candidate: logging.debug("adjusting candidate version: '%s'" % new_cand) pkg.candidate = new_cand class LogInstallProgress(apt.progress.base.InstallProgress): """ Install progress that writes to self.progress_log (/var/run/unattended-upgrades.progress by default) """ def __init__(self, logfile_dpkg, verbose=False, progress_log="var/run/unattended-upgrades.progress"): apt.progress.base.InstallProgress.__init__(self) self.logfile_dpkg = logfile_dpkg self.progress_log = os.path.join(apt_pkg.config.find_dir("Dir"), progress_log) self.verbose = verbose self.output_logfd = None def status_change(self, pkg, percent, status): with open(self.progress_log, "w") as f: f.write(_("Progress: %s %% (%s)") % (percent, pkg)) def _fixup_fds(self): required_fds = [0, 1, 2, # stdin, stdout, stderr self.writefd, self.write_stream.fileno(), self.statusfd, self.status_stream.fileno() ] # ensure that our required fds close on exec for fd in required_fds[3:]: old_flags = fcntl.fcntl(fd, fcntl.F_GETFD) fcntl.fcntl(fd, fcntl.F_SETFD, old_flags | fcntl.FD_CLOEXEC) # close all fds proc_fd = "/proc/self/fd" if os.path.exists(proc_fd): error_count = 0 for fdname in os.listdir(proc_fd): try: fd = int(fdname) except Exception as e: print("ERROR: can not get fd for '%s'" % fdname) if fd in required_fds: continue try: os.close(fd) #print("closed: ", fd) except OSError as e: # there will be one fd that can not be closed # as its the fd from pythons internal diropen() # so its ok to ignore one close error error_count += 1 if error_count > 1: print("ERROR: os.close(%s): %s" % (fd, e)) def _redirect_stdin(self): REDIRECT_INPUT = os.devnull fd = os.open(REDIRECT_INPUT, os.O_RDWR) os.dup2(fd, 0) def _redirect_output(self): # do not create log in dry-run mode, just output to stdout/stderr if not apt_pkg.config.find_b("Debug::pkgDPkgPM", False): logfd = os.open(self.logfile_dpkg, os.O_RDWR | os.O_CREAT, 0o644) os.dup2(logfd, 1) os.dup2(logfd, 2) def update_interface(self): # call super class first apt.progress.base.InstallProgress.update_interface(self) self._do_verbose_output_if_needed() def _do_verbose_output_if_needed(self): # if we are in debug mode, nothing to be more verbose about if apt_pkg.config.find_b("Debug::pkgDPkgPM", False): return # handle verbose if self.verbose: if self.output_logfd is None: self.output_logfd = os.open(self.logfile_dpkg, os.O_RDONLY) try: select.select([self.output_logfd], [], [], 0) except select.error as e: if e.errno != errno.EINTR: logging.exception("select failed") # output to stdout in verbose mode only os.write(1, os.read(self.output_logfd, 1024)) def fork(self): pid = os.fork() if pid == 0: self._fixup_fds() self._redirect_stdin() self._redirect_output() return pid class Unlocked: """ Context manager for unlocking the apt lock while cache.commit() is run """ def __enter__(self): try: apt_pkg.pkgsystem_unlock() except: pass def __exit__(self, exc_type, exc_value, exc_tb): try: apt_pkg.pkgsystem_unlock() except: pass def is_dpkg_journal_dirty(): """ Return True if the dpkg journal is dirty (similar to debSystem::CheckUpdates) """ d = os.path.join( os.path.dirname(apt_pkg.config.find_file("Dir::State::status")), "updates") for f in os.listdir(d): if re.match("[0-9]+", f): return True return False def signal_handler(signal, frame): logging.warning("SIGUSR1 received, will stop") global SIGNAL_STOP_REQUEST SIGNAL_STOP_REQUEST = True def substitute(line): """ substitude known mappings and return a new string Currently supported ${distro-release} """ mapping = {"distro_codename": get_distro_codename(), "distro_id": get_distro_id()} return string.Template(line).substitute(mapping) def get_distro_codename(): return DISTRO_CODENAME def get_distro_id(): return DISTRO_ID def get_allowed_origins_legacy(): """ legacy support for old Allowed-Origins var """ allowed_origins = [] for s in apt_pkg.config.value_list("Unattended-Upgrade::Allowed-Origins"): # if there is a ":" use that as seperator, else use spaces if ":" in s: (distro_id, distro_codename) = s.split(':') else: (distro_id, distro_codename) = s.split() # escape "," (see LP: #824856) - i wonder if there is a simpler way? distro_id = re.sub(r'([^\\]),', r'\1\\,', distro_id) distro_codename = re.sub(r'([^\\]),', r'\1\\,', distro_codename) # convert to new format allowed_origins.append("o=%s,a=%s" % (substitute(distro_id), substitute(distro_codename))) return allowed_origins def get_allowed_origins(): """ return a list of allowed origins from apt.conf This will take substitutions (like distro_id) into account. """ allowed_origins = get_allowed_origins_legacy() for s in apt_pkg.config.value_list("Unattended-Upgrade::Origins-Pattern"): allowed_origins.append(substitute(s)) return allowed_origins def match_whitelist_string(whitelist, origin): """ take a whitelist string in the form "origin=Debian,label=Debian-Security" and match against the given python-apt origin. A empty whitelist string never matches anything. """ whitelist = whitelist.strip() if whitelist == "": logging.warning("empty match string matches nothing") return False res = True # make "\," the html quote equivalent whitelist = whitelist.replace("\,", "%2C") for token in whitelist.split(","): # strip and unquote the "," back (what, value) = [s.strip().replace("%2C", ",") for s in token.split("=")] #logging.debug("matching '%s'='%s' against '%s'" % ( # what, value, origin)) # support substitution here as well value = substitute(value) # first char is apt-cache policy output, send is the name # in the Release file if what in ("o", "origin"): res &= fnmatch.fnmatch(origin.origin, value) elif what in ("l", "label"): res &= fnmatch.fnmatch(origin.label, value) elif what in ("a", "suite", "archive"): res &= fnmatch.fnmatch(origin.archive, value) elif what in ("c", "component"): res &= fnmatch.fnmatch(origin.component, value) elif what in ("site",): res &= fnmatch.fnmatch(origin.site, value) elif what in ("n", "codename",): res &= fnmatch.fnmatch(origin.codename, value) else: raise UnknownMatcherError( "Unknown whitelist entry for macher '%s' (token '%s')" % ( what, token)) logging.debug("matching '%s'='%s' against '%s'" % ( what, value, origin)) return res def cache_commit(cache, logfile_dpkg, verbose, iprogress=None): """Commit the changes from the given cache to the system""" # set debconf to NON_INTERACTIVE, redirect output os.putenv("DEBIAN_FRONTEND", "noninteractive") # only act if there is anything to do (important to avoid writing # empty log stanzas) if len(cache.get_changes()) == 0: return True, None error = None res = False if iprogress is None: iprogress = LogInstallProgress(logfile_dpkg, verbose) try: with Unlocked(): res = cache.commit(install_progress=iprogress) except SystemError as e: error = e if verbose: logging.exception("Exception happened during upgrade.") return res, error def upgrade_normal(cache, logfile_dpkg, verbose): res, error = cache_commit(cache, logfile_dpkg, verbose) if res: logging.info(_("All upgrades installed")) else: logging.error(_("Installing the upgrades failed!")) logging.error(_("error message: '%s'"), error) logging.error(_("dpkg returned a error! See '%s' for details"), logfile_dpkg) return res def upgrade_in_minimal_steps(cache, pkgs_to_upgrade, blacklist, logfile_dpkg="", verbose=False): install_log = LogInstallProgress(logfile_dpkg, verbose) install_log.progress_log += ".minimal-steps" # setup signal handler signal.signal(signal.SIGUSR1, signal_handler) # double check any changes we do allowed_origins = get_allowed_origins() # to upgrade contains the package names to_upgrade = set(pkgs_to_upgrade) while True: # find smallest set smallest_partition = to_upgrade for pkgname in to_upgrade: if SIGNAL_STOP_REQUEST: logging.warning("SIGNAL received, stopping") return True pkg = cache[pkgname] if pkg.is_upgradable: pkg.mark_upgrade() elif not pkg.is_installed: pkg.mark_install() else: continue # double check that we are not running into side effects like # what could have been caused LP: #1020680 if not check_changes_for_sanity(cache, allowed_origins, blacklist): logging.error( "Internal error while building a minimal partition." "Cache has not allowed changes") return False changes = [p.name for p in cache.get_changes()] if not changes: continue if len(changes) == 1: logging.debug("found leaf package %s" % pkg.name) smallest_partition = changes break if len(changes) < len(smallest_partition): logging.debug("found partition of size %s (%s)" % ( len(changes), changes)) smallest_partition = changes cache.clear() # write progress log information if len(pkgs_to_upgrade) > 0: percent = ((len(pkgs_to_upgrade) - len(to_upgrade)) / float(len(pkgs_to_upgrade)) * 100.0) else: percent = 100.0 install_log.status_change(pkg=",".join(smallest_partition), percent=percent, status="") # apply changes logging.debug("applying set %s" % smallest_partition) rewind_cache(cache, [cache[name] for name in smallest_partition]) res, error = cache_commit(cache, logfile_dpkg, verbose, install_log) if error: logging.error(_("Installing the upgrades failed!")) logging.error(_("error message: '%s'") % error) logging.error(_("dpkg returned a error! See '%s' for details") % logfile_dpkg) return False to_upgrade = to_upgrade - set(smallest_partition) logging.debug("left to upgrade %s" % to_upgrade) if len(to_upgrade) == 0: logging.info(_("All upgrades installed")) break return True def is_allowed_origin(ver, allowed_origins): if not ver: return False for origin in ver.origins: for allowed in allowed_origins: if match_whitelist_string(allowed, origin): return True return False def is_pkgname_in_blacklist(pkgname, blacklist): for blacklist_regexp in blacklist: if re.match(blacklist_regexp, pkgname): logging.debug("skipping blacklisted package '%s'" % pkgname) return True return False def check_changes_for_sanity(cache, allowed_origins, blacklist): if cache._depcache.broken_count != 0: return False for pkg in cache: if pkg.marked_delete: logging.debug("pkg '%s' now marked delete" % pkg.name) return False if pkg.marked_install or pkg.marked_upgrade: # apt will never fallback from a trusted to a untrusted # origin so its good enough if we have a single trusted one if not any([o.trusted for o in pkg.candidate.origins]): logging.debug("pkg '%s' is untrusted" % pkg.name) return False if not is_allowed_origin(pkg.candidate, allowed_origins): logging.debug("pkg '%s' not in allowed origin" % pkg.name) return False if is_pkgname_in_blacklist(pkg.name, blacklist): return False if pkg._pkg.selected_state == apt_pkg.SELSTATE_HOLD: logging.debug("pkg '%s' is on hold" % pkg.name) return False # check if the package is unsafe to upgrade unattended ignore_require_restart = apt_pkg.config.find_b( "Unattended-Upgrade::IgnoreAppsRequireRestart", False) upgrade_requires = pkg.candidate.record.get("Upgrade-Requires") if (pkg.marked_upgrade and ignore_require_restart is False and upgrade_requires == "app-restart"): logging.debug("pkg '%s' requires app-restart, not safe to " "upgrade unattended") return False return True def pkgname_from_deb(debfile): # FIXME: add error checking here try: control = apt_inst.DebFile(debfile).control.extractdata("control") sections = apt_pkg.TagSection(control) return sections["Package"] except (IOError, SystemError) as e: logging.error("failed to read deb file '%s' (%s)" % (debfile, e)) # dumb fallback return debfile.split("_")[0] def get_md5sum_for_file_in_deb(deb_file, conf_file): dpkg_cmd = ["dpkg-deb", "--fsys-tarfile", deb_file] tar_cmd = ["tar", "-x", "-O", "-f", "-", "." + conf_file] md5_cmd = ["md5sum"] dpkg_p = Popen(dpkg_cmd, stdout=PIPE) tar_p = Popen(tar_cmd, stdin=dpkg_p.stdout, stdout=PIPE, universal_newlines=True) md5_p = Popen(md5_cmd, stdin=tar_p.stdout, stdout=PIPE, universal_newlines=True) pkg_md5sum = md5_p.communicate()[0].split()[0] return pkg_md5sum # prefix is *only* needed for the build-in tests def conffile_prompt(destFile, prefix=""): logging.debug("check_conffile_prompt('%s')" % destFile) pkgname = pkgname_from_deb(destFile) # get the conffiles for the /var/lib/dpkg/status file status_file = apt_pkg.config.find("Dir::State::status") tagfile = apt_pkg.TagFile(open(status_file, "r")) conffiles = "" for section in tagfile: if section.get("Package") == pkgname: logging.debug("found pkg: %s" % pkgname) if "Conffiles" in section: conffiles = section.get("Conffiles") break # get conffile value from pkg, its ok if the new version # does not have conffiles anymore pkg_conffiles = "" deb = apt_inst.DebFile(destFile) try: pkg_conffiles = deb.control.extractdata("conffiles").strip().decode( "utf-8") except LookupError as e: logging.debug("No conffiles in deb '%s' (%s)" % (destFile, e)) # Conffiles: # /etc/bash_completion.d/m-a c7780fab6b14d75ca54e11e992a6c11c dpkg_status_conffiles = {} for line in conffiles.splitlines(): # ignore empty lines line = line.strip() if not line: continue # show what we do logging.debug("conffile line: '%s'", line) l = line.split() conf_file = l[0] md5 = l[1] if len(l) > 2: obs = l[2] else: obs = None # ignore if conffile is obsolete or does not exist if obs == "obsolete" or not os.path.exists(prefix + conf_file): continue # ignore state "newconffile" until its clearer if there # might be a dpkg prompt (LP: #936870) if md5 == "newconffile": continue if not pkg_conffiles or not conf_file in pkg_conffiles.split("\n"): logging.debug("'%s' not in package conffiles '%s'" % ( conf_file, pkg_conffiles)) continue # record for later dpkg_status_conffiles[conf_file] = md5 # test against the installed file with open(prefix + conf_file, 'rb') as fb: current_md5 = apt_pkg.md5sum(fb) logging.debug("current md5: %s" % current_md5) # hashes are the same, no conffile prompt if current_md5 == md5: continue # calculate md5sum from the deb (may take a bit) pkg_md5sum = get_md5sum_for_file_in_deb(destFile, conf_file) logging.debug("pkg_md5sum: %s" % pkg_md5sum) # the md5sum in the deb is unchanged, this will not # trigger a conffile prompt if pkg_md5sum == md5: continue # if we made it to this point: # current_md5 != pkg_md5sum != md5 # and that will trigger a conffile prompt, we can # stop processing at this point and just return True return True # now check if there are conffiles in the pkg that where not there # in the previous version in the dpkg status file if pkg_conffiles: for conf_file in pkg_conffiles.split("\n"): if (not conf_file in dpkg_status_conffiles and os.path.exists(prefix + conf_file)): logging.debug("found conffile '%s' in new pkg but on dpkg " "status" % conf_file) pkg_md5sum = get_md5sum_for_file_in_deb(destFile, conf_file) with open(prefix + conf_file, 'rb') as fp: if pkg_md5sum != apt_pkg.md5sum(fp): return True return False def dpkg_conffile_prompt(): if not "DPkg::Options" in apt_pkg.config: return True options = apt_pkg.config.value_list("DPkg::Options") for option in options: option = option.strip() if option in ["--force-confold", "--force-confnew"]: return False return True def rewind_cache(cache, pkgs_to_upgrade): " set the cache back to the state with packages_to_upgrade " cache.clear() for pkg2 in pkgs_to_upgrade: pkg2.mark_upgrade() def host(): return os.uname()[1] # *sigh* textwrap is nice, but it breaks "linux-image" into two # seperate lines def wrap(t, width=70, subsequent_indent=""): out = "" for s in t.split(): if (len(out) - out.rfind("\n")) + len(s) > width: out += "\n" + subsequent_indent out += s + " " return out def setup_apt_listchanges(conf="/etc/apt/listchanges.conf"): """ deal with apt-listchanges """ # apt-listchanges will always send a mail if there is a mail address # set in the config regardless of the frontend used, so set it to # mail if we have a sendmail and to none if not (as it appears to # not check if sendmail is there or not), debian bug #579733 if os.path.exists(SENDMAIL_BINARY): os.environ["APT_LISTCHANGES_FRONTEND"] = "mail" else: os.environ["APT_LISTCHANGES_FRONTEND"] = "none" def _send_mail_using_mailx(to_address, subject, body): # ensure that the body is a byte stream and that we do not # break on encoding errors (the default error mode is "strict") encoded_body = body.encode( locale.getpreferredencoding(False), errors="replace") # we use a binary pipe to stdin to ensure we do not break on # unicode encoding errors (e.g. because the user is running a # ascii only system like the buildds) mail = subprocess.Popen( [MAIL_BINARY, "-s", subject, to_address], stdin=subprocess.PIPE, universal_newlines=False) mail.stdin.write(encoded_body) mail.stdin.close() ret = mail.wait() return ret def _send_mail_using_sendmail(to_address, subject, body): # format as a proper mail msg = Message() msg['Subject'] = subject msg['To'] = to_address # order is important here, Message() first, then Charset() # then msg.set_charset() charset = email.charset.Charset("utf-8") charset.body_encoding = email.charset.QP msg.set_payload(body, charset) # and send it away sendmail = subprocess.Popen( [SENDMAIL_BINARY, "-oi", "-t"], stdin=subprocess.PIPE, universal_newlines=True) sendmail.stdin.write(msg.as_string()) sendmail.stdin.close() ret = sendmail.wait() return ret def send_summary_mail(pkgs, res, pkgs_kept_back, mem_log, logfile_dpkg): " send mail (if configured in Unattended-Upgrade::Mail) " to_email = apt_pkg.config.find("Unattended-Upgrade::Mail", "") if not to_email: return if not os.path.exists(MAIL_BINARY) and not os.path.exists(SENDMAIL_BINARY): logging.error(_("No '/usr/bin/mail' or '/usr/sbin/sendmail'," "can not send mail. " "You probably want to install the 'mailx' package.")) return # if the operation was successful and the user has requested to get # mails on on errors, just exit here if (res and apt_pkg.config.find_b( "Unattended-Upgrade::MailOnlyOnError", False)): return # Check if reboot-required flag is present logging.debug("Sending mail with '%s' to '%s'" % (logfile_dpkg, to_email)) if os.path.isfile(REBOOT_REQUIRED_FILE): subject = _( "[reboot required] unattended-upgrades result for '%s': %s") % ( host(), res) else: subject = _("unattended-upgrades result for '%s': '%s'") % ( host(), res) body = _("Unattended upgrade returned: %s\n\n") % res if os.path.isfile(REBOOT_REQUIRED_FILE): body += _( "Warning: A reboot is required to complete this upgrade.\n\n") if res: body += _("Packages that were upgraded:\n") else: body += _("Packages that attempted to upgrade:\n") body += " " + wrap(pkgs, 70, " ") body += "\n" if pkgs_kept_back: body += _("Packages with upgradable origin but kept back:\n") body += " " + wrap(" ".join(pkgs_kept_back), 70, " ") body += "\n" body += "\n" if os.path.exists(logfile_dpkg): body += _("Package installation log:") + "\n" with open(logfile_dpkg) as fp: body += fp.read() body += "\n\n" body += _("Unattended-upgrades log:\n") body += mem_log.getvalue() if os.path.exists(SENDMAIL_BINARY): ret = _send_mail_using_sendmail(to_email, subject, body) elif os.path.exists(MAIL_BINARY): ret = _send_mail_using_mailx(to_email, subject, body) else: raise AssertionError( "This should never be reached, if we are here we either " "have sendmail or mailx. Please report this as a bug.") logging.debug("mail returned: %s" % ret) def do_install(cache, pkgs_to_upgrade, blacklisted_pkgs, options, logfile_dpkg): # set debconf to NON_INTERACTIVE, redirect output os.putenv("DEBIAN_FRONTEND", "noninteractive") setup_apt_listchanges() logging.info(_("Writing dpkg log to '%s'") % logfile_dpkg) pkg_install_success = False try: if (options.minimal_upgrade_steps or # COMPAT with the mispelling apt_pkg.config.find_b( "Unattended-Upgrades::MinimalSteps", False) or apt_pkg.config.find_b( "Unattended-Upgrade::MinimalSteps", False)): pidf = os.path.join(apt_pkg.config.find_dir("Dir"), "var", "run", "unattended-upgrades.pid") with open(pidf, "w") as fp: fp.write("%s" % os.getpid()) # try upgrade all "pkgs" in minimal steps pkg_install_success = upgrade_in_minimal_steps( cache, [pkg.name for pkg in pkgs_to_upgrade], blacklisted_pkgs, logfile_dpkg, options.verbose or options.debug) else: pkg_install_success = upgrade_normal( cache, logfile_dpkg, options.verbose or options.debug) except Exception as e: # print unhandled exceptions here this way, while stderr is redirected os.write(2, ("Exception: %s\n" % e).encode('utf-8')) pkg_install_success = False return pkg_install_success def _setup_alternative_rootdir(rootdir): # clear system unattended-upgrade stuff apt_pkg.config.clear("Unattended-Upgrade") # read rootdir (taken from apt.Cache, but we need to run it # here before the cache gets initialized if os.path.exists(rootdir + "/etc/apt/apt.conf"): apt_pkg.read_config_file(apt_pkg.config, rootdir + "/etc/apt/apt.conf") if os.path.isdir(rootdir + "/etc/apt/apt.conf.d"): apt_pkg.read_config_dir(apt_pkg.config, rootdir + "/etc/apt/apt.conf.d") logdir = os.path.join(rootdir, "var", "log", "unattended-upgrades") if not os.path.exists(logdir): os.makedirs(logdir) apt.apt_pkg.config.set("Unattended-Upgrade::LogDir", logdir) def _get_logdir(): logdir = apt_pkg.config.find_dir( "Unattended-Upgrade::LogDir", # COMPAT only apt_pkg.config.find_dir("APT::UnattendedUpgrades::LogDir", "/var/log/unattended-upgrades/")) return logdir def _setup_logging(options): # ensure this is run only once if len(logging.root.handlers) > 0: return # init the logging logdir = _get_logdir() logfile = os.path.join( logdir, apt_pkg.config.find( "Unattended-Upgrade::LogFile", # COMPAT only apt_pkg.config.find("APT::UnattendedUpgrades::LogFile", "unattended-upgrades.log"))) if not options.dry_run and not os.path.exists(logdir): os.makedirs(logdir) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s', filename=logfile) # additional logging logger = logging.getLogger() mem_log = StringIO() if options.apt_debug: apt_pkg.config.set("Debug::pkgProblemResolver", "1") apt_pkg.config.set("Debug::pkgDepCache::AutoInstall", "1") if options.debug: logger.setLevel(logging.DEBUG) stdout_handler = logging.StreamHandler(sys.stdout) logger.addHandler(stdout_handler) elif options.verbose: logger.setLevel(logging.INFO) stdout_handler = logging.StreamHandler(sys.stdout) logger.addHandler(stdout_handler) if apt_pkg.config.find("Unattended-Upgrade::Mail", ""): mem_log_handler = logging.StreamHandler(mem_log) logger.addHandler(mem_log_handler) return mem_log def get_blacklisted_pkgs(): return apt_pkg.config.value_list("Unattended-Upgrade::Package-Blacklist") def reboot_if_requested_and_needed(shutdown_lock=0): # auto-reboot (if required and the config for this is set if (apt_pkg.config.find_b( "Unattended-Upgrade::Automatic-Reboot", False) and os.path.exists(REBOOT_REQUIRED_FILE)): when = apt_pkg.config.find( "Unattended-Upgrade::Automatic-Reboot-Time", "now") if shutdown_lock > 0: os.close(shutdown_lock) logging.warning("Found %s, rebooting" % REBOOT_REQUIRED_FILE) # XXX: add time option subprocess.call(["/sbin/shutdown", "-r", when]) def write_stamp_file(): statedir = os.path.join(apt_pkg.config.find_dir("Dir::State"), "periodic") with open(os.path.join(statedir, "unattended-upgrades-stamp"), "w"): pass def get_auto_removable(cache): return set([pkg.name for pkg in cache if pkg.is_auto_removable]) def do_auto_remove(cache, options, logfile_dpkg, verbose=False): auto_removable = get_auto_removable(cache) for pkgname in auto_removable: logging.debug("marking %s for remove" % pkgname) cache[pkgname].mark_delete() logging.info(_("Packages that are auto removed: '%s'") % " ".join(auto_removable)) # do it res, error = cache_commit(cache, logfile_dpkg, verbose) if res: logging.info(_("Packages auto-removed")) else: logging.error(_("Auto-removing the packages failed!")) logging.error(_("Error message: '%s'") % error) logging.error(_("dpkg returned an error! See '%s' for details") % logfile_dpkg) return res def main(options, rootdir=""): # useful for testing if rootdir: _setup_alternative_rootdir(rootdir) # setup logging mem_log = _setup_logging(options) # format (origin, archive), e.g. ("Ubuntu","dapper-security") allowed_origins = get_allowed_origins() # pkgs that are (for some reason) not save to install blacklisted_pkgs = get_blacklisted_pkgs() logging.info(_("Initial blacklisted packages: %s"), " ".join(blacklisted_pkgs)) logging.info(_("Starting unattended upgrades script")) # display available origin logging.info(_("Allowed origins are: %s") % allowed_origins) # check if the journal is dirty and if so, take emergceny action # the alternative is to leave the system potentially unsecure until # the user comes in and fixes if (is_dpkg_journal_dirty() and apt_pkg.config.find_b( "Unattended-Upgrade::AutoFixInterruptedDpkg", True)): # ensure the dpkg database is not already locked (LP: #754330) admindir = os.path.dirname(apt_pkg.config.find("Dir::State::Status")) lockfd = apt_pkg.get_lock(os.path.join(admindir, "lock"), False) if lockfd > 0: logging.warning( _("Unclean dpkg state detected, trying to correct")) print(_("Unclean dpkg state detected, trying to correct")) env = copy.copy(os.environ) env["DEBIAN_FRONTEND"] = "noninteractive" try: os.close(lockfd) output = subprocess.check_output( ["dpkg", "--force-confold", "--configure", "-a"], env=env) except subprocess.CalledProcessError as e: output = e.output logging.warning(_("dpkg --configure -a output:\n%s" % output)) else: logging.debug("Unclean dpkg state, but locked, another package " "manager working?") # check and get lock try: apt_pkg.pkgsystem_lock() except SystemError as e: logging.error(_("Lock could not be acquired (another package " "manager running?)")) print(_("Cache lock can not be acquired, exiting")) sys.exit(1) # get a cache cache = UnattendedUpgradesCache(rootdir=rootdir, allowed_origins=allowed_origins) if cache._depcache.broken_count > 0: print(_("Cache has broken packages, exiting")) logging.error(_("Cache has broken packages, exiting")) sys.exit(1) # FIXME: make this into a ContextManager # be nice when calculating the upgrade as its pretty CPU intensive old_priority = os.nice(0) try: # Check that we will be able to restore the priority os.nice(-1) os.nice(20) except OSError as e: if e.errno in (errno.EPERM, errno.EACCES): pass else: raise # speed things up with latest apt actiongroup = apt_pkg.ActionGroup(cache._depcache) actiongroup # pyflakes # find out about the packages that are upgradable (in a allowed_origin) pkgs_to_upgrade = [] pkgs_kept_back = [] # now do the actual upgrade for pkg in cache: if options.debug and pkg.is_upgradable: logging.debug("Checking: %s (%s)" % ( pkg.name, getattr(pkg.candidate, "origins", []))) if (pkg.is_upgradable and not is_pkgname_in_blacklist(pkg.name, blacklisted_pkgs) and is_allowed_origin(pkg.candidate, allowed_origins)): try: pkg.mark_upgrade() if check_changes_for_sanity(cache, allowed_origins, blacklisted_pkgs): # add to packages to upgrade pkgs_to_upgrade.append(pkg) # re-eval pkgs_kept_back as the resolver may fail to # directly upgrade a pkg, but that may work during # a subsequent operation, see debian bug #639840 for pkgname in pkgs_kept_back: if (cache[pkgname].marked_install or cache[pkgname].marked_upgrade): pkgs_kept_back.remove(pkgname) pkgs_to_upgrade.append(cache[pkgname]) else: logging.debug("sanity check failed") rewind_cache(cache, pkgs_to_upgrade) pkgs_kept_back.append(pkg.name) except SystemError as e: # can't upgrade logging.warning( _("package '%s' upgradable but fails to " "be marked for upgrade (%s)") % (pkg.name, e)) rewind_cache(cache, pkgs_to_upgrade) pkgs_kept_back.append(pkg.name) pkgs_to_upgrade.sort(key=lambda p: p.name) pkgs = "\n".join([pkg.name for pkg in pkgs_to_upgrade]) logging.debug("pkgs that look like they should be upgraded: %s" % pkgs) # FIXME: make this into a ContextManager # stop being nice os.nice(old_priority - os.nice(0)) # download what looks good if options.debug: fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress()) else: fetcher = apt_pkg.Acquire() list = apt_pkg.SourceList() list.read_main_list() recs = cache._records pm = apt_pkg.PackageManager(cache._depcache) try: pm.get_archives(fetcher, list, recs) except SystemError as e: logging.error(_("GetArchives() failed: '%s'") % e) res = fetcher.run() logging.debug("fetch.run() result: %s" % res) if dpkg_conffile_prompt(): # now check the downloaded debs for conffile conflicts and build # a blacklist for item in fetcher.items: logging.debug("%s" % item) if item.status == item.STAT_ERROR: print(_("An error occurred: '%s'") % item.error_text) logging.error(_("An error occurred: '%s'") % item.error_text) if not item.complete: print(_("The URI '%s' failed to download, aborting") % item.desc_uri) logging.error(_("The URI '%s' failed to download, aborting") % item.desc_uri) sys.exit(1) if not os.path.exists(item.destfile): print(_("Download finished, but file '%s' not there?!?" % item.destfile)) logging.error("Download finished, but file '%s' not " "there?!?" % item.destfile) sys.exit(1) if not item.is_trusted: blacklisted_pkgs.append(pkgname_from_deb(item.destfile)) if conffile_prompt(item.destfile): # skip package (means to re-run the whole marking again # and making sure that the package will not be pulled in by # some other package again!) # # print to stdout to ensure that this message is part of # the cron mail (only if no summary mail is requested) email = apt_pkg.config.find("Unattended-Upgrade::Mail", "") if not email: print(_("Package '%s' has conffile prompt and needs " "to be upgraded manually") % pkgname_from_deb(item.destfile)) # log to the logfile logging.warning(_("Package '%s' has conffile prompt and " "needs to be upgraded manually") % pkgname_from_deb(item.destfile)) blacklisted_pkgs.append(pkgname_from_deb(item.destfile)) pkgs_kept_back.append(pkgname_from_deb(item.destfile)) # redo the selection about the packages to upgrade based on the new # blacklist logging.debug("blacklist: %s" % blacklisted_pkgs) # find out about the packages that are upgradable (in a allowed_origin) if len(blacklisted_pkgs) > 0: cache.clear() old_pkgs_to_upgrade = pkgs_to_upgrade[:] pkgs_to_upgrade = [] for pkg in old_pkgs_to_upgrade: logging.debug("Checking (blacklist): %s" % (pkg.name)) pkg.mark_upgrade() if check_changes_for_sanity(cache, allowed_origins, blacklisted_pkgs): pkgs_to_upgrade.append(pkg) else: if not (pkg.name in pkgs_kept_back): pkgs_kept_back.append(pkg.name) logging.info(_("package '%s' not upgraded") % pkg.name) cache.clear() for pkg2 in pkgs_to_upgrade: pkg2.mark_upgrade() else: logging.debug("dpkg is configured not to cause conffile prompts") # auto-removal if apt_pkg.config.find_b( "Unattended-Upgrade::Remove-Unused-Dependencies", False): pending_autoremovals = get_auto_removable(cache) else: pending_autoremovals = [] # exit if there is nothing to do and nothing to report if (len(pending_autoremovals) == 0 and len(pkgs_to_upgrade) == 0 and len(pkgs_kept_back) == 0): logging.info(_("No packages found that can be upgraded unattended " "and no pending auto-removals")) # FIXME: DRY violation, write_stamp_file() is used below as well write_stamp_file() return # check if its configured for install on shutdown, if so, the # environment UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN will # be set by the unatteded-upgrades-shutdown script if (not "UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN" in os.environ and apt_pkg.config.find_b( "Unattended-Upgrade::InstallOnShutdown", False)): logger = logging.getLogger() logger.debug("Configured to install on shutdown, so exiting now") return # check if we are in dry-run mode if options.dry_run: logging.info("Option --dry-run given, *not* performing real actions") apt_pkg.config.set("Debug::pkgDPkgPM", "1") # do the install based on the new list of pkgs pkgs = " ".join([pkg.name for pkg in pkgs_to_upgrade]) logging.info(_("Packages that will be upgraded: %s" % pkgs)) # get log now = datetime.datetime.now() logfile_dpkg = os.path.join( _get_logdir(), 'unattended-upgrades-dpkg_%s.log' % now.isoformat('_')) # only perform install step if we actually have packages to install pkg_install_success = None shutdown_lock = -1 if len(pkgs_to_upgrade) > 0: # lock for the shutdown check - its fine if the system # is shutdown while downloading but not so much while installing shutdown_lock = apt_pkg.get_lock("/var/run/unattended-upgrades.lock") # do install pkg_install_success = do_install( cache, pkgs_to_upgrade, blacklisted_pkgs, options, logfile_dpkg) # remove unneeded packages if there are any if apt_pkg.config.find_b( "Unattended-Upgrade::Remove-Unused-Dependencies", False): cache = UnattendedUpgradesCache(rootdir=rootdir, allowed_origins=allowed_origins) if cache._depcache.broken_count > 0: print(_("Cache has broken packages, exiting")) logging.error(_("Cache has broken packages, exiting")) sys.exit(1) remove_success = do_auto_remove( cache, options, logfile_dpkg, options.verbose or options.debug) if pkg_install_success is not False: pkg_install_success = remove_success logging.debug("InstCount=%i DelCount=%i BrokenCount=%i" % (cache._depcache.inst_count, cache._depcache.del_count, cache._depcache.broken_count)) # send a mail (if needed) if not options.dry_run: send_summary_mail( pkgs, pkg_install_success, pkgs_kept_back, mem_log, logfile_dpkg) # FIXME: DRY violation, write_stamp_file() is used above as well # write timestamp file write_stamp_file() # check if the user wants a reboot if not options.dry_run: reboot_if_requested_and_needed(shutdown_lock) if __name__ == "__main__": localesApp = "unattended-upgrades" localesDir = "/usr/share/locale" gettext.bindtextdomain(localesApp, localesDir) gettext.textdomain(localesApp) # init the options parser = OptionParser() parser.add_option("-d", "--debug", action="store_true", default=False, help=_("print debug messages")) parser.add_option("", "--apt-debug", action="store_true", default=False, help=_("make apt/libapt print verbose debug messages")) parser.add_option("-v", "--verbose", action="store_true", default=False, help=_("print info messages")) parser.add_option("", "--dry-run", action="store_true", default=False, help=_("Simulation, download but do not install")) parser.add_option("", "--minimal-upgrade-steps", action="store_true", default=False, help=_("Upgrade in minimal steps (and allow " "interrupting with SIGINT")) parser.add_option("", "--minimal_upgrade_steps", action="store_true", help=SUPPRESS_HELP, default=False) (options, args) = parser.parse_args() if os.getuid() != 0: print(_("You need to be root to run this application")) sys.exit(1) # ensure that we are not killed when the terminal goes away e.g. on # shutdown signal.signal(signal.SIGHUP, signal.SIG_IGN) # run the main code main(options)