~ubuntu-core-dev/unattended-upgrades/ubuntu

# Copyright (c) 2005-2012 Canonical Ltd

#

# AUTHOR:

# along with unattended-upgrades; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#

import apt_inst

import apt_pkg

 

import copy

import datetime

import fcntl

import string

import sys

 

from optparse import OptionParser

from subprocess import Popen, PIPE

 

    LOG = PROGRESS_LOG 

 

    def status_change(self, pkg, percent, status):

 

    def _fixup_fds(self):

        required_fds = [ 0, 1, 2, # stdin, stdout, stderr

                try:

                    fd = int(fdname)

                except Exception as e:

                if fd in required_fds:

                    continue

                try:

                    os.close(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:

 

    def fork(self):

        pid = os.fork()

    try:

        with Unlocked():

            res = cache.commit(install_progress=iprogress)

        error = e

    if res:

        logging.info(_("All upgrades installed"))

                if not res:

                    raise Exception("cache.commit() returned false")

            cache.open()

            logging.error(_("Installing the upgrades failed!"))

            logging.error(_("error message: '%s'") % e)

            logging.error(_("dpkg returned a error! See '%s' for details") % \

        control = apt_inst.DebFile(debfile).control.extractdata("control")

        sections = apt_pkg.TagSection(control)

        return sections["Package"]

        logging.error("failed to read deb file '%s' (%s)" % (debfile, e))

        # dumb fallback

        return debfile.split("_")[0]

                conffiles = section.get("Conffiles")

                # Conffiles:

                # /etc/bash_completion.d/m-a c7780fab6b14d75ca54e11e992a6c11c

                    logging.debug("conffile line: %s", line)

                    conf_file = l[0]

                    md5 = l[1]

                    if len(l) > 2:

                    # does not have conffiles anymore

                    deb = apt_inst.DebFile(destFile)

                    try:

                    except LookupError as e:

                        logging.debug("No conffiles in %s anymore? (%s)" % (destFile, e))

                        pkg_conffiles = ""

                        logging.debug("'%s' not in package conffiles '%s'" % (conf_file, pkg_conffiles))

                        continue

                    # test against the installed file

                    logging.debug("current md5: %s" % current_md5)

                    # hashes are the same, no conffile prompt

                    if current_md5 == md5:

                    dpkg_cmd = ["dpkg-deb","--fsys-tarfile",destFile]

                    tar_cmd = ["tar","-x","-O", "-f","-", "."+conf_file]

                    md5_cmd = ["md5sum"]

                    logging.debug("pkg_md5sum: %s" % pkg_md5sum)

                    # the md5sum in the deb is unchanged, this will not 

                    # trigger a conffile prompt

    """ deal with apt-listchanges """

    if os.path.exists(conf):

        # check if mail is used by apt-listchanges

        cf.read(conf)

        if cf.has_section("apt") and cf.has_option("apt", "frontend"):

            frontend = cf.get("apt","frontend")

    # mails on on errors, just exit here

    if (res and

        apt_pkg.config.find_b("Unattended-Upgrade::MailOnlyOnError", False)):

    # Check if reboot-required flag is present

    logging.debug("Sending mail with '%s' to '%s'" % (logfile_dpkg, email))

    if os.path.isfile(REBOOT_REQUIRED_FILE):

        subject = _("[reboot required] unattended-upgrades result for '%s'") % host()

    else:

        subject = _("unattended-upgrades result for '%s'") % host()

    s = _("Unattended upgrade returned: %s\n\n") % res

    if os.path.isfile(REBOOT_REQUIRED_FILE):

        s += _("Warning: A reboot is required to complete this upgrade.\n\n")

    s += "\n"

    if os.path.exists(logfile_dpkg):

        s += _("Package installation log:")+"\n"

        s += "\n\n"

    s += _("Unattended-upgrades log:\n")

    s += mem_log.getvalue()

        old_stdout = 1

        old_stderr = 2

    else:

        old_stdout = os.dup(1)

        old_stderr = os.dup(2)

        os.dup2(fd,1)

            # COMPAT with the mispelling

            apt_pkg.config.find_b("Unattended-Upgrades::MinimalSteps", False) or

            apt_pkg.config.find_b("Unattended-Upgrade::MinimalSteps", False)):

            # try upgrade all "pkgs" in minimal steps

            pkg_install_success = upgrade_in_minimal_steps(

                cache, [pkg.name for pkg in pkgs_to_upgrade], logfile_dpkg)

        lockfd = apt_pkg.get_lock(os.path.join(admindir, "lock"), False)

        if lockfd > 0:

            logging.warning(_("Unclean dpkg state detected, trying to correct"))

            env = copy.copy(os.environ)

            env["DEBIAN_FRONTEND"] = "noninteractive"

            try:

    # check and get lock

    try:

        apt_pkg.pkgsystem_lock()

        logging.error(_("Lock could not be acquired (another package "

                        "manager running?)"))

        sys.exit(1)

 

    # get a cache

    cache = UnattendedUpgradesCache(rootdir=rootdir, 

                                    allowed_origins=allowed_origins)

    if cache._depcache.broken_count > 0:

        logging.error(_("Cache has broken packages, exiting"))

        sys.exit(1)

    # speed things up with latest apt

                    logging.debug("sanity check failed")

                    rewind_cache(cache, pkgs_to_upgrade)

                    pkgs_kept_back.append(pkg.name)

                # 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)

    pm = apt_pkg.PackageManager(cache._depcache)

    try:

        pm.get_archives(fetcher,list,recs)

        logging.error(_("GetArchives() failed: '%s'") % e)

    res = fetcher.run()

 

        for item in fetcher.items:

            logging.debug("%s" % item)

            if item.status == item.STAT_ERROR:

                logging.error(_("An error ocured: '%s'") % item.error_text)

            if not item.complete:

                logging.error(_("The URI '%s' failed to download, aborting") % item.desc_uri)

                sys.exit(1)

            if not os.path.exists(item.destfile):

                logging.error("Download finished, but file '%s' not there?!?" % item.destfile)

                sys.exit(1)

            if not item.is_trusted:

                # the cron mail (only if no summary mail is requested)

                email = apt_pkg.config.find("Unattended-Upgrade::Mail", "")

                if not email:

                # 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))

    (options, args) = parser.parse_args()

 

    if os.getuid() != 0:

        sys.exit(1)

 

    # nice & ionce