Merge lp:~mvo/unattended-upgrades/pep8-again into lp:~mvo/unattended-upgrades/debian-sid-mirror

[Michael Vogt]

Fix pep8 errors and include unattended-upgrades-shutdown in the checks

Unmerged revisions

305. By Michael Vogt on 2012-10-05

add unattended-upgrades-shutdown in the pep8/pyflakes checks too

304. By Michael Vogt on 2012-10-05

* lp:~mvo/unattended-upgrades/create-logdir-in-shutdown-helper-lp1013363:
  - create logdir in the shutdown helper if needed (LP: #1013363)

303. By Michael Vogt on 2012-10-05

* lp:~mvo/unattended-upgrades/lp1061498:
  - fix crash in dpkg_conffile_prompt() (LP: #1061498)

302. By Michael Vogt on 2012-09-14

test/Makefile: fix cleanup

301. By Michael Vogt on 2012-09-14

debian/tests/run-tests: add run-test script

300. By Michael Vogt on 2012-09-14

add dep8 tests

299. By Michael Vogt on 2012-09-14

Fixed debug output when a package has no candidates (LP: #1046438)

298. By Michael Vogt on 2012-09-10

releasing version 0.79.3ubuntu1

297. By Michael Vogt on 2012-09-07

fully pep8 clean (yeah!)

296. By Michael Vogt on 2012-09-07

add pyflakes/pep8 tests

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2012-10-05 15:48:44 +0000
@@ -0,0 +1,2 @@
+__pycache__
+build

=== modified file 'debian/changelog'
--- debian/changelog	2012-08-14 13:04:45 +0000
+++ debian/changelog	2012-10-05 15:48:44 +0000
@@ -1,3 +1,33 @@
+unattended-upgrades (0.79.3ubuntu3) UNRELEASEDquantal; urgency=low
+
+  * lp:~mvo/unattended-upgrades/lp1061498:
+    - fix crash in dpkg_conffile_prompt() (LP: #1061498)
+  * lp:~mvo/unattended-upgrades/create-logdir-in-shutdown-helper-lp1013363:
+    - create logdir in the shutdown helper if needed (LP: #1013363)
+
+ -- Michael Vogt <[e-mail]>  Fri, 05 Oct 2012 16:59:08 +0200
+
+unattended-upgrades (0.79.3ubuntu2) quantal; urgency=low
+
+  [ Marc Tardif ]
+  * Fixed debug output when a package has no candidates (LP: #1046438)
+  
+  [ Michael Vogt ]
+  * debian/test/:
+    - add dep8 tests
+
+ -- Marc Tardif <[e-mail]>  Thu, 13 Sep 2012 16:16:04 -0400
+
+unattended-upgrades (0.79.3ubuntu1) quantal; urgency=low
+
+  [ Thomas Kluyver ]
+  * Port to Python 3
+
+  [ Brian Murray ]
+  * unattended-upgrade: fix typo in debugging output
+
+ -- Michael Vogt <[e-mail]>  Mon, 10 Sep 2012 09:55:19 +0200
+
 unattended-upgrades (0.79.4) UNRELEASED; urgency=low
 
   * data/50unattended-upgrades.{Debian,Ubuntu}:
@@ -63,7 +93,7 @@
     - added, thanks to Pedro Ribeiro, closes: #678738
   * po/sk.po:
     - added, thanks to helix84, closes: #677471
-  
+
   [ Teodor MICU ]
   * debian/unattended-upgrades.init:
     - fixes new style lsb-init output, closes: #678030
@@ -93,7 +123,7 @@
     - updated, thanks to Joe Dalton, closes: #677804
   * po/de.po:
     - updated, thanks to Chris Leick (closes: #678204)
-  
+
   [ Teodor MICU ]
   * debian/unattended-upgrades.init:
     - use new style lsb-init output, closes: #678030

=== modified file 'debian/control'
--- debian/control	2012-07-13 18:51:00 +0000
+++ debian/control	2012-10-05 15:48:44 +0000
@@ -3,14 +3,15 @@
 Priority: optional
 Maintainer: Michael Vogt <[e-mail]>
 Build-Depends: debhelper (>= 7.0.50~), po-debconf, lsb-release
-Build-Depends-Indep: python (>= 2.6.6-3~), python-distutils-extra
-Standards-Version: 3.8.3
+Build-Depends-Indep: python3, python3-distutils-extra
+Standards-Version: 3.9.3
 Vcs-Bzr: http://code.launchpad.net/~ubuntu-core-dev/unattended-upgrades/ubuntu/
+XS-Testsuite: autopkgtest
 
 Package: unattended-upgrades
 Architecture: all
-Depends: ${shlibs:Depends}, ${misc:Depends}, debconf, python, 
- python-apt (>= 0.7.90), apt-utils, apt, ucf, lsb-release, 
+Depends: ${shlibs:Depends}, ${misc:Depends}, debconf, python3, 
+ python3-apt (>= 0.7.90), apt-utils, apt, ucf, lsb-release,
  lsb-base (>= 3.2-14)
 Suggests: bsd-mailx, mail-transport-agent
 Description: automatic installation of security upgrades

=== modified file 'debian/rules'
--- debian/rules	2011-11-09 19:20:50 +0000
+++ debian/rules	2012-10-05 15:48:44 +0000
@@ -3,24 +3,26 @@
 DIST=$(shell /usr/bin/lsb_release -i -s)
 
 %:
-	dh $@ --with python2
+	dh $@ --with python3
 
 override_dh_auto_build:
 	# copy the right template into place
 	cp data/50unattended-upgrades.$(DIST) data/50unattended-upgrades
-	dh_auto_build
+	python3 setup.py build
+
+override_dh_auto_install:
+	python3 setup.py install \
+		--root=$(CURDIR)/debian/unattended-upgrades \
+		--install-layout=deb
 
 override_dh_auto_clean:
 	# Sanity-check before upload.
-	set -e; if [ -e /usr/lib/python$(PYVER)/py_compile.py ]; then \
-		for f in unattended-upgrade unattended-upgrade-shutdown; do \
-			ln -nsf $$f $$f.py; \
-			python$(PYVER) /usr/lib/python$(PYVER)/py_compile.py \
-				$$f.py; \
-			rm -f $$f.py; \
-		done; \
-	fi
-	dh_auto_clean
+	set -e; for f in unattended-upgrade unattended-upgrade-shutdown; do \
+		ln -nsf $$f $$f.py; \
+		py3compile $$f.py; \
+		rm -f $$f.py; \
+	done
+	python3 setup.py clean -a
 
 override_dh_installinit:
 	# we do not want to run the init script in the postinst/prerm, its

=== added directory 'debian/tests'
=== added file 'debian/tests/control'
--- debian/tests/control	1970-01-01 00:00:00 +0000
+++ debian/tests/control	2012-10-05 15:48:44 +0000
@@ -0,0 +1,2 @@
+Tests: run-tests
+Depends: @, make, python-dev, python3-dev, python-coverage

=== added file 'debian/tests/run-tests'
--- debian/tests/run-tests	1970-01-01 00:00:00 +0000
+++ debian/tests/run-tests	2012-10-05 15:48:44 +0000
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+cd test
+make

=== modified file 'debian/unattended-upgrades.init'
--- debian/unattended-upgrades.init	2012-06-29 08:09:25 +0000
+++ debian/unattended-upgrades.init	2012-10-05 15:48:44 +0000
@@ -33,7 +33,7 @@
 stop)
 	if [ -e $SHUTDOWN_HELPER ]; then
 		[ "$VERBOSE" != "no" ] && log_action_begin_msg "Checking for running $DESC"
-		python $SHUTDOWN_HELPER
+		python3 $SHUTDOWN_HELPER
 		[ "$VERBOSE" != "no" ] && log_action_end_msg $? "$NAME"
 	fi
 	;;

=== modified file 'pm/sleep.d/10_unattended-upgrades-hibernate'
--- pm/sleep.d/10_unattended-upgrades-hibernate	2011-11-08 16:56:58 +0000
+++ pm/sleep.d/10_unattended-upgrades-hibernate	2012-10-05 15:48:44 +0000
@@ -17,7 +17,7 @@
 case "${1}" in
         hibernate)
                 if [ -e $SHUTDOWN_HELPER ]; then
-         	    python $SHUTDOWN_HELPER
+         	    python3 $SHUTDOWN_HELPER
                 fi
                 ;;
         resume|thaw)

=== modified file 'setup.py'
--- setup.py	2011-10-24 10:20:18 +0000
+++ setup.py	2012-10-05 15:48:44 +0000
@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 
 from distutils.core import setup
-from DistUtilsExtra.command import *
-import glob
-import os
+from DistUtilsExtra.command import (
+    build_extra,
+    build_i18n,
+    )
 
     
 setup(name='unattended-upgrades', version='0.1',

=== modified file 'test/Makefile'
--- test/Makefile	2011-10-07 09:22:19 +0000
+++ test/Makefile	2012-10-05 15:48:44 +0000
@@ -3,12 +3,15 @@
 all: check
 
 check:
+	# test with both py2 and py3 for now and also use coverage for the py2
 	set -e; \
 	find . -name 'test_*.py' | \
 	while read file; do \
-	    echo "Running $$file"; \
 	    if [ -x $$file ]; then \
-	    	python $$file ; \
+		echo "Running $$file with python3"; \
+	    	python3 $$file ; \
+		echo "Running $$file with python"; \
+		python-coverage run -a $$file; \
 	    fi \
 	done
 
@@ -16,4 +19,8 @@
 	rm -rf ./aptroot/var/cache/
 	rm -rf ./aptroot/var/lib/apt
 	rm -rf ./aptroot/var/run
+	find .. -type d -name __pycache__ | xargs rm -rf
 
+coverage-html:
+	echo "output in htmlcov/
+	python-coverage html
\ No newline at end of file

=== modified file 'test/create_debug_lock.py'
--- test/create_debug_lock.py	2011-06-16 07:10:07 +0000
+++ test/create_debug_lock.py	2012-10-05 15:48:44 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 #
 # create a lock file so that unattended-upgrades-shutdown pauses
 # on shutdown -- useful for testing
@@ -7,6 +7,7 @@
 import os
 import time
 
+
 pid = os.fork()
 if pid == 0:
     os.setsid()

=== modified file 'test/test_against_real_archive.py' (properties changed: +x to -x)
--- test/test_against_real_archive.py	2012-02-28 10:48:18 +0000
+++ test/test_against_real_archive.py	2012-10-05 15:48:44 +0000
@@ -1,22 +1,31 @@
-#!/usr/bin/python
+#!/usr/bin/python3
+"""Test unattended_upgrades against the real archive in a chroot.
+
+Note that this test is not run by the makefile in this folder, as it requires
+network access, and it fails in some situations (unclear which).
+"""
 
 import apt
 import apt_pkg
 import glob
+import logging
 import os
 import re
 import unittest
 
 import unattended_upgrade
 
+
 apt_pkg.config.set("APT::Architecture", "amd64")
 
+
 class MockOptions():
     def __init__(self, debug=True, dry_run=True):
         self.debug = debug
         self.dry_run = dry_run
         self.minimal_upgrade_steps = False
 
+
 class TestAgainstRealArchive(unittest.TestCase):
 
     def setUp(self):
@@ -40,11 +49,13 @@
         apt_pkg.config.set("APT::UnattendedUpgrades::LogDir", logdir)
         unattended_upgrade.DISTRO_CODENAME = "lucid"
         res = unattended_upgrade.main(options, os.path.abspath("./aptroot"))
+        logging.debug(res)
         # check if the log file exists
         self.assertTrue(os.path.exists(logfile))
-        log = open(logfile).read()
+        with open(logfile) as fp:
+            log = fp.read()
         # check that stuff worked
-        self.assertFalse(" ERROR " in log)
+        self.assertFalse(" ERROR " in log, log)
         # check if we actually have the expected ugprade in it
         self.assertTrue(
             re.search("INFO Packages that are upgraded:.*awstats", log))
@@ -59,4 +70,3 @@
 
 if __name__ == "__main__":
     unittest.main()
-

=== modified file 'test/test_conffile.py'
--- test/test_conffile.py	2012-06-28 20:06:37 +0000
+++ test/test_conffile.py	2012-10-05 15:48:44 +0000
@@ -1,11 +1,15 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import apt_pkg
 import logging
 import unittest
-import sys
-
-from unattended_upgrade import conffile_prompt
+
+
+from unattended_upgrade import (
+    conffile_prompt,
+    dpkg_conffile_prompt,
+    )
+
 
 class ConffilePromptTestCase(unittest.TestCase):
 
@@ -19,7 +23,7 @@
         test_pkg = "./packages/conf-test-package_1.1.deb"
         self.assertTrue(conffile_prompt(test_pkg, prefix="./root.conffile"),
                         "conffile prompt detection incorrect")
-    
+
     def test_will_not_prompt(self):
         # conf-test 0.9 is installed, 1.0 gets installed
         # they both have the same config files
@@ -54,7 +58,27 @@
                         "conffile prompt detection incorrect")
 
 
+class DpkgConffileTestCase(unittest.TestCase):
+    """
+    This tests that the detection if dpkg will prompt at all works,
+    i.e. if the user has decided to use a --force-conf{old,new} option
+    """
+
+    def setUp(self):
+        apt_pkg.config.clear("DPkg::Options")
+
+    def test_no_dpkg_prompt_option(self):
+        self.assertTrue(dpkg_conffile_prompt())
+
+    def test_regression_lp1061498(self):
+        apt_pkg.config.set("DPkg::Options::", "muup")
+        self.assertTrue(dpkg_conffile_prompt())
+
+    def test_dpkg_will_never_prompt(self):
+        apt_pkg.config.set("DPkg::Options::", "--force-confold")
+        self.assertFalse(dpkg_conffile_prompt())
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()
-

=== modified file 'test/test_in_chroot.py'
--- test/test_in_chroot.py	2012-06-28 20:06:37 +0000
+++ test/test_in_chroot.py	2012-10-05 15:48:44 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import apt
 import logging
@@ -15,7 +15,8 @@
 #SOURCES_LIST="""
 #deb http://ftp.de.debian.org/debian squeeze main contrib non-free
 #deb http://ftp.de.debian.org/debian squeeze-updates main contrib non-free
-#deb http://ftp.de.debian.org/debian squeeze-proposed-updates main contrib non-f#ree
+#deb http://ftp.de.debian.org/debian squeeze-proposed-updates main contrib \
+#  non-free
 #deb http://security.debian.org squeeze/updates main contrib non-free
 #"""
 #DISTRO="squeeze"
@@ -27,7 +28,7 @@
 
 
 # ubuntu
-SOURCES_LIST="""
+SOURCES_LIST = """
 deb http://archive.ubuntu.com/ubuntu/ lucid main restricted
 deb-src http://archive.ubuntu.com/ubuntu/ lucid main restricted
 
@@ -37,35 +38,39 @@
 deb http://security.ubuntu.com/ubuntu/ lucid-security main restricted
 deb-src http://security.ubuntu.com/ubuntu/ lucid-security main restricted
 """
-DISTRO="lucid"
-ARCH="i386"
-TARBALL="%s-%s.tgz" % (DISTRO, ARCH)
-MIRROR="http://archive.ubuntu.com/ubuntu"
-APT_CONF="""APT::Architecture "%s";""" % ARCH
-ORIGINS_PATTERN="origin=Ubuntu,archive=lucid-security"
+DISTRO = "lucid"
+ARCH = "i386"
+TARBALL = "%s-%s.tgz" % (DISTRO, ARCH)
+MIRROR = "http://archive.ubuntu.com/ubuntu"
+APT_CONF = """APT::Architecture "%s";""" % ARCH
+ORIGINS_PATTERN = "origin=Ubuntu,archive=lucid-security"
 
 apt.apt_pkg.config.set("APT::Architecture", ARCH)
 sys.path.insert(0, "..")
 import unattended_upgrade
 
+
 class MockOptions(object):
     debug = True
     dry_run = False
     minimal_upgrade_steps = False
 
+
 class TestUnattendedUpgrade(unittest.TestCase):
 
     def _create_new_debootstrap_tarball(self, tarball, target):
-        print "creating initial test tarball, this is needed only once"
+        print("creating initial test tarball, this is needed only once")
         # force i386
-        subprocess.call(["debootstrap",
-                         "--arch=%s" % ARCH,
-                         # smaller version of the minimal system
-                         "--variant=minbase",
-                         "--include=python-apt,apt-utils,gpgv,ubuntu-keyring,ca-certificates",
-                         DISTRO, 
-                         target,
-                         MIRROR])
+        subprocess.call(
+            ["debootstrap",
+             "--arch=%s" % ARCH,
+             # smaller version of the minimal system
+             "--variant=minbase",
+             "--include=python-apt,apt-utils,gpgv,ubuntu-keyring,"
+                 "ca-certificates",
+             DISTRO,
+             target,
+             MIRROR])
         subprocess.call(["chroot", target, "apt-get", "clean"])
         subprocess.call(["tar", "czf", tarball, target])
 
@@ -73,7 +78,7 @@
         subprocess.call(["tar", "xzf", tarball])
 
     def test_normal_upgrade(self):
-        print "Running normal unattended upgrade in chroot"
+        print("Running normal unattended upgrade in chroot")
         options = MockOptions()
         options.minimal_upgrade_steps = False
         # run it
@@ -82,7 +87,7 @@
         self.assertTrue(self._verify_install_log_in_real_chroot(target))
 
     def test_minimal_steps_upgrade(self):
-        print "Running minimal steps unattended upgrade in chroot"
+        print("Running minimal steps unattended upgrade in chroot")
         options = MockOptions()
         options.minimal_upgrade_steps = True
         # run it
@@ -91,14 +96,15 @@
         self.assertTrue(self._verify_install_log_in_real_chroot(target))
 
     def test_upgrade_on_shutdown_upgrade(self):
-        print "Running unattended upgrade on shutdown (download and install) in chroot"
+        print("Running unattended upgrade on shutdown (download and install) "
+              "in chroot")
         # ensure that it actually installs in shutdown env mode
         options = MockOptions()
         os.environ["UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN"] = "1"
         apt.apt_pkg.config.set("Unattended-Upgrade::InstallOnShutdown", "1")
         target = self._run_upgrade_test_in_real_chroot(options)
         self.assertTrue(self._verify_install_log_in_real_chroot(target))
-    
+
     def _get_lockfile_location(self, target):
         return os.path.join(
             target, "var/log/unattended-upgrades/unattended-upgrades.log")
@@ -114,14 +120,13 @@
         open(os.path.join(target, "etc/apt/apt.conf"), "w").write(APT_CONF)
         open(os.path.join(target, "etc/apt/sources.list"), "w").write(
             SOURCES_LIST)
-       
 
     def _run_upgrade_test_in_real_chroot(self, options, clean_chroot=True):
         """ helper that runs the unattended-upgrade in a chroot
             and does some basic verifications
         """
         if os.getuid() != 0:
-            print "Skipping because uid != 0"
+            print("Skipping because uid != 0")
             return
 
         # clear to avoid pollution in the chroot
@@ -130,7 +135,7 @@
         # create chroot
         target = "./test-chroot.%s" % DISTRO
 
-        # setup chroot if needed 
+        # setup chroot if needed
         if clean_chroot:
             self._setup_chroot(target)
 
@@ -143,7 +148,7 @@
             if not os.path.exists("/var/log/unattended-upgrades/"):
                 os.makedirs("/var/log/unattended-upgrades/")
             # make sure we are up-to-date
-            subprocess.call(["apt-get","update", "-q", "-q"])
+            subprocess.call(["apt-get", "update", "-q", "-q"])
             # run it
             apt.apt_pkg.config.clear("Unattended-Upgrade::Allowed-Origins")
             apt.apt_pkg.config.clear("Unattended-Upgrade::Origins-Pattern")
@@ -153,7 +158,7 @@
             unattended_upgrade.main(options)
             os._exit(0)
         else:
-            has_progress=False
+            has_progress = False
             all_progress = ""
             last_progress = ""
             progress_log = os.path.join(
@@ -171,9 +176,9 @@
                 if pid == apid:
                     ret = os.WEXITSTATUS(status)
                     break
-        #print "*******************", all_progress
+        #print("*******************", all_progress)
         self.assertEqual(ret, 0)
-        # this number is a bit random, we just want to be sure we have 
+        # this number is a bit random, we just want to be sure we have
         # progress data
         self.assertTrue(has_progress, True)
         self.assertTrue(len(all_progress) > 5)
@@ -183,11 +188,12 @@
         # examine log
         log = self._get_lockfile_location(target)
         logfile = open(log).read()
-        #print logfile
-        NEEDLE_PKG="ca-certificates"
+        #print(logfile)
+        NEEDLE_PKG = "ca-certificates"
         if not re.search(
             "Packages that are upgraded:.*%s" % NEEDLE_PKG, logfile):
-            logging.warn("Can not find expected %s upgrade in log" % NEEDLE_PKG)
+            logging.warn("Can not find expected %s upgrade in log" %
+                         NEEDLE_PKG)
             return False
         if "ERROR Installing the upgrades failed" in logfile:
             logging.warn("Got a ERROR in the logfile")
@@ -196,9 +202,10 @@
             target, "var/log/unattended-upgrades/*-dpkg*.log")
         dpkg_logfile = open(glob.glob(dpkg_log)[0]).read()
         if not "Preparing to replace %s" % NEEDLE_PKG in dpkg_logfile:
-            logging.warn("Did not find %s upgrade in the dpkg.log" % NEEDLE_PKG)
+            logging.warn("Did not find %s upgrade in the dpkg.log" %
+                         NEEDLE_PKG)
             return False
-        #print dpkg_logfile
+        #print(dpkg_logfile)
         return True
 
 

=== modified file 'test/test_logdir.py'
--- test/test_logdir.py	2012-06-29 07:08:35 +0000
+++ test/test_logdir.py	2012-10-05 15:48:44 +0000
@@ -1,9 +1,8 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import apt_pkg
 import logging
 import os
-import mock
 import sys
 import tempfile
 import unittest
@@ -11,10 +10,12 @@
 sys.path.insert(0, "..")
 from unattended_upgrade import _setup_logging
 
+
 class MockOptions:
     dry_run = False
     debug = False
 
+
 class TestLogdir(unittest.TestCase):
 
     def setUp(self):

=== modified file 'test/test_mail.py'
--- test/test_mail.py	2012-07-13 12:20:03 +0000
+++ test/test_mail.py	2012-10-05 15:48:44 +0000
@@ -1,11 +1,14 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
 import apt_pkg
 import os
+import sys
 import unittest
 
+from io import StringIO
 from email.parser import Parser
-from StringIO import StringIO
 
 import unattended_upgrade
 from unattended_upgrade import send_summary_mail, setup_apt_listchanges
@@ -40,9 +43,10 @@
         res = successful
         pkgs_kept_back = []
         # include some unicode chars here for good measure
-        mem_log = StringIO(u"mem_log text üöä")
+        mem_log = StringIO("mem_log text üöä")
         logfile_dpkg = "./apt-term.log"
-        open("./apt-term.log", "w").write("logfile_dpkg text")
+        with open("./apt-term.log", "w") as fp:
+            fp.write("logfile_dpkg text")
         return (pkgs, res, pkgs_kept_back, mem_log, logfile_dpkg)
 
     def _verify_common_mail_content(self, mail_txt):
@@ -50,47 +54,55 @@
             self.assertTrue(expected_string in mail_txt)
 
     def test_summary_mail_reboot(self):
-        open("./reboot-required","w").write("")
+        with open("./reboot-required", "w") as fp:
+            fp.write("")
         send_summary_mail(*self._return_mock_data())
         os.unlink("./reboot-required")
-        mail_txt = open("mail.txt").read()
+        # this is used for py2 compat for py3 only we can do
+        # remove the "rb" and the subsequent '.decode("utf-8")'
+        with open("mail.txt", "rb") as fp:
+            mail_txt = fp.read().decode("utf-8")
         self.assertTrue("[reboot required]" in mail_txt)
         self._verify_common_mail_content(mail_txt)
-        
+
     def test_summary_mail_no_reboot(self):
         send_summary_mail(*self._return_mock_data())
-        mail_txt = open("mail.txt").read()
+        with open("mail.txt", "rb") as fp:
+            mail_txt = fp.read().decode("utf-8")
         self.assertFalse("[reboot required]" in mail_txt)
         self._verify_common_mail_content(mail_txt)
-    
+
     def test_summary_mail_only_on_error(self):
         # default is to always send mail, ensure this is correct
         # for both success and failure
         apt_pkg.config.set("Unattended-Upgrade::MailOnlyOnError", "false")
         send_summary_mail(*self._return_mock_data(successful=True))
-        self._verify_common_mail_content(open("mail.txt").read())
+        with open("mail.txt", "rb") as fp:
+            self._verify_common_mail_content(fp.read().decode("utf-8"))
         os.remove("mail.txt")
         # now with a simulated failure
         send_summary_mail(*self._return_mock_data(successful=False))
-        self._verify_common_mail_content(open("mail.txt").read())
+        with open("mail.txt", "rb") as fp:
+            self._verify_common_mail_content(fp.read().decode("utf-8"))
         os.remove("mail.txt")
         # now test with "MailOnlyOnError"
         apt_pkg.config.set("Unattended-Upgrade::MailOnlyOnError", "true")
         send_summary_mail(*self._return_mock_data(successful=True))
         self.assertFalse(os.path.exists("mail.txt"))
         send_summary_mail(*self._return_mock_data(successful=False))
-        mail_txt = open("mail.txt").read()
+        with open("mail.txt", "rb") as fp:
+            mail_txt = fp.read().decode("utf-8")
         self._verify_common_mail_content(mail_txt)
         self.assertTrue("Unattended upgrade returned: False" in mail_txt)
         self.assertTrue(os.path.exists("mail.txt"))
 
     def test_apt_listchanges(self):
         # test with sendmail available
-        unattended_upgrade.SENDMAIL_BINARY="/bin/true"
+        unattended_upgrade.SENDMAIL_BINARY = "/bin/true"
         setup_apt_listchanges("./data/listchanges.conf.mail")
         self.assertEqual(os.environ["APT_LISTCHANGES_FRONTEND"], "mail")
         # test without sendmail
-        unattended_upgrade.SENDMAIL_BINARY="/bin/not-here-xxxxxxxxx"
+        unattended_upgrade.SENDMAIL_BINARY = "/bin/not-here-xxxxxxxxx"
         setup_apt_listchanges("./data/listchanges.conf.pager")
         self.assertEqual(os.environ["APT_LISTCHANGES_FRONTEND"], "none")
 
@@ -108,6 +120,7 @@
         # we don't accidently try
         self.assertFalse('text/plain; charset="utf-8"' in mail_txt)
 
+
 class SendmailTestCase(CommonTestsForMailxAndSendmail, unittest.TestCase):
 
     def setUp(self):
@@ -117,10 +130,15 @@
     def _verify_common_mail_content(self, mail_txt):
         CommonTestsForMailxAndSendmail._verify_common_mail_content(
             self, mail_txt)
+
+        # python2 needs this as utf8 encoded string (not unicode)
+        if sys.version < '3':
+            mail_txt = mail_txt.encode("utf-8")
+
         msg = Parser().parsestr(mail_txt)
         content_type = msg["Content-Type"]
         self.assertEqual(content_type, 'text/plain; charset="utf-8"')
-    
+
 
 class SendmailAndMailxTestCase(SendmailTestCase):
 
@@ -132,4 +150,3 @@
 if __name__ == "__main__":
     #logging.basicConfig(level=logging.DEBUG)
     unittest.main()
-

=== modified file 'test/test_minimal_partitions.py'
--- test/test_minimal_partitions.py	2011-11-18 10:46:15 +0000
+++ test/test_minimal_partitions.py	2012-10-05 15:48:44 +0000
@@ -1,33 +1,32 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import apt
 import apt_pkg
 import os
-import logging
 import unittest
-import sys
-import time
 
 import unattended_upgrade
 
+
 class LogInstallProgressMock(unattended_upgrade.LogInstallProgress):
 
     # klass data so that we can veriy in the test as the actual
     # object is destroyed
     DATA = []
-    
+
     # overwrite to log the data
     def status_change(self, pkg, percent, status):
-        print pkg, percent
+        print(pkg, percent)
         self.DATA.append([pkg, percent])
 
+
 class TestMinimalPartitions(unittest.TestCase):
 
     def setUp(self):
         # setup dry-run mode for apt
         apt_pkg.config.set("Dir::Cache", "/tmp")
-        apt_pkg.config.set("Debug::NoLocking","1")
-        apt_pkg.config.set("Debug::pkgDPkgPM","1")
+        apt_pkg.config.set("Debug::NoLocking", "1")
+        apt_pkg.config.set("Debug::pkgDPkgPM", "1")
         apt_pkg.config.set("Dir::State::extended_states", "./extended_states")
         apt_pkg.config.clear("Dpkg::Post-Invoke")
         apt_pkg.config.clear("Dpkg::Pre-Install-Pkgs")
@@ -40,7 +39,8 @@
     def test_upgrade_in_minimal_steps(self):
         self.cache.upgrade(True)
         pkgs_to_upgrade = [pkg.name for pkg in self.cache.get_changes()]
-        unattended_upgrade.PROGRESS_LOG="./aptroot/var/run/unatteded-upgrades.progress"
+        unattended_upgrade.PROGRESS_LOG = \
+            "./aptroot/var/run/unatteded-upgrades.progress"
         unattended_upgrade.LogInstallProgress = LogInstallProgressMock
         unattended_upgrade.upgrade_in_minimal_steps(
             self.cache, pkgs_to_upgrade)

=== modified file 'test/test_origin_pattern.py'
--- test/test_origin_pattern.py	2012-08-14 11:55:21 +0000
+++ test/test_origin_pattern.py	2012-10-05 15:48:44 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 import apt_pkg
 import logging
@@ -12,49 +12,63 @@
     UnknownMatcherError,
     )
 
+
 class MockOrigin():
     pass
+
+
 class MockCandidate():
     pass
+
+
 class MockPackage():
     pass
+
+
 class MockCache(list):
     pass
+
+
 class MockDepCache():
     pass
 
+
 class TestOriginPatern(unittest.TestCase):
 
     def setUp(self):
         pass
+
     def tearDown(self):
         pass
+
     def test_match_whitelist_string(self):
         origin = self._get_mock_origin(
             "OriginUbuntu", "LabelUbuntu", "ArchiveUbuntu",
             "archive.ubuntu.com", "main")
         # good
-        s="o=OriginUbuntu"
+        s = "o=OriginUbuntu"
         self.assertTrue(match_whitelist_string(s, origin))
-        s="o=OriginUbuntu,l=LabelUbuntu,a=ArchiveUbuntu,site=archive.ubuntu.com"
+        s = "o=OriginUbuntu,l=LabelUbuntu,a=ArchiveUbuntu," \
+            "site=archive.ubuntu.com"
         self.assertTrue(match_whitelist_string(s, origin))
         # bad
-        s=""
-        self.assertFalse(match_whitelist_string(s, origin))
-        s="o=something"
-        self.assertFalse(match_whitelist_string(s, origin))
-        s="o=LabelUbuntu,a=no-match"
+        s = ""
+        self.assertFalse(match_whitelist_string(s, origin))
+        s = "o=something"
+        self.assertFalse(match_whitelist_string(s, origin))
+        s = "o=LabelUbuntu,a=no-match"
         self.assertFalse(match_whitelist_string(s, origin))
         # with escaping
         origin = self._get_mock_origin("Google, Inc.", archive="stable")
         # good
-        s="o=Google\, Inc.,a=stable"
+        s = "o=Google\, Inc.,a=stable"
         self.assertTrue(match_whitelist_string(s, origin))
 
     def test_match_whitelist_from_conffile(self):
         # read some
         apt_pkg.config.clear("Unattended-Upgrade")
-        apt_pkg.read_config_file(apt_pkg.config, "./data/50unattended-upgrades.Test")
+        apt_pkg.read_config_file(
+            apt_pkg.config, "./data/50unattended-upgrades.Test")
         allowed_origins = unattended_upgrade.get_allowed_origins()
         #print allowed_origins
         self.assertTrue("o=aOrigin,a=aArchive" in allowed_origins)
@@ -63,7 +77,8 @@
 
     def test_compatiblity(self):
         apt_pkg.config.clear("Unattended-Upgrade")
-        apt_pkg.read_config_file(apt_pkg.config, "./data/50unattended-upgrades.compat")
+        apt_pkg.read_config_file(
+            apt_pkg.config, "./data/50unattended-upgrades.compat")
         allowed_origins = unattended_upgrade.get_allowed_origins()
         #print allowed_origins
         self.assertTrue("o=Google\, Inc.,a=stable" in allowed_origins)
@@ -74,7 +89,7 @@
 
     def test_unkown_matcher(self):
         apt_pkg.config.clear("Unattended-Upgrade")
-        s="xxx=OriginUbuntu"
+        s = "xxx=OriginUbuntu"
         with self.assertRaises(UnknownMatcherError):
             self.assertTrue(match_whitelist_string(s, None))
 
@@ -90,10 +105,12 @@
         allowed_origins = ["o=Ubuntu"]
         blacklist = ["linux-.*"]
         # with blacklist pkg
-        self.assertFalse(check_changes_for_sanity(cache, allowed_origins, blacklist))
+        self.assertFalse(
+            check_changes_for_sanity(cache, allowed_origins, blacklist))
         # with "normal" pkg
         pkg.name = "apt"
-        self.assertTrue(check_changes_for_sanity(cache, allowed_origins, blacklist))   
+        self.assertTrue(
+            check_changes_for_sanity(cache, allowed_origins, blacklist))
 
     def _get_mock_origin(self, aorigin="", label="", archive="",
                          site="", component=""):
@@ -125,4 +142,3 @@
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()
-

=== added file 'test/test_pep8.py'
--- test/test_pep8.py	1970-01-01 00:00:00 +0000
+++ test/test_pep8.py	2012-10-05 15:48:44 +0000
@@ -0,0 +1,18 @@
+import glob
+import os
+import subprocess
+import unittest
+
+
+class PackagePep8TestCase(unittest.TestCase):
+
+    def test_all_code(self):
+        res = 0
+        testdir = os.path.dirname(__file__)
+        py_files = glob.glob(os.path.join(testdir, "*.py"))
+        res += subprocess.call(["pep8", "--repeat", ] + py_files)
+        self.assertEqual(res, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

=== modified file 'test/test_pyflakes.py'
--- test/test_pyflakes.py	2012-07-13 16:40:10 +0000
+++ test/test_pyflakes.py	2012-10-05 15:48:44 +0000
@@ -2,12 +2,14 @@
 import subprocess
 import unittest
 
+
 class TestPyflakesClean(unittest.TestCase):
     """ ensure that the tree is pyflakes clean """
 
     def test_pyflakes_clean(self):
-        target = os.path.join(os.path.dirname(__file__), "..", "unattended-upgrade")
-        self.assertEqual(subprocess.call(["pyflakes", target]), 0)
+        path = os.path.join(
+            os.path.dirname(__file__), "unattended_upgrade.py")
+        self.assertEqual(subprocess.call(["pyflakes",  path]), 0)
 
 
 if __name__ == "__main__":

=== modified file 'test/test_substitute.py'
--- test/test_substitute.py	2011-02-04 11:05:12 +0000
+++ test/test_substitute.py	2012-10-05 15:48:44 +0000
@@ -1,17 +1,13 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
-import apt
 import apt_pkg
-import os
 import logging
 import unittest
-import sys
-
-from StringIO import StringIO
 
 import unattended_upgrade
 from unattended_upgrade import substitute, get_allowed_origins
 
+
 class TestSubstitude(unittest.TestCase):
 
     def setUp(self):
@@ -36,4 +32,3 @@
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()
-

=== added symlink 'test/unattended_upgrade_shutdown.py'
=== target is u'../unattended-upgrade-shutdown'
=== modified file 'unattended-upgrade'
--- unattended-upgrade	2012-08-14 11:55:21 +0000
+++ unattended-upgrade	2012-10-05 15:48:44 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # Copyright (c) 2005-2012 Canonical Ltd
 #
 # AUTHOR:
@@ -20,26 +20,27 @@
 # 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 email.Charset
+import email.charset
 import fcntl
 import re
 import os
 import string
 import sys
 
-from email.Message import Message
+from io import StringIO
+from email.message import Message
 from optparse import OptionParser
-from StringIO import StringIO
-from subprocess import Popen, PIPE
-
-import warnings
-warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
+
+from subprocess import (
+    Popen,
+    PIPE,
+    )
+
 import apt
 import logging
 import lsb_release
@@ -57,29 +58,32 @@
 DISTRO_ID = lsb_release.get_distro_information()['ID']
 
 # progress information is written here
-PROGRESS_LOG="/var/run/unattended-upgrades.progress"
+PROGRESS_LOG = "/var/run/unattended-upgrades.progress"
 
 # set from the sigint signal handler
-SIGNAL_STOP_REQUEST=False
+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 
+        # ensure we update the candidate versions
         self.adjust_candidate_versions()
+
     def clear(self):
         apt.Cache.clear(self)
-        # ensure we update the candidate versions 
+        # 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
         """
@@ -114,20 +118,19 @@
         (/var/run/unattended-upgrades.progress by default)
     """
 
-    LOG = PROGRESS_LOG 
+    LOG = PROGRESS_LOG
 
     def status_change(self, pkg, percent, status):
-        f=open(self.LOG, "w")
-        f.write(_("Progress: %s %% (%s)") % (percent, pkg))
-        f.close()
+        with open(self.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()
-                       ]
+        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)
@@ -140,19 +143,19 @@
                 try:
                     fd = int(fdname)
                 except Exception as e:
-                    print "ERROR: can not get fd for '%s'" % fdname
+                    print("ERROR: can not get fd for '%s'" % fdname)
                 if fd in required_fds:
                     continue
                 try:
                     os.close(fd)
-                    #print "closed: ", 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)
+                        print("ERROR: os.close(%s): %s" % (fd, e))
 
     def fork(self):
         pid = os.fork()
@@ -162,53 +165,62 @@
 
 
 class Unlocked:
-    """ context manager for unlocking the apt lock while cache.commit()
-        is run 
-    """
+    """
+    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():
     """
-    test if the dpkg journal is dirty
+    Return True if the dpkg journal is dirty
     (similar to debSystem::CheckUpdates)
     """
-    d = os.path.dirname(
-        apt_pkg.config.find_file("Dir::State::status"))+"/updates"
+    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.warn("SIGUSR1 recieved, will stop")
     global SIGNAL_STOP_REQUEST
-    SIGNAL_STOP_REQUEST=True
+    SIGNAL_STOP_REQUEST = True
+
 
 def substitute(line):
-    """ substitude known mappings and return a new string 
+    """ substitude known mappings and return a new string
 
     Currently supported ${distro-release}
     """
-    mapping = {"distro_codename" : get_distro_codename(),
-               "distro_id" : get_distro_id(),
+    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 = []
@@ -222,10 +234,11 @@
         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), 
+        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
 
@@ -236,6 +249,7 @@
         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"
@@ -251,9 +265,10 @@
     whitelist = whitelist.replace("\,", "%2C")
     for token in whitelist.split(","):
         # strip and unquote the "," back
-        (what, value) = [s.strip().replace("%2C",",")
+        (what, value) = [s.strip().replace("%2C", ",")
                          for s in token.split("=")]
-        #logging.debug("matching '%s'='%s' against '%s'" % (what, value, origin))
+        #logging.debug("matching '%s'='%s' against '%s'" % (
+        #              what, value, origin))
         # first char is apt-cache policy output, send is the name
         # in the Release file
         if what in ("o", "origin"):
@@ -272,6 +287,7 @@
                     what, token))
     return res
 
+
 def upgrade_normal(cache, pkgs_to_upgrade, logfile_dpkg):
     error = None
     res = False
@@ -279,17 +295,18 @@
     try:
         with Unlocked():
             res = cache.commit(install_progress=iprogress)
-    except SystemError,e:
+    except SystemError as e:
         error = e
     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") % \
+        logging.error(_("dpkg returned a error! See '%s' for details") %
                           logfile_dpkg)
     return res
 
+
 def upgrade_in_minimal_steps(cache, pkgs_to_upgrade, logfile_dpkg=""):
 
     install_log = LogInstallProgress()
@@ -320,13 +337,15 @@
                 smallest_partition = changes
                 break
             if len(changes) < len(smallest_partition):
-                logging.debug("found  partition of size %s (%s)" % (len(changes), changes))
+                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
+            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),
@@ -343,19 +362,20 @@
                 if not res:
                     raise Exception("cache.commit() returned false")
             cache.open()
-        except Exception, e:
+        except Exception as e:
             logging.error(_("Installing the upgrades failed!"))
             logging.error(_("error message: '%s'") % e)
-            logging.error(_("dpkg returned a error! See '%s' for details") % \
+            logging.error(_("dpkg returned a error! See '%s' for details") %
                               logfile_dpkg)
             return False
-        to_upgrade = to_upgrade-set(smallest_partition)
+        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
@@ -365,6 +385,7 @@
                 return True
     return False
 
+
 def is_pkgname_in_blacklist(pkgname, blacklist):
     for blacklist_regexp in blacklist:
         if re.match(blacklist_regexp, pkgname):
@@ -372,6 +393,7 @@
             return True
     return False
 
+
 def check_changes_for_sanity(cache, allowed_origins, blacklist):
     if cache._depcache.broken_count != 0:
         return False
@@ -392,33 +414,39 @@
             ignore_require_restart = apt_pkg.config.find_b(
                 "Unattended-Upgrade::IgnoreAppsRequireRestart", False)
             if (pkg.marked_upgrade and
-                ignore_require_restart == False and
+                ignore_require_restart is False and
                 pkg.candidate.record.get("Upgrade-Requires") == "app-restart"):
-                logging.debug("pkg '%s' requires app-restart, not safe to upgrade unattended")
+                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), e:
+    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]
+    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)
-    md5_p = Popen(md5_cmd, stdin=tar_p.stdout, 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)
@@ -426,7 +454,7 @@
 
     # 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"))
+    tagfile = apt_pkg.TagFile(open(status_file, "r"))
     conffiles = ""
     for section in tagfile:
         if section.get("Package") == pkgname:
@@ -440,21 +468,22 @@
     pkg_conffiles = ""
     deb = apt_inst.DebFile(destFile)
     try:
-        pkg_conffiles = deb.control.extractdata("conffiles").strip()
+        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 string.split(conffiles,"\n"):
+    for line in conffiles.splitlines():
         # ignore empty lines
-        line = string.strip(line)
+        line = line.strip()
         if not line:
             continue
         # show what we do
         logging.debug("conffile line: '%s'", line)
-        l = string.split(line)
+        l = line.split()
         conf_file = l[0]
         md5 = l[1]
         if len(l) > 2:
@@ -462,13 +491,13 @@
         else:
             obs = None
         # ignore if conffile is obsolete or does not exist
-        if obs == "obsolete" or not os.path.exists(prefix+conf_file):
+        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 
+        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))
@@ -476,7 +505,8 @@
         # record for later
         dpkg_status_conffiles[conf_file] = md5
         # test against the installed file
-        current_md5 = apt_pkg.md5sum(open(prefix+conf_file).read())
+        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:
@@ -484,7 +514,7 @@
         # 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 
+        # the md5sum in the deb is unchanged, this will not
         # trigger a conffile prompt
         if pkg_md5sum == md5:
             continue
@@ -493,18 +523,19 @@
         # 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)):
+                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)
-                if pkg_md5sum != apt_pkg.md5sum(open(prefix+conf_file).read()):
-                    return True
+                with open(prefix + conf_file, 'rb') as fp:
+                    if pkg_md5sum != apt_pkg.md5sum(fp):
+                        return True
     return False
 
 
@@ -512,9 +543,9 @@
     if not "DPkg::Options" in apt_pkg.config:
         return True
     options = apt_pkg.config.value_list("DPkg::Options")
-    for option in map(string.strip, options):
-        if (option == "--force-confold" or
-	    option == "--force-confnew"):
+    for option in options:
+        option = option.strip()
+        if option in ["--force-confold", "--force-confnew"]:
             return False
     return True
 
@@ -535,7 +566,7 @@
 def wrap(t, width=70, subsequent_indent=""):
     out = ""
     for s in t.split():
-        if (len(out)-out.rfind("\n")) + len(s) > width:
+        if (len(out) - out.rfind("\n")) + len(s) > width:
             out += "\n" + subsequent_indent
         out += s + " "
     return out
@@ -554,8 +585,9 @@
 
 
 def _send_mail_using_mailx(to_address, subject, body):
-    mail = subprocess.Popen([
-            MAIL_BINARY, "-s", subject, to_address], stdin=subprocess.PIPE)
+    mail = subprocess.Popen(
+        [MAIL_BINARY, "-s", subject, to_address],
+        stdin=subprocess.PIPE,  universal_newlines=True)
     mail.stdin.write(body)
     mail.stdin.close()
     ret = mail.wait()
@@ -565,14 +597,15 @@
 def _send_mail_using_sendmail(to_address, subject, body):
     # format as a proper mail
     msg = Message()
-    charset = email.Charset.Charset("utf-8")
-    charset.body_encoding = email.Charset.QP
+    charset = email.charset.Charset("utf-8")
+    charset.body_encoding = email.charset.QP
     msg.set_charset(charset)
     msg.set_payload(body)
     msg['Subject'] = subject
     msg['To'] = to_address
     sendmail = subprocess.Popen(
-        [SENDMAIL_BINARY, "-oi", "-t"], stdin=subprocess.PIPE)
+        [SENDMAIL_BINARY, "-oi", "-t"],
+        stdin=subprocess.PIPE, universal_newlines=True)
     sendmail.stdin.write(msg.as_string())
     sendmail.stdin.close()
     ret = sendmail.wait()
@@ -594,16 +627,18 @@
     # mails on on errors, just exit here
     if (res and
         apt_pkg.config.find_b("Unattended-Upgrade::MailOnlyOnError", False)):
-	return
+        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'") % host()
+        subject = _(
+            "[reboot required] unattended-upgrades result for '%s'") % host()
     else:
         subject = _("unattended-upgrades result for '%s'") % host()
     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")
+        body += _(
+            "Warning: A reboot is required to complete this upgrade.\n\n")
     body += _("Packages that are upgraded:\n")
     body += " " + wrap(pkgs, 70, " ")
     body += "\n"
@@ -613,15 +648,16 @@
         body += "\n"
     body += "\n"
     if os.path.exists(logfile_dpkg):
-        body += _("Package installation log:")+"\n"
-        body += open(logfile_dpkg).read()
+        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()
 
-    # ensure that the message a utf8 encoded string
-    if type(body) is unicode:
-        body= body.encode("utf-8", "replace")
+    # python2 needs this as utf8 encoded string (not unicode)
+    if sys.version < '3':
+        body = body.encode("utf-8")
 
     if os.path.exists(SENDMAIL_BINARY):
         ret = _send_mail_using_sendmail(to_email, subject, body)
@@ -636,13 +672,13 @@
 
 def do_install(cache, pkgs_to_upgrade, options, logfile_dpkg):
     # set debconf to NON_INTERACTIVE, redirect output
-    os.putenv("DEBIAN_FRONTEND","noninteractive");
+    os.putenv("DEBIAN_FRONTEND", "noninteractive")
     setup_apt_listchanges()
-    
+
     # redirect to log
     REDIRECT_INPUT = os.devnull
     fd = os.open(REDIRECT_INPUT, os.O_RDWR)
-    os.dup2(fd,0)
+    os.dup2(fd, 0)
 
     logging.info(_("Writing dpkg log to '%s'") % logfile_dpkg)
 
@@ -651,18 +687,21 @@
         old_stdout = 1
         old_stderr = 2
     else:
-        fd = os.open(logfile_dpkg, os.O_RDWR|os.O_CREAT, 0644)
+        fd = os.open(logfile_dpkg, os.O_RDWR | os.O_CREAT, 0o644)
         old_stdout = os.dup(1)
         old_stderr = os.dup(2)
-        os.dup2(fd,1)
-        os.dup2(fd,2)
+        os.dup2(fd, 1)
+        os.dup2(fd, 2)
 
     try:
-        if (options.minimal_upgrade_steps or 
+        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)):
-            open("/var/run/unattended-upgrades.pid", "w").write("%s" % os.getpid())
+            apt_pkg.config.find_b(
+                "Unattended-Upgrades::MinimalSteps", False) or
+            apt_pkg.config.find_b(
+                "Unattended-Upgrade::MinimalSteps", False)):
+            with open("/var/run/unattended-upgrades.pid", "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], logfile_dpkg)
@@ -685,15 +724,16 @@
     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"):
+    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"):
+    if os.path.isdir(rootdir + "/etc/apt/apt.conf.d"):
         apt_pkg.read_config_dir(apt_pkg.config,
                                 rootdir + "/etc/apt/apt.conf.d")
 
+
 def _get_logdir():
-    logdir= apt_pkg.config.find_dir(
+    logdir = apt_pkg.config.find_dir(
         "Unattended-Upgrade::LogDir",
         # COMPAT only
         apt_pkg.config.find_dir("APT::UnattendedUpgrades::LogDir",
@@ -716,13 +756,12 @@
             apt_pkg.config.find("APT::UnattendedUpgrades::LogFile",
                                 "unattended-upgrades.log")))
 
-    if not options.dry_run and not os.path.exists(os.path.dirname(logfile)):
-        os.makedirs(os.path.dirname(logfile))
+    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()
@@ -734,7 +773,7 @@
         mem_log_handler = logging.StreamHandler(mem_log)
         logger.addHandler(mem_log_handler)
     return mem_log
-        
+
 
 def main(options, rootdir=""):
 
@@ -749,24 +788,28 @@
     allowed_origins = get_allowed_origins()
 
     # pkgs that are (for some reason) not save to install
-    blacklisted_pkgs = apt_pkg.config.value_list("Unattended-Upgrade::Package-Blacklist")
-    logging.info(_("Initial blacklisted packages: %s"), " ".join(blacklisted_pkgs))
+    blacklisted_pkgs = apt_pkg.config.value_list(
+        "Unattended-Upgrade::Package-Blacklist")
+    logging.info(_("Initial blacklisted packages: %s"),
+                 " ".join(blacklisted_pkgs))
     logging.info(_("Starting unattended upgrades script"))
 
     # display available origin
-    logging.info(_("Allowed origins are: %s") % map(str,allowed_origins))
+    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)):
+        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")
+            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:
@@ -777,22 +820,23 @@
                 output = e.output
             logging.warning(_("dpkg --configure -a output:\n%s" % output))
         else:
-            logging.debug("Unclean dpkg state, but locked, another package manager working?")
-    
+            logging.debug("Unclean dpkg state, but locked, another package "
+                          "manager working?")
+
     # check and get lock
     try:
         apt_pkg.pkgsystem_lock()
-    except SystemError, e:
+    except SystemError as e:
         logging.error(_("Lock could not be acquired (another package "
                         "manager running?)"))
-        print _("Cache lock can not be acquired, exiting")
+        print(_("Cache lock can not be acquired, exiting"))
         sys.exit(1)
 
     # get a cache
-    cache = UnattendedUpgradesCache(rootdir=rootdir, 
+    cache = UnattendedUpgradesCache(rootdir=rootdir,
                                     allowed_origins=allowed_origins)
     if cache._depcache.broken_count > 0:
-        print _("Cache has broken packages, exiting")
+        print(_("Cache has broken packages, exiting"))
         logging.error(_("Cache has broken packages, exiting"))
         sys.exit(1)
     # speed things up with latest apt
@@ -802,13 +846,14 @@
     # find out about the packages that are upgradable (in a allowed_origin)
     pkgs_to_upgrade = []
     pkgs_kept_back = []
-    pkgs_auto_removable = set([pkg.name for pkg in cache 
+    pkgs_auto_removable = set([pkg.name for pkg in cache
                                if pkg.is_auto_removable])
 
     # now do the actual upgrade
     for pkg in cache:
         if options.debug and pkg.is_upgradable:
-            logging.debug("Checking: %s (%s)" % (pkg.name, map(str, pkg.candidate.origins)))
+            logging.debug("Checking: %s (%s)" % (
+                    pkg.name, map(str, 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)):
@@ -818,7 +863,7 @@
                                             blacklisted_pkgs):
                     # add to packages to upgrade
                     pkgs_to_upgrade.append(pkg)
-                    # re-eval pkgs_kept_back as the resolver may fail to 
+                    # 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:
@@ -830,17 +875,18 @@
                     logging.debug("sanity check failed")
                     rewind_cache(cache, pkgs_to_upgrade)
                     pkgs_kept_back.append(pkg.name)
-            except SystemError, e:
+            except SystemError as e:
                 # can't upgrade
-                logging.warning(_("package '%s' upgradable but fails to be marked for upgrade (%s)") % (pkg.name, e))
+                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)
-           
+
     # download what looks good
     if options.debug:
         fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress())
@@ -851,8 +897,8 @@
     recs = cache._records
     pm = apt_pkg.PackageManager(cache._depcache)
     try:
-        pm.get_archives(fetcher,list,recs)
-    except SystemError, e:
+        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)
@@ -863,15 +909,19 @@
         for item in fetcher.items:
             logging.debug("%s" % item)
             if item.status == item.STAT_ERROR:
-                print _("An error ocured: '%s'") % item.error_text
+                print(_("An error ocured: '%s'") % item.error_text)
                 logging.error(_("An error ocured: '%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)
+                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)
+                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))
@@ -879,18 +929,21 @@
                 # 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)
+                    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))
+                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)
@@ -904,7 +957,7 @@
                 pkg.mark_upgrade()
                 if check_changes_for_sanity(cache, allowed_origins,
                                             blacklisted_pkgs):
-                     pkgs_to_upgrade.append(pkg)
+                    pkgs_to_upgrade.append(pkg)
                 else:
                     if not (pkg.name in pkgs_kept_back):
                         pkgs_kept_back.append(pkg.name)
@@ -916,23 +969,26 @@
         logging.debug("dpkg is configured not to cause conffile prompts")
 
     # do auto-remove
-    if apt_pkg.config.find_b("Unattended-Upgrade::Remove-Unused-Dependencies", False):
-        now_auto_removable = set([pkg.name for pkg in cache 
+    if apt_pkg.config.find_b(
+        "Unattended-Upgrade::Remove-Unused-Dependencies", False):
+        now_auto_removable = set([pkg.name for pkg in cache
                                if pkg.is_auto_removable])
-        for pkgname in now_auto_removable-pkgs_auto_removable:
+        for pkgname in now_auto_removable - pkgs_auto_removable:
             logging.debug("marking %s for remove" % pkgname)
             cache[pkgname].mark_delete()
         logging.info(_("Packages that are auto removed: '%s'") %
-                     " ".join(now_auto_removable-pkgs_auto_removable))
+                     " ".join(now_auto_removable - pkgs_auto_removable))
 
-    logging.debug("InstCount=%i DelCount=%i BrokenCout=%i" % (cache._depcache.inst_count, cache._depcache.del_count, cache._depcache.broken_count))
+    logging.debug("InstCount=%i DelCount=%i BrokenCount=%i" % (
+            cache._depcache.inst_count, cache._depcache.del_count,
+            cache._depcache.broken_count))
 
     # exit if there is nothing to do and nothing to report
     if (len(pkgs_to_upgrade) == 0) and (len(pkgs_kept_back) == 0):
         logging.info(_("No packages found that can be upgraded unattended"))
         return
 
-    # check if its configured for install on shutdown, if so, the 
+    # 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
@@ -944,7 +1000,7 @@
     # 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")
+        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])
@@ -972,17 +1028,18 @@
             pkgs, pkg_install_success, pkgs_kept_back, mem_log, logfile_dpkg)
 
     # auto-reboot (if required and the config for this is set
-    if (apt_pkg.config.find_b("Unattended-Upgrade::Automatic-Reboot", False) and
+    if (apt_pkg.config.find_b(
+            "Unattended-Upgrade::Automatic-Reboot", False) and
         os.path.exists(REBOOT_REQUIRED_FILE)):
         if shutdown_lock > 0:
             os.close(shutdown_lock)
         logging.warning("Found %s, rebooting" % REBOOT_REQUIRED_FILE)
         subprocess.call(["/sbin/reboot"])
-        
+
 
 if __name__ == "__main__":
-    localesApp="unattended-upgrades"
-    localesDir="/usr/share/locale"
+    localesApp = "unattended-upgrades"
+    localesDir = "/usr/share/locale"
     gettext.bindtextdomain(localesApp, localesDir)
     gettext.textdomain(localesApp)
 
@@ -996,19 +1053,20 @@
                       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"))
+                      help=_("Upgrade in minimal steps (and allow "
+                             "interrupting with SIGINT"))
     (options, args) = parser.parse_args()
 
     if os.getuid() != 0:
-        print _("You need to be root to run this application")
+        print(_("You need to be root to run this application"))
         sys.exit(1)
 
     # nice & ionce
     os.nice(19)
-    IONICE="/usr/bin/ionice"
+    IONICE = "/usr/bin/ionice"
     if os.path.exists(IONICE):
         with open(os.devnull, "w") as fstderr:
-            subprocess.call([IONICE, "-c3", "-p",str(os.getpid())],
+            subprocess.call([IONICE, "-c3", "-p", str(os.getpid())],
                             stderr=fstderr)
 
     # ensure that we are not killed when the terminal goes away e.g. on

=== modified file 'unattended-upgrade-shutdown'
--- unattended-upgrade-shutdown	2012-04-26 11:40:46 +0000
+++ unattended-upgrade-shutdown	2012-10-05 15:48:44 +0000
@@ -1,13 +1,13 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # Copyright (c) 2009 Canonical Ltd
 #
 # AUTHOR:
 # Michael Vogt <[e-mail]>
 #
-# unattended-upgrade-shutdown - helper that checks if a 
+# unattended-upgrade-shutdown - helper that checks if a
 # unattended-upgrade is in progress and waits until it exists
 #
-# This file is part of unattended-upgrades 
+# 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
@@ -47,16 +47,19 @@
     logging.exception("importing of apt_pkg failed, exiting")
     sys.exit(0)
 
+
 def do_usplash(msg):
     if os.path.exists("/sbin/usplash_write"):
         logging.debug("Running usplash_write")
-        subprocess.call(["/sbin/usplash_write","TEXT", msg])
-        subprocess.call(["/sbin/usplash_write","PULSATE"])
+        subprocess.call(["/sbin/usplash_write", "TEXT", msg])
+        subprocess.call(["/sbin/usplash_write", "PULSATE"])
+
 
 def do_plymouth(msg):
     if os.path.exists("/bin/plymouth"):
         logging.debug("Running plymouth --text")
-        subprocess.call(["/bin/plymouth","message", "--text", msg])
+        subprocess.call(["/bin/plymouth", "message", "--text", msg])
+
 
 def log_msg(msg, level=logging.WARN):
     """ helper that will print msg to usplash, plymouth, console """
@@ -64,6 +67,7 @@
     do_plymouth(msg)
     do_usplash(msg)
 
+
 def log_progress():
     """ helper to log the install progress (if any) """
     # wait a some seconds and try again
@@ -76,10 +80,11 @@
     # log it
     log_msg(msg)
 
+
 if __name__ == "__main__":
     # setup gettext
-    localesApp="unattended-upgrades"
-    localesDir="/usr/share/locale"
+    localesApp = "unattended-upgrades"
+    localesDir = "/usr/share/locale"
     gettext.bindtextdomain(localesApp, localesDir)
     gettext.textdomain(localesApp)
 
@@ -89,11 +94,11 @@
                       help="print debug messages")
     parser.add_option("", "--delay", default=10,
                       help="delay in minutes to wait for unattended-upgrades")
-    parser.add_option("", "--lock-file", 
+    parser.add_option("", "--lock-file",
                       default="/var/run/unattended-upgrades.lock",
                       help="lock file location")
     (options, args) = parser.parse_args()
-    
+
     # setup logging
     level = logging.INFO
     if options.debug:
@@ -101,7 +106,11 @@
 
     # use a normal logfile instead of syslog too as on shutdown its too
     # easy to get syslog killed
-    logfile = "/var/log/unattended-upgrades/unattended-upgrades-shutdown.log"
+    logdir = apt_pkg.config.find_dir(
+        "Unattended-Upgrade::LogDir", "/var/log/unattended-upgrades/")
+    if not os.path.exists(logdir):
+        os.makedirs(logdir)
+    logfile = os.path.join(logdir, "unattended-upgrades-shutdown.log")
     logging.basicConfig(filename=logfile,
                         level=level,
                         format="%(asctime)s %(levelname)s - %(message)s")
@@ -125,7 +134,7 @@
     # run the monitoring loop and keep the "UI" updated
     start_time = time.time()
     lock_was_taken = False
-    while True: 
+    while True:
         res = apt_pkg.get_lock(options.lock_file)
         logging.debug("get_lock returned %i" % res)
         # exit here if there is no lock
@@ -141,11 +150,12 @@
             os.kill(pid, signal.SIGUSR1)
         # show log
         log_progress()
-	time.sleep(5)
-	if (time.time() - start_time) > options.delay*60:
-            logging.warning(_("Giving up on lockfile after %s delay") % options.delay)
+        time.sleep(5)
+        if (time.time() - start_time) > options.delay * 60:
+            logging.warning(
+                _("Giving up on lockfile after %s delay") % options.delay)
             sys.exit(1)
-    
+
     # add finished info to the log/terminal to help tracking down
     # LP: #434835
     if lock_was_taken: