Merge lp:~ember/update-manager/ubuntu.bug1002956 into lp:update-manager

[Pedro Fragoso]

[Michael Vogt (mvo)]

Thanks for this fix! I (manually) merged it into the update-manager branch now and we should SRU it for both precise and oneiric.

review: Approve

=== added directory '.bzr-builddeb'
=== renamed directory '.bzr-builddeb' => '.bzr-builddeb.moved'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2012-05-22 15:21:19 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+native = True

=== added file 'AUTHORS'
--- AUTHORS	1970-01-01 00:00:00 +0000
+++ AUTHORS	2012-05-22 15:21:19 +0000
@@ -0,0 +1,19 @@
+Hackers
+=======
+Michiel Sikkes <[e-mail]>
+Michael Vogt <[e-mail]>
+
+Translators
+===========
+Jorge Bernal <[e-mail]>
+Jean Privat <[e-mail]>
+Martin Willemoes Hansen <[e-mail]>
+Zygmunt Krynicki <[e-mail]>
+
+Technical Author
+================
+Sean Wheller   <[e-mail]>
+
+Icons
+=====
+Jakub Steiner <[e-mail]>

=== renamed file 'AUTHORS' => 'AUTHORS.moved'
=== added directory 'AutoUpgradeTester'
=== renamed directory 'AutoUpgradeTester' => 'AutoUpgradeTester.moved'
=== added symlink 'AutoUpgradeTester/DistUpgrade'
=== target is u'../DistUpgrade/'
=== added file 'AutoUpgradeTester/README'
--- AutoUpgradeTester/README	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/README	2012-05-22 15:21:19 +0000
@@ -0,0 +1,8 @@
+
+
+This code will test a release upgrade.
+
+If its started and there is a dir/symlink called "DistUpgrade" this
+code will be used for the upgrade (useful for testing the bzr
+development version of the upgrader code). Otherwise the latest
+released version of the archive is used via "do-release-upgrade".
\ No newline at end of file

=== added file 'AutoUpgradeTester/UpgradeTestBackend.py'
--- AutoUpgradeTester/UpgradeTestBackend.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackend.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,167 @@
+# TargetNonInteractive.py
+#
+# abstraction for non-interactive backends (like chroot, qemu)
+#
+
+from DistUpgrade.DistUpgradeConfigParser import DistUpgradeConfig
+
+import ConfigParser
+import os
+import os.path
+import tempfile
+from shutil import rmtree
+
+# refactor the code so that we have
+# UpgradeTest - the controler object
+# UpgradeTestImage - abstraction for chroot/qemu/xen
+
+class UpgradeTestImage(object):
+    def runInTarget(self, command):
+        pass
+    def copyToImage(self, fromFile, toFile):
+        pass
+    def copyFromImage(self, fromFile, toFile):
+        pass
+    def bootstrap(self, force=False):
+        pass
+    def start(self):
+        pass
+    def stop(self):
+        pass
+
+class UpgradeTestBackend(object):
+    """ This is a abstrace interface that all backends (chroot, qemu)
+        should implement - very basic currently :)
+    """
+
+    apt_options = ["-y","--allow-unauthenticated"]
+
+    def __init__(self, profiledir, resultdir=""):
+        " init the backend with the given profile "
+        # init the dirs
+        assert(profiledir != None)
+        profiledir = os.path.normpath(profiledir)
+        profile = os.path.join(os.path.abspath(profiledir), "DistUpgrade.cfg")
+        self.upgradefilesdir = "./DistUpgrade"
+
+        if os.path.exists("./post_upgrade_tests/"):
+            self.post_upgrade_tests_dir = "./post_upgrade_tests/"
+        else:
+            self.post_upgrade_tests_dir = "/usr/share/auto-upgrade-tester/post_upgrade_tests/"
+        # init the rest
+        if os.path.exists(profile):
+            override_cfg_d = os.path.join(profiledir, "..", "override.cfg.d")
+            defaults_cfg_d = os.path.join(profiledir, "..", "defaults.cfg.d")
+            self.profile = os.path.abspath(profile)
+            self.config = DistUpgradeConfig(datadir=os.path.dirname(profile),
+                                            name=os.path.basename(profile),
+                                            override_dir=override_cfg_d,
+                                            defaults_dir=defaults_cfg_d)
+        else:
+            raise IOError, "Can't find profile '%s' (%s) " % (profile, os.getcwd())
+        if resultdir:
+            base_resultdir = resultdir
+        else:
+            base_resultdir = self.config.getWithDefault(
+                "NonInteractive", "ResultDir", "results-upgrade-tester")
+        self.resultdir = os.path.abspath(
+            os.path.join(base_resultdir, profiledir.split("/")[-1]))
+
+        # Cleanup result directory before new run
+        if os.path.exists(self.resultdir):
+            rmtree(self.resultdir)
+        os.makedirs(self.resultdir)
+        
+        self.fromDist = self.config.get("Sources","From")
+        if "http_proxy" in os.environ and not self.config.has_option("NonInteractive","Proxy"):
+	    self.config.set("NonInteractive","Proxy", os.environ["http_proxy"])
+        elif self.config.has_option("NonInteractive","Proxy"):
+            proxy=self.config.get("NonInteractive","Proxy")
+            os.putenv("http_proxy",proxy)
+        os.putenv("DEBIAN_FRONTEND","noninteractive")
+        self.cachedir = None
+        try:
+            self.cachedir = self.config.get("NonInteractive","CacheDebs")
+        except ConfigParser.NoOptionError:
+            pass
+        # init a sensible environment (to ensure proper operation if
+        # run from cron)
+        os.environ["PATH"] = "/usr/sbin:/usr/bin:/sbin:/bin"
+
+    def installPackages(self, pkgs):
+        """
+        install packages in the image
+        """
+        pass
+
+    def getSourcesListFile(self):
+        """
+        creates a temporary sources.list file and returns it to 
+        the caller
+        """
+        # write new sources.list
+        sourceslist = tempfile.NamedTemporaryFile()
+        comps = self.config.getlist("NonInteractive","Components")
+        pockets = self.config.getlist("NonInteractive","Pockets")
+        mirror = self.config.get("NonInteractive","Mirror")
+        sourceslist.write("deb %s %s %s\n" % (mirror, self.fromDist, " ".join(comps)))
+        for pocket in pockets:
+            sourceslist.write("deb %s %s-%s %s\n" % (mirror, self.fromDist,pocket, " ".join(comps)))
+        sourceslist.flush()
+        return sourceslist
+    
+    def bootstrap(self):
+        " bootstaps a pristine install"
+        pass
+
+    def upgrade(self):
+        " upgrade a given install "
+        pass
+
+    def test(self):
+        " test if the upgrade was successful "
+        pass
+
+    def resultsToJunitXML(self, results, outputfile = None):
+        """
+        Filter results to get Junit XML output
+
+        :param results: list of results. Each result is a dictionary of the form
+            name: name of the test
+            result: (pass, fail, error)
+            time: execution time of the test in seconds
+            message: optional message in case of failure or error
+        :param output: Output XML to this file instead of returning the value
+        """
+        from xml.sax.saxutils import escape
+
+        output = ""
+        testsuite_name = ''
+        res = [x['result'] for x in results]
+        fail_count = res.count('fail')
+        error_count = res.count('error')
+        total_count = len(res)
+        total_time = sum([x['time'] for x in results])
+
+        output = """<testsuite errors="%d" failures="%d" name="%s" tests="%d" time="%.3f">\n""" % (
+            error_count, fail_count, testsuite_name, total_count,total_time)
+
+        for result in results:
+            output += """<testcase classname="%s" name="%s" time="%.3f">\n""" % (
+                self.profilename + '.PostUpgradeTest',
+                result['name'][:-3], result['time'])
+            if 'fail' in result['result']:
+                output += """<failure type="%s">%s\n</failure>\n""" % (
+                    'exception', escape(result['message']))
+            elif 'error' in result['result']:
+                output += """<error type="%s">%s\n</error>\n""" % (
+                    'exception', escape(result['message']))
+
+            output += "</testcase>\n"
+        output += "</testsuite>\n"
+
+        if outputfile:
+            with open(outputfile, 'w') as f:
+                f.write(output)
+        else:
+            return output

=== added file 'AutoUpgradeTester/UpgradeTestBackendChroot.py'
--- AutoUpgradeTester/UpgradeTestBackendChroot.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackendChroot.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,338 @@
+
+import sys
+import os
+import warnings
+warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
+
+from UpgradeTestBackend import UpgradeTestBackend
+
+import tempfile
+import subprocess
+import shutil
+import glob
+import ConfigParser
+
+class UpgradeTestBackendChroot(UpgradeTestBackend):
+
+    diverts = ["/usr/sbin/mkinitrd",
+               "/sbin/modprobe",
+               "/usr/sbin/invoke-rc.d",
+               # install-info has a locking problem quite often
+               "/usr/sbin/install-info",
+	       "/sbin/start-stop-daemon"]
+
+    def __init__(self, profile):
+        UpgradeTestBackend.__init__(self, profile)
+        self.tarball = None
+
+    def _umount(self, chrootdir):
+        umount_list = []
+        for line in open("/proc/mounts"):
+            (dev, mnt, fs, options, d, p) = line.split()
+            if mnt.startswith(chrootdir):
+                umount_list.append(mnt)
+        # now sort and umount by reverse length (to ensure
+        # we umount /sys/fs/binfmt_misc before /sys)
+        umount_list.sort(key=len)
+        umount_list.reverse()
+        # do the list
+        for mpoint in umount_list:
+            print "Umount '%s'" % mpoint
+            os.system("umount %s" % mpoint)
+
+            
+    def login(self):
+        d = self._unpackToTmpdir(self.tarball)
+        print "logging into: '%s'" % d
+        self._runInChroot(d, ["/bin/sh"])
+        print "Cleaning up"
+        if d:
+            shutil.rmtree(d)
+
+    def _runInChroot(self, chrootdir, command, cmd_options=[]):
+        print "runing: ",command
+        print "in: ", chrootdir
+        pid = os.fork()
+        if pid == 0:
+            os.chroot(chrootdir)
+            os.chdir("/")
+            os.system("mount -t devpts devpts /dev/pts")
+            os.system("mount -t sysfs sysfs /sys")
+            os.system("mount -t proc proc /proc")
+            os.system("mount -t binfmt_misc binfmt_misc /proc/sys/fs/binfmt_misc")
+            env = os.environ
+            env["DEBIAN_FRONTEND"] = "noninteractive"
+            os.execve(command[0], command, env)
+        else:
+            print "Parent: waiting for %s" % pid
+            (id, exitstatus) = os.waitpid(pid, 0)
+            self._umount(chrootdir)
+            return exitstatus
+
+    def _runApt(self, tmpdir, command, cmd_options=[]):
+        ret = self._runInChroot(tmpdir,
+                                ["/usr/bin/apt-get", command]+self.apt_options+cmd_options)
+        return ret
+
+
+    def installPackages(self, pkgs):
+        print "installPackages: ", pkgs
+        if not pkgs:
+            return True
+        res = self._runApt(self.tmpdir, "install", pkgs)
+        return res == 0
+
+    def _tryRandomPkgInstall(self, amount):
+        " install 'amount' packages randomly "
+        self._runApt(self.tmpdir,"install",["python2.4-apt", "python-apt"])
+        shutil.copy("%s/randomInst.py",self.tmpdir+"/tmp")
+        ret = subprocess.call(["chroot",self.tmpdir,"/tmp/randomInst.py","%s" % amount])
+        print ret
+
+    def _cacheDebs(self, tmpdir):
+        # see if the debs should be cached
+        if self.cachedir:
+            print "Caching debs"
+            for f in glob.glob(tmpdir+"/var/cache/apt/archives/*.deb"):
+                if not os.path.exists(self.cachedir+"/"+os.path.basename(f)):
+                    try:
+                        shutil.copy(f,self.cachedir)
+                    except IOError, e:
+                        print "Can't copy '%s' (%s)" % (f,e)
+
+    def _getTmpDir(self):
+        tmpdir = self.config.getWithDefault("CHROOT","Tempdir",None)
+        if tmpdir is None:
+            tmpdir = tempfile.mkdtemp()
+        else:
+            if os.path.exists(tmpdir):
+                self._umount(tmpdir)
+                shutil.rmtree(tmpdir)
+            os.makedirs(tmpdir)
+        return tmpdir
+    
+    def bootstrap(self,outfile=None):
+        " bootstaps a pristine fromDist tarball"
+        if not outfile:
+            outfile = os.path.dirname(self.profile) + "/dist-upgrade-%s.tar.gz" % self.fromDist
+        outfile = os.path.abspath(outfile)
+        self.tarball = outfile
+
+        # don't bootstrap twice if this is something we can cache
+        try:
+            if (self.config.getboolean("CHROOT","CacheTarball") and
+                os.path.exists(self.tarball) ):
+                self.tmpdir = self._unpackToTmpdir(self.tarball)
+                if not self.tmpdir:
+                    print "Error extracting tarball"
+                    return False
+                return True
+        except ConfigParser.NoOptionError:
+            pass
+        
+        # bootstrap!
+        self.tmpdir = tmpdir = self._getTmpDir()
+        print "tmpdir is %s" % tmpdir
+
+        print "bootstraping to %s" % outfile
+        ret = subprocess.call(["debootstrap", self.fromDist, tmpdir, self.config.get("NonInteractive","Mirror")])
+        print "debootstrap returned: %s" % ret
+        if ret != 0:
+            return False
+
+        print "diverting"
+        self._dpkgDivert(tmpdir)
+
+        # create some minimal device node
+        print "Creating some devices"
+        os.system("(cd %s/dev ; echo $PWD; ./MAKEDEV null)" % tmpdir)
+        #self._runInChroot(tmpdir, ["/bin/mknod","/dev/null","c","1","3"])
+
+        # set a hostname
+        shutil.copy("/etc/hostname","%s/etc/hostanme" % tmpdir)
+
+        # copy the stuff from toChroot/
+        if os.path.exists("./toChroot/"):
+            os.chdir("toChroot/")
+            for (dirpath, dirnames, filenames) in os.walk("."):
+                for name in filenames:
+                    if not os.path.exists(os.path.join(tmpdir,dirpath,name)):
+                        shutil.copy(os.path.join(dirpath,name), os.path.join(tmpdir,dirpath,name))
+            os.chdir("..")
+
+        # write new sources.list
+        if (self.config.has_option("NonInteractive","Components") and
+            self.config.has_option("NonInteractive","Pockets")):
+            sourcelist=self.getSourcesListFile()
+            shutil.copy(sourcelist.name, tmpdir+"/etc/apt/sources.list")
+            print open(tmpdir+"/etc/apt/sources.list","r").read()
+
+        # move the cache debs
+        self._populateWithCachedDebs(tmpdir)
+                
+        print "Updating the chroot"
+        ret = self._runApt(tmpdir,"update")
+        print "apt update returned %s" % ret
+        if ret != 0:
+            return False
+        # run it three times to work around network issues
+        for i in range(3):
+            ret = self._runApt(tmpdir,"dist-upgrade")
+        print "apt dist-upgrade returned %s" % ret
+        if ret != 0:
+            return False
+
+        print "installing basepkg"
+        ret = self._runApt(tmpdir,"install", [self.config.get("NonInteractive","BasePkg")])
+        print "apt returned %s" % ret
+        if ret != 0:
+            return False
+
+        CMAX = 4000
+        pkgs =  self.config.getListFromFile("NonInteractive","AdditionalPkgs")
+        while(len(pkgs)) > 0:
+            print "installing additonal: %s" % pkgs[:CMAX]
+            ret= self._runApt(tmpdir,"install",pkgs[:CMAX])
+            print "apt(2) returned: %s" % ret
+            if ret != 0:
+                self._cacheDebs(tmpdir)
+                return False
+            pkgs = pkgs[CMAX+1:]
+
+        if self.config.has_option("NonInteractive","PostBootstrapScript"):
+            script = self.config.get("NonInteractive","PostBootstrapScript")
+            if os.path.exists(script):
+                shutil.copy(script, os.path.join(tmpdir,"tmp"))
+                self._runInChroot(tmpdir,[os.path.join("/tmp",script)])
+            else:
+                print "WARNING: %s not found" % script
+
+        try:
+            amount = self.config.get("NonInteractive","RandomPkgInstall")
+            self._tryRandomPkgInstall(amount)
+        except ConfigParser.NoOptionError:
+            pass
+
+        print "Caching debs"
+        self._cacheDebs(tmpdir)
+
+        print "Cleaning chroot"
+        ret = self._runApt(tmpdir,"clean")
+        if ret != 0:
+            return False
+
+        print "building tarball: '%s'" % outfile
+        os.chdir(tmpdir)
+        ret = subprocess.call(["tar","czf",outfile,"."])
+        print "tar returned %s" % ret
+
+        return True
+
+    def _populateWithCachedDebs(self, tmpdir):
+        # now populate with hardlinks for the debs
+        if self.cachedir:
+            print "Linking cached debs into chroot"
+            for f in glob.glob(self.cachedir+"/*.deb"):
+                try:
+                    os.link(f, tmpdir+"/var/cache/apt/archives/%s"  % os.path.basename(f))
+                except OSError, e:
+                    print "Can't link: %s (%s)" % (f,e)
+        return True
+
+    def upgrade(self, tarball=None):
+        if not tarball:
+            tarball = self.tarball
+        assert(tarball != None)
+        print "runing upgrade on: %s" % tarball
+        tmpdir = self.tmpdir
+        #self._runApt(tmpdir, "install",["apache2"])
+
+        self._populateWithCachedDebs(tmpdir)
+        
+        # copy itself to the chroot (resolve symlinks)
+        targettmpdir = os.path.join(tmpdir,"tmp","dist-upgrade")
+        if not os.path.exists(targettmpdir):
+            os.makedirs(targettmpdir)
+        for f in glob.glob("%s/*" %  self.upgradefilesdir):
+            if not os.path.isdir(f):
+                shutil.copy(f, targettmpdir)
+                
+        # copy the profile
+        if os.path.exists(self.profile):
+            print "Copying '%s' to '%s' " % (self.profile,targettmpdir)
+            shutil.copy(self.profile, targettmpdir)
+        # copy the .cfg and .list stuff from there too
+        for f in glob.glob("%s/*.cfg" % (os.path.dirname(self.profile))):
+            shutil.copy(f, targettmpdir)
+        for f in glob.glob("%s/*.list" % (os.path.dirname(self.profile))):
+            shutil.copy(f, targettmpdir)
+            
+        # run it
+        pid = os.fork()
+        if pid == 0:
+            os.chroot(tmpdir)
+            os.chdir("/tmp/dist-upgrade")
+            os.system("mount -t devpts devpts /dev/pts")
+            os.system("mount -t sysfs sysfs /sys")
+            os.system("mount -t proc proc /proc")
+            os.system("mount -t binfmt_misc binfmt_misc /proc/sys/fs/binfmt_misc")
+            if os.path.exists("/tmp/dist-upgrade/dist-upgrade.py"):
+                os.execl("/tmp/dist-upgrade/dist-upgrade.py",
+                         "/tmp/dist-upgrade/dist-upgrade.py")
+            else:
+                os.execl("/usr/bin/do-release-upgrade",
+                         "/usr/bin/do-release-upgrade","-d",
+                         "-f","DistUpgradeViewNonInteractive")
+        else:
+            print "Parent: waiting for %s" % pid
+            (id, exitstatus) = os.waitpid(pid, 0)
+            print "Child exited (%s, %s): %s" % (id, exitstatus, os.WEXITSTATUS(exitstatus))
+            # copy the result
+            for f in glob.glob(tmpdir+"/var/log/dist-upgrade/*"):
+                print "copying result to: ", self.resultdir
+                shutil.copy(f, self.resultdir)
+            # cache debs and cleanup
+            self._cacheDebs(tmpdir)
+            self._umount(tmpdir)
+            shutil.rmtree(tmpdir)
+            return (exitstatus == 0)
+
+    def _unpackToTmpdir(self, baseTarBall):
+        # unpack the tarball
+        self.tmpdir = tmpdir = self._getTmpDir()
+        os.chdir(tmpdir)
+        ret = subprocess.call(["tar","xzf",baseTarBall])
+        if ret != 0:
+            return None
+        return tmpdir
+
+    def _dpkgDivert(self, tmpdir):
+        for d in self.diverts:
+            cmd = ["chroot",tmpdir,
+                   "dpkg-divert","--add","--local",
+                   "--divert",d+".thereal",
+                   "--rename",d]
+            ret = subprocess.call(cmd)
+            if ret != 0:
+                print "dpkg-divert returned: %s" % ret
+            shutil.copy(tmpdir+"/bin/true",tmpdir+d)
+
+    def test(self):
+        # FIXME: add some sanity testing here
+        return True
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        profilename = sys.argv[1]
+    else:
+	profilename = "default"
+    chroot = UpgradeTestBackendChroot(profilename)
+    tarball = "%s/tarball/dist-upgrade-%s.tar.gz" % (os.getcwd(),profilename)
+    if not os.path.exists(tarball):
+        print "No existing tarball found, creating a new one"
+        chroot.bootstrap(tarball)
+    chroot.upgrade(tarball)
+
+    #tmpdir = chroot._unpackToTmpdir(tarball)
+    #chroot._dpkgDivert(tmpdir)
+    #print tmpdir

=== added file 'AutoUpgradeTester/UpgradeTestBackendEC2.py'
--- AutoUpgradeTester/UpgradeTestBackendEC2.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackendEC2.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,329 @@
+# ec2 backend
+
+from UpgradeTestBackendSSH import UpgradeTestBackendSSH
+from UpgradeTestBackend import UpgradeTestBackend
+
+from DistUpgrade.sourceslist import SourcesList
+
+from boto.ec2.connection import EC2Connection
+
+import ConfigParser
+import os
+import sys
+import os.path
+import glob
+import time
+import atexit
+import apt_pkg
+
+
+# images created with EC2
+class NoCredentialsFoundException(Exception):
+    pass
+
+class OptionError(Exception):
+    pass
+
+
+# Step to perform for a ec2 upgrade test
+#
+# 1. conn = EC2Connect()
+# 2. reservation = conn.run_instances(image_id = image, security_groups = groups, key_name = key)
+# 3. wait for instance.state == 'running':
+#    instance.update()
+# 4. ssh -i <key> [e-mail]_name <command>
+
+
+# TODO
+#
+# Using ebs (elastic block storage) and snapshots for the test
+# 1. ec2-create-volume -s 80 -z us-east-1a
+#    (check with ec2-describe-instance that its actually in 
+#     the right zone)
+# 2. ec2-attach-volume vol-7bd23de2 -i i-3325ad4 -d /dev/sdh
+#    (do not name it anything but sd*)
+# 3. mount/use the thing inside the instance
+#
+#
+# Other useful things:
+# - sda1: root fs
+# - sda2: free space (~140G)
+# - sda3: swapspace  (~1G)
+
+class UpgradeTestBackendEC2(UpgradeTestBackendSSH):
+    " EC2 backend "
+
+    def __init__(self, profile):
+        UpgradeTestBackend.__init__(self, profile)
+        self.profiledir = os.path.abspath(os.path.dirname(profile))
+        # ami base name (e.g .ami-44bb5c2d)
+        self.ec2ami = self.config.get("EC2","AMI")
+        self.ssh_key = self.config.get("EC2","SSHKey")
+        try:
+            self.access_key_id = (os.getenv("AWS_ACCESS_KEY_ID") or
+                                  self.config.get("EC2","access_key_id"))
+            self.secret_access_key = (os.getenv("AWS_SECRET_ACCESS_KEY") or
+                                      self.config.get("EC2","secret_access_key"))
+        except ConfigParser.NoOptionError:
+            print "Either export AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY or"
+            print "set access_key_id and secret_access_key in the profile config"
+            print "file."
+            sys.exit(1)
+        self._conn = EC2Connection(self.access_key_id, self.secret_access_key)
+        self.ubuntu_official_ami = False
+        if self.config.has_option("EC2","UbuntuOfficialAMI"):
+            self.ubuntu_official_ami = self.config.getboolean("EC2","UbuntuOfficialAMI")
+        
+        try:
+            self.security_groups = self.config.getlist("EC2","SecurityGroups")
+        except ConfigParser.NoOptionError:
+            self.security_groups = []
+
+        if self.ssh_key.startswith("./"):
+            self.ssh_key = self.profiledir + self.ssh_key[1:]
+        self.ssh_port = "22"
+        self.instance = None
+
+        # the public name of the instance, e.g. 
+        #  ec2-174-129-152-83.compute-1.amazonaws.com
+        self.ssh_hostname = ""
+        # the instance name (e.g. i-3325ad4)
+        self.ec2instance = ""
+        if (self.config.has_option("NonInteractive","RealReboot") and
+            self.config.getboolean("NonInteractive","RealReboot")):
+            raise OptionError, "NonInteractive/RealReboot option must be set to False for the ec2 upgrader"
+        atexit.register(self._cleanup)
+
+    def _cleanup(self):
+        print "_cleanup(): stopping running instance"
+        if self.instance:
+            self.instance.stop()
+
+    def _enableRootLogin(self):
+        command = ["sudo", 
+                   "sed", "-i", "-e", "'s,\(.*\)\(ssh-rsa.*\),\\2,'", 
+                   "/root/.ssh/authorized_keys"]
+        ret = self._runInImageAsUser("ubuntu", command)
+        return (ret == 0)
+
+    def bootstrap(self, force=False):
+        print "bootstrap()"
+
+        print "Building new image based on '%s'" % self.ec2ami
+
+        # get common vars
+        basepkg = self.config.get("NonInteractive","BasePkg")
+
+        # start the VM
+        self.start_instance()
+
+        # prepare the sources.list (needed because a AMI may have any
+        # sources.list)
+        sources = self.getSourcesListFile()
+        ret = self._copyToImage(sources.name, "/etc/apt/sources.list")
+        assert(ret == 0)
+
+        # install some useful stuff
+        ret = self._runInImage(["apt-get","update"])
+        assert(ret == 0)
+        # FIXME: instead of this retrying (for network errors with 
+        #        proxies) we should have a self._runAptInImage() 
+        for i in range(3):
+            ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","install", "--allow-unauthenticated", "-y",basepkg])
+        assert(ret == 0)
+
+        CMAX = 4000
+        pkgs =  self.config.getListFromFile("NonInteractive","AdditionalPkgs")
+        while(len(pkgs)) > 0:
+            print "installing additonal: %s" % pkgs[:CMAX]
+            ret= self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","install","--reinstall", "--allow-unauthenticated", "-y"]+pkgs[:CMAX])
+            print "apt(2) returned: %s" % ret
+            if ret != 0:
+                #self._cacheDebs(tmpdir)
+                print "apt returned a error, stopping"
+                self.stop_instance()
+                return False
+            pkgs = pkgs[CMAX+1:]
+
+        if self.config.has_option("NonInteractive","PostBootstrapScript"):
+            script = self.config.get("NonInteractive","PostBootstrapScript")
+            print "have PostBootstrapScript: %s" % script
+            if os.path.exists(script):
+                self._runInImage(["mkdir","/upgrade-tester"])
+                self._copyToImage(script, "/upgrade-tester")
+                print "running script: %s" % os.path.join("/tmp",script)
+                self._runInImage([os.path.join("/upgrade-tester",script)])
+            else:
+                print "WARNING: %s not found" % script
+
+        if self.config.getWithDefault("NonInteractive",
+                                      "UpgradeFromDistOnBootstrap", False):
+            print "running apt-get upgrade in from dist (after bootstrap)"
+            for i in range(3):
+                ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","--allow-unauthenticated", "-y","dist-upgrade"])
+            assert(ret == 0)
+
+        print "Cleaning image"
+        ret = self._runInImage(["apt-get","clean"])
+        assert(ret == 0)
+
+        # done with the bootstrap
+
+        # FIXME: idealy we would reboot here, but its less important
+        #        because we can't get a new kernel anyway in ec2 (yet)
+        # - the reboot thing is *not* yet reliable!
+        #self.reboot_instance()
+
+        # FIXME: support for caching/snapshoting the base image here
+        
+        return True
+
+    def start_instance(self):
+        print "Starting ec2 instance and wait until its availabe "
+
+        # start the instance
+        reservation = self._conn.run_instances(image_id=self.ec2ami,
+                                               security_groups=self.security_groups,
+                                               key_name=self.ssh_key[:-4].split("/")[-1])
+        self.instance = reservation.instances[0]
+        while self.instance.state == "pending":
+                print "Waiting for instance %s to come up..." % self.instance.id
+                time.sleep(10)
+                self.instance.update()
+
+        print "It's up: hostname =", self.instance.dns_name
+        self.ssh_hostname = self.instance.dns_name
+        self.ec2instance = self.instance.id
+
+        # now sping until ssh comes up in the instance
+        if self.ubuntu_official_ami:
+            user = "ubuntu"
+        else:
+            user = "root"
+        for i in range(900):
+            time.sleep(1)
+            if self.ping(user):
+                print "instance available via ssh ping"
+                break
+        else:
+            print "Could not connect to instance after 900s, exiting"
+            return False
+        # re-enable root login if needed
+        if self.ubuntu_official_ami:
+            print "Re-enabling root login... ",
+            ret = self._enableRootLogin()
+            if ret:
+                print "Done!"
+            else:
+                print "Oops, failed to enable root login..."
+            assert (ret == True)
+            # the official image seems to run a update on startup?!?
+            print "waiting for the official image to leave apt alone"
+            time.sleep(10)
+        return True
+    
+    def reboot_instance(self):
+        " reboot a ec2 instance and wait until its available again "
+        self.instance.reboot()
+        # FIMXE: find a better way to know when the instance is 
+        #        down - maybe with "-v" ?
+        time.sleep(5)
+        while True:
+            if self._runInImage(["/bin/true"]) == 0:
+                print "instance rebootet"
+                break
+
+    def stop_instance(self):
+        " permanently stop a instance (it can never be started again "
+        # terminates are final - all data is lost
+        self.instance.stop()
+        # wait until its down
+        while True:
+            if self._runInImage(["/bin/true"]) != 0:
+                print "instance stopped"
+                break
+
+    def upgrade(self):
+        print "upgrade()"
+
+        # clean from any leftover pyc files
+        for f in glob.glob("%s/*.pyc" %  self.upgradefilesdir):
+            os.unlink(f)
+
+        print "Starting for upgrade"
+
+        assert(self.ec2instance)
+        assert(self.ssh_hostname)
+
+        # copy the profile
+        if os.path.exists(self.profile):
+            print "Copying '%s' to image overrides" % self.profile
+            self._runInImage(["mkdir","-p","/etc/update-manager/release-upgrades.d"])
+            self._copyToImage(self.profile, "/etc/update-manager/release-upgrades.d/")
+
+        # copy test repo sources.list (if needed)
+        test_repo = self.config.getWithDefault("NonInteractive","AddRepo","")
+        if test_repo:
+            test_repo = os.path.join(os.path.dirname(self.profile), test_repo)
+            self._copyToImage(test_repo, "/etc/apt/sources.list.d")
+            sourcelist = self.getSourcesListFile()
+            apt_pkg.Config.Set("Dir::Etc", os.path.dirname(sourcelist.name))
+            apt_pkg.Config.Set("Dir::Etc::sourcelist", 
+                               os.path.basename(sourcelist.name))
+            sources = SourcesList(matcherPath=".")
+            sources.load(test_repo)
+            # add the uri to the list of valid mirros in the image
+            for entry in sources.list:
+                if (not (entry.invalid or entry.disabled) and
+                    entry.type == "deb"):
+                    print "adding %s to mirrors" % entry.uri
+                    self._runInImage(["echo '%s' >> /upgrade-tester/mirrors.cfg" % entry.uri])
+
+        # check if we have a bzr checkout dir to run against or
+        # if we should just run the normal upgrader
+        if (os.path.exists(self.upgradefilesdir) and
+            self.config.getWithDefault("NonInteractive", 
+                                       "UseUpgraderFromBzr", 
+                                       True)):
+            self._copyUpgraderFilesFromBzrCheckout()
+            ret = self._runBzrCheckoutUpgrade()
+        else:
+            ret = self._runInImage(["do-release-upgrade","-d",
+                                    "-f","DistUpgradeViewNonInteractive"])
+        print "dist-upgrade.py returned: %i" % ret
+        
+
+        # copy the result
+        print "coyping the result"
+        self._copyFromImage("/var/log/dist-upgrade/*",self.resultdir)
+
+        # stop the machine
+        print "Shuting down the VM"
+        self.stop_instance()
+
+        return True
+
+    def test(self):
+        # FIXME: add some tests here to see if the upgrade worked
+        # this should include:
+        # - new kernel is runing (run uname -r in target)
+        # - did it sucessfully rebooted
+        # - is X runing
+        # - generate diff of upgrade vs fresh install
+        # ...
+        return True
+        
+
+    # compatibility for the auto-install-tester
+    def start(self):
+        self.start_instance()
+    def stop(self):
+        self.stop_instance()
+    def saveVMSnapshot(self):
+        print "saveVMSnapshot not supported yet"
+    def restoreVMSnapshot(self):
+        print "restoreVMSnapshot not supported yet"
+
+    
+# vim:ts=4:sw=4:et
+

=== added file 'AutoUpgradeTester/UpgradeTestBackendQemu.py'
--- AutoUpgradeTester/UpgradeTestBackendQemu.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackendQemu.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,585 @@
+# qemu backend
+
+from UpgradeTestBackendSSH import UpgradeTestBackendSSH
+from DistUpgrade.sourceslist import SourcesList
+
+import ConfigParser
+import subprocess
+import os
+import sys
+import os.path
+import shutil
+import glob
+import time
+import tempfile
+import atexit
+import apt_pkg
+import fcntl
+
+from DistUpgrade.utils import is_port_already_listening
+
+# images created with http://bazaar.launchpad.net/~mvo/ubuntu-jeos/mvo
+#  ./ubuntu-jeos-builder --vm kvm --kernel-flavor generic --suite feisty --ssh-key `pwd`/ssh-key.pub  --components main,restricted --rootsize 20G
+# 
+
+
+# TODO: 
+# - add support to boot certain images with certain parameters
+#   (dapper-386 needs qemu/kvm with "-no-acpi" to boot reliable)
+# - add option to use pre-done base images
+#   the bootstrap() step is then a matter of installing the right
+#   packages into the image (via _runInImage())
+# 
+# - refactor and move common code to UpgradeTestBackend
+# - convert ChrootNonInteractive 
+# - benchmark qemu/qemu+kqemu/kvm/chroot
+# - write tests (unittest, doctest?)
+# - offer "test-upgrade" feature on real system, run it
+#   as "qemu -hda /dev/hda -snapshot foo -append init=/upgrade-test"
+#   (this *should* write the stuff to the snapshot file
+# - add "runInTarget()" that will write a marker file so that we can
+#   re-run a command if it fails the first time (or fails because
+#   a fsck was done and reboot needed in the VM etc)
+# - start a X session with the gui-upgrader in a special
+#   "non-interactive" mode to see if the gui upgrade would work too
+
+class NoImageFoundException(Exception):
+    pass
+
+class PortInUseException(Exception):
+    pass
+class NoPortsException(Exception):
+    pass
+
+
+class UpgradeTestBackendQemu(UpgradeTestBackendSSH):
+    " qemu/kvm backend - need qemu >= 0.9.0"
+
+    QEMU_DEFAULT_OPTIONS = [
+        "-monitor","stdio",
+        "-localtime",
+        "-no-reboot",    # exit on reboot
+        #        "-no-kvm",      # crashes sometimes with kvm HW
+        ]
+
+    def __init__(self, profile):
+        UpgradeTestBackendSSH.__init__(self, profile)
+        self.qemu_options = self.QEMU_DEFAULT_OPTIONS[:]
+        self.qemu_pid = None
+        self.profiledir = profile
+        self.profile_override = os.path.join(
+            self.profiledir, "..", "override.cfg.d")
+        # get the kvm binary
+        self.qemu_binary = self.config.getWithDefault("KVM","KVM","kvm")
+        # setup mount dir/imagefile location
+        self.baseimage = self.config.get("KVM", "BaseImage")
+        if not os.path.exists(self.baseimage):
+            print "Missing '%s' base image, need to build it now" % self.baseimage
+            arch = self.config.getWithDefault("KVM", "Arch", "i386")
+            rootsize = self.config.getWithDefault("KVM", "RootSize", "80000")
+            destdir = "ubuntu-kvm-%s-%s" % (arch, self.fromDist)
+            ret = subprocess.call(["sudo",
+                                   "ubuntu-vm-builder","kvm", self.fromDist,
+                                   "--kernel-flavour", "generic",
+                                   "--ssh-key", "%s.pub" % self.ssh_key ,
+                                   "--components", "main,restricted",
+                                   "--rootsize", rootsize,
+                                   "--addpkg", "openssh-server",
+                                   "--destdir", destdir,
+                                   "--arch", arch])
+            # move the disk in place, ubuntu-vm-builder uses a random filename
+            shutil.move(glob.glob("%s/*.qcow2" % destdir)[0], 
+                        self.baseimage)
+            # remove old tree to ensure that subsequent runs work
+            shutil.rmtree(destdir)
+            if ret != 0:
+                raise NoImageFoundException
+        # check if we want virtio here and default to yes
+        try:
+            self.virtio = self.config.getboolean("KVM","Virtio")
+        except ConfigParser.NoOptionError:
+            self.virtio = True
+        if self.virtio:
+            self.qemu_options.extend(["-net","nic,model=virtio"])
+            self.qemu_options.extend(["-net","user"])
+        # swapimage
+        if self.config.getWithDefault("KVM","SwapImage",""):
+            self.qemu_options.append("-hdb")
+            self.qemu_options.append(self.config.get("KVM","SwapImage"))
+        # regular image
+        self.profilename = self.config.get("NonInteractive","ProfileName")
+        imagedir = self.config.get("KVM","ImageDir")
+        self.image = os.path.join(imagedir, "test-image.%s" % self.profilename)
+        # make ssh login possible (localhost 54321) available
+        ssh_port = int(self.config.getWithDefault("KVM","SshPort","54321"))
+        (self.ssh_lock, ssh_port) = self.getFreePort(port_base=ssh_port)
+        if not self.ssh_lock:
+            raise NoPortsException("Couldn't allocate SSH port.")
+        self.ssh_port = str(ssh_port)
+        print "using ssh port: %s" % self.ssh_port
+        self.ssh_hostname = "localhost"
+        self.qemu_options.append("-redir")
+        self.qemu_options.append("tcp:%s::22" % self.ssh_port)
+        # vnc port/display
+        VNC_BASE_PORT = 5900
+        vncport = int(self.config.getWithDefault("KVM","VncNum", "0")) + VNC_BASE_PORT
+        (self.vnc_lock, vncport) = self.getFreePort(port_base=vncport)
+        if not self.vnc_lock:
+            raise NoPortsException("Couldn't allocate VNC port.")
+        print "using VncNum: %s" % vncport
+        self.qemu_options.append("-vnc")
+        self.qemu_options.append("localhost:%s" % str(vncport - VNC_BASE_PORT))
+
+        # make the memory configurable
+        mem = self.config.getWithDefault("KVM","VirtualRam","1536")
+        self.qemu_options.append("-m")
+        self.qemu_options.append(str(mem))
+
+        # check if the ssh port is in use
+        if subprocess.call("netstat -t -l -n |grep 0.0.0.0:%s" % self.ssh_port,
+                           shell=True) == 0:
+            raise PortInUseException, "the port is already in use (another upgrade tester is running?)"
+        # register exit handler to ensure that we quit kvm on exit
+        atexit.register(self.stop)
+
+    def __del__(self):
+        """
+        Destructor
+        Clean-up lockfiles
+        """
+        for lock in (self.ssh_lock, self.vnc_lock):
+            lockpath = lock.name
+            print "Releasing lock: %s" % lockpath
+            lock.close()
+            os.unlink(lockpath)
+
+    def genDiff(self):
+        """
+        generate a diff that compares a fresh install to a upgrade.
+        ideally that should be empty
+        Ensure that we always run this *after* the regular upgrade was
+        run (otherwise it is useless)
+        """
+        # generate ls -R output of test-image (
+        self.start()
+        self._runInImage(["find", "/bin", "/boot", "/etc/", "/home",
+                          "/initrd", "/lib", "/root", "/sbin/",
+                          "/srv", "/usr", "/var"],
+                         stdout=open(self.resultdir+"/upgrade_install.files","w"))
+        self._runInImage(["dpkg","--get-selections"],
+                         stdout=open(self.resultdir+"/upgrade_install.pkgs","w"))
+        self._runInImage(["tar","cvf","/tmp/etc-upgrade.tar","/etc"])
+        self._copyFromImage("/tmp/etc-upgrade.tar", self.resultdir)
+        self.stop()
+
+        # HACK: now build fresh toDist image - it would be best if
+        self.fromDist = self.config.get("Sources","To")
+        self.config.set("Sources","From",
+                        self.config.get("Sources","To"))
+        diff_image = os.path.join(self.profiledir, "test-image.diff")
+        # FIXME: we need to regenerate the base image too, but there is no
+        #        way to do this currently without running as root
+        # as a workaround we regenerate manually every now and then
+        # and use UpgradeFromDistOnBootstrap=true here
+        self.config.set("KVM","CacheBaseImage", "false")
+        self.config.set("NonInteractive","UpgradeFromDistOnBootstrap","true")
+        self.baseimage = "jeos/%s-i386.qcow2" % self.config.get("Sources","To")
+        self.image = diff_image
+        print "bootstraping into %s" % diff_image
+        self.bootstrap()
+        print "bootstrap finshsed"
+        self.start()
+        print "generating file diff list"
+        self._runInImage(["find", "/bin", "/boot", "/etc/", "/home",
+                          "/initrd", "/lib", "/root", "/sbin/",
+                          "/srv", "/usr", "/var"],
+                         stdout=open(self.resultdir+"/fresh_install","w"))
+        self._runInImage(["dpkg","--get-selections"],
+                         stdout=open(self.resultdir+"/fresh_install.pkgs","w"))
+        self._runInImage(["tar","cvf","/tmp/etc-fresh.tar","/etc"])
+        self._copyFromImage("/tmp/etc-fresh.tar", self.resultdir)
+        self.stop()
+        # now compare the diffs
+        pass
+
+    def bootstrap(self, force=False):
+        print "bootstrap()"
+
+        # move old crash files away so that test() is not
+        # confused by them
+        for f in glob.glob(self.resultdir+"/*.crash"):
+            shutil.move(f, f+".old")
+
+        # copy image into place, use baseimage as template
+        # we expect to be able to ssh into the baseimage to
+        # set it up
+        if (not force and
+            os.path.exists("%s.%s" % (self.image,self.fromDist)) and 
+            self.config.has_option("KVM","CacheBaseImage") and
+            self.config.getboolean("KVM","CacheBaseImage")):
+            print "Not bootstraping again, we have a cached BaseImage"
+            shutil.copy("%s.%s" % (self.image,self.fromDist), self.image)
+            return True
+
+        print "Building new image '%s' based on '%s'" % (self.image, self.baseimage)
+        shutil.copy(self.baseimage, self.image)
+
+        # get common vars
+        basepkg = self.config.get("NonInteractive","BasePkg")
+        additional_base_pkgs = self.config.getlist("Distro","BaseMetaPkgs")
+
+        # start the VM
+        self.start()
+
+        # FIXME: make this part of the apt env
+        #        otherwise we get funny debconf promtps for 
+        #        e.g. the xserver
+        #export DEBIAN_FRONTEND=noninteractive
+        #export APT_LISTCHANGES_FRONTEND=none
+        # 
+
+        # generate static network config (NetworkManager likes
+        # to reset the dhcp interface and that sucks when
+        # going into the VM with ssh)
+        nm = self.config.getWithDefault("NonInteractive","WorkaroundNetworkManager","")
+        if nm:
+            interfaces = tempfile.NamedTemporaryFile()
+            interfaces.write("""
+auto lo
+iface lo inet loopback
+
+auto eth0
+iface eth0 inet static
+       address 10.0.2.15
+       netmask 255.0.0.0
+       gateway 10.0.2.2
+""")
+            interfaces.flush()
+            self._copyToImage(interfaces.name, "/etc/network/interfaces")
+        
+        # generate hosts file, the default hosts file contains
+        # "127.0.0.1 ubuntu. ubuntu" for some reason and the missing
+        # domain part after the "." makes e.g. postfix rather unhappy
+        etc_hosts = tempfile.NamedTemporaryFile()
+        etc_hosts.write('127.0.0.1 localhost\n')
+        etc_hosts.write('127.0.0.1 upgrade-test-vm\n')
+        etc_hosts.flush()
+        self._copyToImage(etc_hosts.name, "/etc/hosts")
+
+        # generate apt.conf
+        proxy = self.config.getWithDefault("NonInteractive","Proxy","")
+        if proxy:
+            aptconf = tempfile.NamedTemporaryFile()
+            aptconf.write('Acquire::http::proxy "%s";' % proxy)
+            aptconf.flush()
+            self._copyToImage(aptconf.name, "/etc/apt/apt.conf")
+
+        # tzdata is unhappy without that file
+        tzone = tempfile.NamedTemporaryFile()
+        tzone.write("Europe/Berlin")
+        tzone.flush()
+        self._copyToImage(tzone.name, "/etc/timezone")
+
+        aptclone = self.config.getWithDefault('NonInteractive', 'AptCloneFile', '')
+
+        if not aptclone:
+            # create /etc/apt/sources.list
+            sources = self.getSourcesListFile()
+            self._copyToImage(sources.name, "/etc/apt/sources.list")
+
+            # install some useful stuff
+            ret = self._runInImage(["apt-get","update"])
+            assert ret == 0
+            # FIXME: instead of this retrying (for network errors with 
+            #        proxies) we should have a self._runAptInImage() 
+            for i in range(3):
+                ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","install", "-y",basepkg]+additional_base_pkgs)
+            assert ret == 0
+        else:
+            dst_clonename = '/tmp/apt-clone.tgz'
+            self._copyToImage(aptclone, dst_clonename)
+            ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive", "apt-get",
+                                    "install", "-y", "apt-clone"])
+            assert ret == 0
+            print "Restoring clone from %s" % aptclone
+            ret = self._runInImage(['DEBIAN_FRONTEND=noninteractive',
+                                    'apt-clone', 'restore', dst_clonename])
+            # FIXME: what action should be taken when a package failed
+            #        to restore?
+            if ret != 0:
+                print "WARNING: Some packages failed to restore. Continuing anyway!"
+            #assert ret == 0
+
+        CMAX = 4000
+        pkgs =  self.config.getListFromFile("NonInteractive","AdditionalPkgs")
+        while(len(pkgs)) > 0:
+            print "installing additonal: %s" % pkgs[:CMAX]
+            ret= self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","install","--reinstall","-y"]+pkgs[:CMAX])
+            print "apt(2) returned: %s" % ret
+            if ret != 0:
+                #self._cacheDebs(tmpdir)
+                self.stop()
+                return False
+            pkgs = pkgs[CMAX+1:]
+
+        # Copy additional data to the image that can the be used by the
+        # post bootstrap script
+        # Data is copied to /upgrade-tester/data
+        # Value is a list of files separated by commas
+        datadir = '/upgrade-tester/data'
+        self._runInImage(["mkdir", "-p", datadir])
+        if self.config.has_option("NonInteractive", "PostBootstrapData"):
+            data = self.config.get("NonInteractive", "PostBootstrapData")
+            for datafile in data.split(','):
+                self._copyToImage(datafile, datadir)
+
+        if self.config.has_option("NonInteractive","PostBootstrapScript"):
+            script = self.config.get("NonInteractive","PostBootstrapScript")
+            print "have PostBootstrapScript: %s" % script
+            if os.path.exists(script):
+                self._copyToImage(script, "/upgrade-tester")
+                self._copyToImage(glob.glob(os.path.dirname(
+                            self.profile)+"/*.cfg"), "/upgrade-tester")
+                script_name = os.path.basename(script)
+                self._runInImage(["chmod","755",
+                                  os.path.join("/upgrade-tester",script_name)])
+                print "running script: %s" % script_name
+                cmd = os.path.join("/upgrade-tester",script_name)
+                ret = self._runInImage(["cd /upgrade-tester; %s" % cmd])
+                print "PostBootstrapScript returned: %s" % ret
+                assert ret == 0, "PostBootstrapScript returned non-zero"
+            else:
+                print "WARNING: %s not found" % script
+
+        if self.config.getWithDefault("NonInteractive",
+                                      "UpgradeFromDistOnBootstrap", False):
+            print "running apt-get upgrade in from dist (after bootstrap)"
+            for i in range(3):
+                ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","-y","dist-upgrade"])
+            assert ret == 0, "dist-upgrade returned %s" % ret
+
+        print "Cleaning image"
+        ret = self._runInImage(["apt-get","clean"])
+        assert ret == 0, "apt-get clean returned %s" % ret
+
+        # done with the bootstrap
+        self.stop()
+
+        # copy cache into place (if needed)
+        if (self.config.has_option("KVM","CacheBaseImage") and
+            self.config.getboolean("KVM","CacheBaseImage")):
+            shutil.copy(self.image, "%s.%s" % (self.image,self.fromDist))
+        
+        return True
+
+    def saveVMSnapshot(self,name):
+        # savevm
+        print "savevm"
+        self.stop()
+        shutil.copy(self.image, self.image+"."+name)
+        return
+        # *sigh* buggy :/
+        #self.qemu_pid.stdin.write("stop\n")
+        #self.qemu_pid.stdin.write("savevm %s\n" % name)
+        #self.qemu_pid.stdin.write("cont\n")
+    def delVMSnapshot(self,name):
+        print "delvm"
+        self.qemu_pid.stdin.write("delvm %s\n" % name)
+    def restoreVMSnapshot(self,name):
+        print "restorevm"
+        self.stop()
+        shutil.copy(self.image+"."+name, self.image)
+	return
+        # loadvm
+        # *sigh* buggy :/
+        #self.qemu_pid.stdin.write("stop\n")
+        #self.qemu_pid.stdin.write("loadvm %s\n" % name)
+        #self.qemu_pid.stdin.write("cont\n")
+
+    def start(self):
+        if self.qemu_pid != None:
+            print "already runing"
+            return True
+        # mvo: disabled for now, hardy->lucid does not work well with it
+        #      (random hangs)
+        #if self.virtio:
+        #    drive = ["-drive", "file=%s,if=virtio,boot=on" % self.image]
+        #else:
+        drive = ["-hda", self.image]
+        # build cmd
+        cmd = [self.qemu_binary]+drive+self.qemu_options
+        print "Starting %s" % cmd
+        self.qemu_pid = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+        # spin here until ssh has come up and we can login
+        now = time.time()
+        while True:
+            if self.qemu_pid.poll():
+                res = self.qemu_pid.wait()
+                print "qemu stopped unexpecedtly with exit code '%s'" % res
+                return False
+            time.sleep(1)
+            if self._runInImage(["/bin/true"]) == 0:
+                break
+            if (time.time() - now) > 900:
+                print "Could not start image after 900s, exiting"
+                return False
+        return True
+
+    def stop(self):
+        " we stop because we run with -no-reboot"
+        print "stop"
+        if self.qemu_pid:
+            print "stop pid: ", self.qemu_pid
+            self._runInImage(["/sbin/reboot"])
+            print "waiting for qemu to shutdown"
+            for i in range(600):
+                if self.qemu_pid.poll() is not None:
+                    print "poll() returned"
+                    break
+                time.sleep(1)
+            else:
+                print "Not stopped after 600s, killing "
+                try:
+                    os.kill(int(self.qemu_pid.pid), 15)
+                    time.sleep(10)
+                    os.kill(int(self.qemu_pid.pid), 9)
+                except Exception, e:
+                    print "FAILED to kill %s '%s'" % (self.qemu_pid, e)
+            self.qemu_pid = None
+            print "qemu stopped"
+
+
+    def upgrade(self):
+        print "upgrade()"
+
+        # clean from any leftover pyc files
+        for f in glob.glob("%s/*.pyc" %  self.upgradefilesdir):
+            os.unlink(f)
+
+        print "Starting for upgrade"
+        if not self.start():
+            return False
+
+        # copy the profile
+        if os.path.exists(self.profile):
+            print "Copying '%s' to image overrides" % self.profile
+            self._runInImage(["mkdir","-p","/etc/update-manager/release-upgrades.d"])
+            self._copyToImage(self.profile, "/etc/update-manager/release-upgrades.d/")
+            for override_cfg in glob.glob(
+                os.path.abspath(os.path.join(self.profile_override, "*.cfg"))):
+                print "Copying '%s' to image overrides" % override_cfg
+                self._copyToImage(
+                      override_cfg, "/etc/update-manager/release-upgrades.d/")
+
+        # copy test repo sources.list (if needed) 
+        test_repo = self.config.getWithDefault("NonInteractive","AddRepo","")
+        if test_repo:
+            test_repo = os.path.join(os.path.dirname(self.profile), test_repo)
+            self._copyToImage(test_repo, "/etc/apt/sources.list.d")
+            sourcelist = self.getSourcesListFile()
+            apt_pkg.Config.Set("Dir::Etc", os.path.dirname(sourcelist.name))
+            apt_pkg.Config.Set("Dir::Etc::sourcelist", 
+                               os.path.basename(sourcelist.name))
+            sources = SourcesList(matcherPath=".")
+            sources.load(test_repo)
+            # add the uri to the list of valid mirros in the image
+            self._runInImage(["mkdir","-p","/upgrade-tester"])
+            self._runInImage(["echo -e '[Sources]\nValidMirrors=/upgrade-tester/new_mirrors.cfg' > /etc/update-manager/release-upgrades.d/new_mirrors.cfg"])
+            for entry in sources.list:
+                if (not (entry.invalid or entry.disabled) and
+                    entry.type == "deb"):
+                    print "adding %s to mirrors" % entry.uri
+                    self._runInImage(["echo '%s' >> /upgrade-tester/new_mirrors.cfg" % entry.uri])
+
+            # upgrade *before* the regular upgrade runs 
+            if self.config.getWithDefault("NonInteractive", "AddRepoUpgradeImmediately", False):
+                self._runInImage(["apt-get", "update"])
+                self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","-y","dist-upgrade", "--allow-unauthenticated"])
+
+        apt_conf = self.config.getWithDefault("NonInteractive","AddAptConf","")
+        if apt_conf:
+            apt_conf = os.path.join(os.path.dirname(self.profile), apt_conf)
+            self._copyToImage(apt_conf, "/etc/apt/apt.conf.d")
+
+        # check if we have a bzr checkout dir to run against or
+        # if we should just run the normal upgrader
+        cmd_prefix=[]
+        debconf_log = self.config.getWithDefault(
+            'NonInteractive', 'DebconfLog', '')
+        if debconf_log:
+            cmd_prefix=['export DEBIAN_FRONTEND=editor EDITOR="cat>>%s";' % debconf_log]
+            print "Logging debconf prompts to %s" % debconf_log
+        if not self.config.getWithDefault("NonInteractive","ForceOverwrite", False):
+            print "Disabling ForceOverwrite"
+            cmd_prefix += ["export RELEASE_UPGRADE_NO_FORCE_OVERWRITE=1;"]
+        if (os.path.exists(self.upgradefilesdir) and
+            self.config.getWithDefault("NonInteractive",
+                                       "UseUpgraderFromBzr",
+                                       True)):
+            print "Using ./DistUpgrade/* for the upgrade"
+            self._copyUpgraderFilesFromBzrCheckout()
+            ret = self._runBzrCheckoutUpgrade(cmd_prefix)
+        else:
+            print "Using do-release-upgrade for the upgrade"
+            ret = self._runInImage(cmd_prefix+["do-release-upgrade","-d",
+                                    "-f","DistUpgradeViewNonInteractive"])
+        print "dist-upgrade.py returned: %i" % ret
+
+        # copy the result
+        print "coyping the result"
+        self._copyFromImage("/var/log/dist-upgrade/*",self.resultdir)
+
+        # give the ssh output extra time
+        time.sleep(10)
+
+        # stop the machine
+        print "Shuting down the VM"
+        self.stop()
+        return (ret == 0)
+
+    def getFreePort(self, port_base=1025, prefix='auto-upgrade-tester'):
+        """ Find a free port and lock it when found
+        :param port_base: Base port number.
+        :param prefix: Prefix name for the lock
+        :return: (lockfile, portnumber)
+        """
+
+        # allows the system to be configurable
+        lockdir = self.profiledir
+
+        for port_inc in range(0, 100):
+            port_num = port_base + port_inc
+            if is_port_already_listening(port_num):
+                print "Port %d already in use. Skipping!" % port_num
+                continue
+
+            lockfilepath = os.path.join(lockdir, '%s.%d.lock' % (prefix, port_num))
+            # FIXME: we can use apt_pkg.get_lock() here instead
+            if not os.path.exists(lockfilepath):
+                open(lockfilepath, 'w').close()
+            lock = open(lockfilepath, 'r+')
+            try:
+                fcntl.flock(lock, fcntl.LOCK_EX|fcntl.LOCK_NB)
+                return (lock, port_num)
+            except IOError:
+                print "Port %d already locked. Skipping!" % port_num
+                lock.close()
+
+        print "No free port found. Aborting!"
+        return (None, None)
+
+if __name__ == "__main__":
+
+    # FIXME: very rough proof of conecpt, unify with the chroot
+    #        and automatic-upgrade code
+    # see also /usr/sbin/qemu-make-debian-root
+
+    qemu = UpgradeTestBackendQemu(sys.argv[1],".")
+    #qemu.bootstrap()
+    #qemu.start()
+    #qemu._runInImage(["ls","/"])
+    #qemu.stop()
+    qemu.upgrade()
+
+    # FIXME: now write something into rc.local again and run reboot
+    #        and see if we come up with the new kernel

=== added file 'AutoUpgradeTester/UpgradeTestBackendSSH.py'
--- AutoUpgradeTester/UpgradeTestBackendSSH.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackendSSH.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,218 @@
+# abstract backend that is based around ssh login
+
+from UpgradeTestBackend import UpgradeTestBackend
+
+import glob
+import logging
+import os
+import os.path
+import subprocess
+import time
+
+
+class UpgradeTestBackendSSH(UpgradeTestBackend):
+    " abstract backend that works with ssh "
+
+    def __init__(self, profile):
+        UpgradeTestBackend.__init__(self, profile)
+        self.profiledir = os.path.dirname(profile)
+        # get ssh key name
+        self.ssh_key = os.path.abspath(
+            self.config.getWithDefault(
+                "NonInteractive",
+                "SSHKey",
+                "/var/cache/auto-upgrade-tester/ssh-key")
+            )
+        if not os.path.exists(self.ssh_key):
+            print "Creating key: %s" % self.ssh_key
+            subprocess.call(["ssh-keygen","-N","","-f",self.ssh_key])
+
+    def login(self):
+        " run a shell in the image "
+        print "login"
+        self.start()
+        ret = self._runInImage(["/bin/sh"])
+        if ret != 0:
+            logging.warn("_runInImage returned: %s" % ret)
+        self.stop()
+
+    def ping(self, user="root"):
+        " check if the instance is ready "
+        ret = self._runInImageAsUser(user, ["/bin/true"])
+        return (ret == 0)
+
+    def _copyToImage(self, fromF, toF, recursive=False):
+        "copy a file (or a list of files) to the given toF image location"
+        cmd = ["scp",
+               "-P", self.ssh_port,
+               "-q","-q", # shut it up
+               "-i",self.ssh_key,
+               "-o", "StrictHostKeyChecking=no",
+               "-o", "UserKnownHostsFile=%s" % os.path.dirname(
+                self.profile)+"/known_hosts"
+               ]
+        if recursive:
+            cmd.append("-r")
+        # we support both single files and lists of files
+        if isinstance(fromF,list):
+            cmd += fromF
+        else:
+            cmd.append(fromF)
+        cmd.append("root@%s:%s" %  (self.ssh_hostname, toF))
+        #print cmd
+        ret = subprocess.call(cmd)
+        return ret
+
+    def _copyFromImage(self, fromF, toF):
+        "copy a file from the given fromF image location"
+        cmd = ["scp",
+               "-P",self.ssh_port,
+               "-q","-q", # shut it up
+               "-i",self.ssh_key,
+               "-o", "StrictHostKeyChecking=no",
+               "-o", "UserKnownHostsFile=%s" % os.path.dirname(self.profile)+"/known_hosts",
+               "root@%s:%s" %  (self.ssh_hostname, fromF),
+               toF
+               ]
+        #print cmd
+        ret = subprocess.call(cmd)
+        return ret
+
+
+    def _runInImage(self, command, **kwargs):
+        ret = self._runInImageAsUser("root", command, **kwargs)
+        return ret
+
+    def _runInImageAsUser(self, user, command, **kwargs):
+        "run a given command in the image"
+        # ssh -l root -p 54321 localhost -i profile/server/ssh_key
+        #     -o StrictHostKeyChecking=no
+        ret = subprocess.call(["ssh",
+                               "-tt",
+                               "-l", user,
+                               "-p",self.ssh_port,
+                               self.ssh_hostname,
+                               "-q","-q", # shut it up
+                               "-i",self.ssh_key,
+                               "-o", "StrictHostKeyChecking=no",
+                               "-o", "BatchMode=yes",
+                               "-o", "UserKnownHostsFile=%s" % os.path.dirname(self.profile)+"/known_hosts",
+                               ]+command, **kwargs)
+        return ret
+
+
+    def installPackages(self, pkgs):
+        " install additional pkgs (list) into the vm before the upgrade "
+        if not pkgs:
+            return True
+        self.start()
+        self._runInImage(["apt-get","update"])
+        ret = self._runInImage(["DEBIAN_FRONTEND=noninteractive","apt-get","install", "--reinstall", "-y"]+pkgs)
+        self.stop()
+        return (ret == 0)
+
+
+    def _copyUpgraderFilesFromBzrCheckout(self):
+        " copy upgrader files from a bzr checkout "
+        print "copy upgrader into image"
+        # copy the upgrade into target+/upgrader-tester/
+        files = []
+        self._runInImage(["mkdir","-p","/upgrade-tester","/etc/update-manager/release-upgrades.d"])
+        for f in glob.glob("%s/*" % self.upgradefilesdir):
+            if not os.path.isdir(f):
+                files.append(f)
+            elif os.path.islink(f):
+                print "Copying link '%s' to image " % f
+                self._copyToImage(f, "/upgrade-tester", recursive=True)
+        self._copyToImage(files, "/upgrade-tester")
+        # and any other cfg files
+        for f in glob.glob(os.path.dirname(self.profile)+"/*.cfg"):
+            if (os.path.isfile(f) and
+                not os.path.basename(f).startswith("DistUpgrade.cfg")):
+                print "Copying '%s' to image " % f
+                self._copyToImage(f, "/upgrade-tester")
+        # base-installer
+        bi="%s/base-installer" %  self.upgradefilesdir
+        print "Copying '%s' to image" % bi
+        self._copyToImage(bi, "/upgrade-tester/", recursive=True)
+        # copy the patches
+        pd="%s/patches" %  self.upgradefilesdir
+        print "Copying '%s' to image" % pd
+        self._copyToImage(pd, "/upgrade-tester/", recursive=True)
+        # and prereq lists
+        prereq = self.config.getWithDefault("PreRequists","SourcesList",None)
+        if prereq is not None:
+            prereq = os.path.join(os.path.dirname(self.profile),prereq)
+            print "Copying '%s' to image" % prereq
+            self._copyToImage(prereq, "/upgrade-tester")
+
+    def _runBzrCheckoutUpgrade(self, cmd_prefix):
+        # start the upgrader
+        print "running the upgrader now"
+
+        # this is to support direct copying of backport udebs into the 
+        # qemu image - useful for testing backports without having to
+        # push them into the archive
+        upgrader_args = ""
+        upgrader_env = ""
+
+        backports = self.config.getlist("NonInteractive", "PreRequistsFiles")
+        if backports:
+            self._runInImage(["mkdir -p /upgrade-tester/backports"])
+            for f in backports:
+                print "Copying %s" % os.path.basename(f)
+                self._copyToImage(f, "/upgrade-tester/backports/")
+                self._runInImage(["(cd /upgrade-tester/backports ; dpkg-deb -x %s . )" % os.path.basename(f)])
+            upgrader_args = " --have-prerequists"
+            upgrader_env = "LD_LIBRARY_PATH=/upgrade-tester/backports/usr/lib PATH=/upgrade-tester/backports/usr/bin:$PATH PYTHONPATH=/upgrade-tester/backports//usr/lib/python$(python -c 'import sys; print \"%s.%s\" % (sys.version_info[0], sys.version_info[1])')/site-packages/ "
+
+        ret = self._runInImage(cmd_prefix+["(cd /upgrade-tester/ ; "
+                                "%s./dist-upgrade.py %s)" % (upgrader_env,
+                                                             upgrader_args)])
+        return ret
+
+    def test(self):
+        # - generate diff of upgrade vs fresh install
+        # ...
+        #self.genDiff()
+        self.start()
+        # check for crashes
+        self._copyFromImage("/var/crash/*.crash", self.resultdir)
+        crashfiles = glob.glob(self.resultdir+"/*.crash")
+        # run stuff in post_upgrade_tests dir
+        ok = True
+        results = []
+        for script in glob.glob(self.post_upgrade_tests_dir+"*"):
+            if not os.access(script, os.X_OK):
+                continue
+            result = {'name':os.path.basename(script),
+                      'result':'pass',
+                      'time':0,
+                      'message':''
+                     }
+            start_time = time.time()
+            logging.info("running '%s' post_upgrade_test" % script)
+            self._copyToImage(script, "/tmp/")
+            ret = self._runInImage(["/tmp/%s" % os.path.basename(script)])
+            if ret != 0:
+                print "WARNING: post_upgrade_test '%s' failed" % script
+                ok = False
+                log=open(self.resultdir+"/test-%s.FAIL" % os.path.basename(script), "w")
+                log.write("FAIL")
+                result['result'] = 'fail'
+                result['message'] = "post_upgrade_test '%s' failed" % script
+            result['time'] = time.time() - start_time
+            results.append(result)
+
+        # check for conffiles (the copy is done via a post upgrade script)
+        self._copyFromImage("/tmp/*.dpkg-dist", self.resultdir)
+        # Collect debconf prompts generated by debconf_test.py script
+        self._copyFromImage("/tmp/debconf_*.log", self.resultdir)
+        self.resultsToJunitXML(results, os.path.join(self.resultdir, 'results.xml'))
+
+        self.stop()
+        if len(crashfiles) > 0:
+            print "WARNING: crash files detected on the upgrade"
+            print crashfiles
+            return False
+        return ok

=== added file 'AutoUpgradeTester/UpgradeTestBackendSimulate.py'
--- AutoUpgradeTester/UpgradeTestBackendSimulate.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/UpgradeTestBackendSimulate.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,32 @@
+# UpgradeTestBackendSimulate.py
+#
+# test backend
+#
+
+import tempfile
+
+from UpgradeTestBackend import UpgradeTestBackend
+
+class UpgradeTestBackendSimulate(UpgradeTestBackend):
+
+    def __init__(self, profiledir, resultdir=""):
+        tmpdir = tempfile.mkdtemp()
+        super(UpgradeTestBackendSimulate, self).__init__(profiledir, resultdir=tmpdir)
+
+    def installPackages(self, pkgs):
+        print "simulate installing packages: %s" % ",".join(pkgs)
+
+    def bootstrap(self):
+        " bootstaps a pristine install"
+        print "simulate running bootstrap"
+        return True
+
+    def upgrade(self):
+        " upgrade a given install "
+        print "simulate running upgrade"
+        return True
+
+    def test(self):
+        " test if the upgrade was successful "
+        print "running post upgrade test"
+        return True

=== added file 'AutoUpgradeTester/__init__.py'
=== added file 'AutoUpgradeTester/apt-watchdog'
--- AutoUpgradeTester/apt-watchdog	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/apt-watchdog	2012-05-22 15:21:19 +0000
@@ -0,0 +1,50 @@
+#!/usr/bin/python
+#
+# this is watchdog that will try to kill hanging apt-get installs
+# that may happen when the auto-install-tester runs
+# 
+# its probably not useful for anything else
+
+import os
+import signal 
+import subprocess
+import sys
+import time
+
+# default kill time 60min
+WAKEUP_INTERVAL = 60*60
+
+def watchdog_loop():
+    watch_files = ["/var/log/apt/term.log",
+                   "/var/log/dist-upgrade/apt-term.log"]
+    mtime = 0
+    while True:
+        for f in watch_files:
+            if os.path.exists(f):
+                mtime = max(mtime, os.path.getmtime(f))
+        time.sleep(WAKEUP_INTERVAL)
+        for f in watch_files:
+            if os.path.exists(f):
+                if os.path.getmtime(f) > mtime:
+                    break
+        else:
+            print "no mtime change for %s seconds, sending SIGINT" % WAKEUP_INTERVAL
+            subprocess.call(["killall","-INT","apt-get"])
+        
+
+if __name__ == "__main__":
+    print "Starting apt watchdog daemon for the auto-install-tester"
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--no-daemon":
+        watchdog_loop()
+
+    # do the daemon thing
+    pid = os.fork()
+    if pid == 0:
+        os.setsid()
+        signal.signal(signal.SIGHUP, signal.SIG_IGN)
+        watchdog_loop()
+    else:
+        # add a little sleep to ensure child is setup
+        time.sleep(10)
+        os._exit(0)

=== added file 'AutoUpgradeTester/auto-install-tester.py'
--- AutoUpgradeTester/auto-install-tester.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/auto-install-tester.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,207 @@
+#!/usr/bin/python
+
+from optparse import OptionParser
+import os
+import os.path
+import time
+
+import sys
+sys.path.insert(0, "../DistUpgrade")
+
+from UpgradeTestBackendQemu import UpgradeTestBackendQemu
+
+import apt
+import apt_pkg
+
+def do_install_remove(backend, pkgname):
+    """ install a package in the backend """
+    #print "watchdog_runing: ", backend.watchdog_running
+    if not backend.watchdog_running:
+        print "starting watchdog"
+        backend._runInImage(["/bin/apt-watchdog"])
+        backend.watchdog_running = True
+#    ret = backend._runInImage(["DEBIAN_FRONTEND=text","DEBIAN_PRIORITY=low",
+#                               "apt-get","install","-q","-y",pkg.name])
+    ret = backend._runInImage(["DEBIAN_FRONTEND=noninteractive",
+                               "apt-get","install","-q","-y",pkg.name])
+    print "apt returned: ", ret
+    if ret != 0:
+        return False
+    # now remove it again
+    ret = backend._runInImage(["DEBIAN_FRONTEND=noninteractive",
+                               "apt-get","autoremove", "-y",pkg.name])
+    print "apt returned: ", ret
+    if ret != 0:
+        return False
+    return True
+
+def test_downloadable(backend, pkgname):
+    """ test if the pkg is downloadable or gives a 404 """ 
+    ret = backend._runInImage(["apt-get","install","-q","--download-only","-y",pkg.name])
+    print "apt --download-only returned: ", ret
+    if ret != 0:
+        return False
+    return True
+
+if __name__ == "__main__":
+
+    parser = OptionParser()
+    parser.add_option("-p", "--profile", dest="profile", 
+                      default="profile/auto-install-tester/",
+                      help="base profile dir")
+
+    (options, args) = parser.parse_args()
+
+    # create backend
+    apt_pkg.Config.Set("APT::Architecture","i386")
+    basedir = os.path.abspath(os.path.dirname(options.profile))
+    aptbasedir = os.path.join(basedir,"auto-install-test")
+
+
+    # create apt dirs if needed
+    for d in ["etc/apt/",
+              "var/lib/dpkg",
+              "var/lib/apt/lists/partial",
+              "var/cache/apt/archives/partial"]:
+        if not os.path.exists(os.path.join(aptbasedir,d)):
+            os.makedirs(os.path.join(aptbasedir,d))
+
+
+    backend = UpgradeTestBackendQemu(options.profile)
+    backend.watchdog_running = False
+    backend.bootstrap()
+
+    # copy status file from image to aptbasedir
+    backend.start()
+    print "copy apt-watchdog"
+    backend._copyToImage("apt-watchdog", "/bin/")
+    print "copy status file"
+    backend._copyFromImage("/var/lib/dpkg/status",
+                           os.path.join(aptbasedir,"var/lib/dpkg/","status"))
+    print "run update"
+    backend._runInImage(["apt-get","-q", "update"])
+    backend.stop()
+
+    # build apt stuff (outside of the kvm)
+    mirror = backend.config.get("NonInteractive","Mirror")
+    dist = backend.config.get("Sources","From")
+    components = backend.config.getlist("NonInteractive","Components")
+    pockets =  backend.config.getlist("NonInteractive","Pockets")
+    f=open(os.path.join(aptbasedir,"etc","apt","sources.list"),"w")
+    f.write("deb %s %s %s\n" % (mirror, dist, " ".join(components)))
+    for pocket in pockets:
+        f.write("deb %s %s-%s %s\n" % (mirror, dist, pocket, " ".join(components)))
+    f.close()
+    
+    # get a cache
+    cache = apt.Cache(rootdir=os.path.abspath(aptbasedir))
+    cache.update(apt.progress.text.AcquireProgress())
+    cache.open(apt.progress.OpProgress())
+
+    # now test if we can install stuff
+    backend.saveVMSnapshot("clean-base")
+    backend.start()
+
+    # setup dirs
+    resultdir = backend.resultdir
+    print "Using resultdir: '%s'" % resultdir
+    failures = open(os.path.join(resultdir,"failures.txt"),"w")
+
+    # pkg blacklist - only useful for pkg that causes exsessive delays
+    # when installing, e.g. by requiring input or by tryint to connect
+    # to a (firewalled) network
+    pkgs_blacklisted = set()
+    sname = os.path.join(resultdir,"pkgs_blacklisted.txt")
+    print "looking at ", sname
+    if os.path.exists(sname):
+        pkgs_blacklisted = set(open(sname).read().split("\n"))
+        print "have '%s' with '%i' entries" % (sname, len(pkgs_blacklisted))
+
+    # set with package that have been tested successfully
+    pkgs_tested = set()
+    sname = os.path.join(resultdir,"pkgs_done.txt")
+    print "looking at ", sname
+    if os.path.exists(sname):
+        pkgs_tested = set(open(sname).read().split("\n"))
+        print "have '%s' with '%i' entries" % (sname, len(pkgs_tested))
+        statusfile = open(sname, "a")
+    else:
+        statusfile = open(sname, "w")
+
+    # now see if we can install and remove it again
+    for (i, pkg) in enumerate(cache):
+#    for (i, pkg) in enumerate([ cache["abook"],
+#                                cache["emacspeak"],
+#                                cache["postfix"] ]):
+        # clean the cache
+        cache._depcache.Init()
+        print "\n\nPackage %s: %i of %i (%f.2)" % (pkg.name, i, len(cache), 
+                                             float(i)/float(len(cache))*100)
+        print "pkgs_tested has %i entries\n\n" % len(pkgs_tested)
+
+        pkg_failed = False
+
+        # skip stuff in the ubuntu-minimal that we can't install or upgrade
+        if pkg.is_installed and not pkg.is_upgradable:
+            continue
+
+        # skip blacklisted pkg names
+        if pkg.name in pkgs_blacklisted:
+            print "blacklisted: ", pkg.name
+            continue
+
+        # skip packages we tested already
+        if "%s-%s" % (pkg.name, pkg.candidateVersion) in pkgs_tested:
+            print "already tested: ", pkg.name
+            continue
+
+        # see if we can install/upgrade the pkg
+        try:
+            pkg.markInstall()
+        except SystemError, e:
+            pkg.markKeep()
+        if not (pkg.markedInstall or pkg.markedUpgrade):
+            print "pkg: %s not installable" % pkg.name
+            failures.write("%s markInstall()\n " % pkg.name)
+            continue
+        
+        if not test_downloadable(backend, pkg.name):
+            # because the test runs for so long its likely that we hit
+            # 404 because the archive has changed since we ran, deal with
+            # that here by not outputing it as a error for a start
+            # FIXME: restart whole test
+            continue
+
+        # mark as tested
+        statusfile.write("%s-%s\n" % (pkg.name, pkg.candidateVersion))
+            
+        if not do_install_remove(backend, pkg.name):
+            # on failure, re-run in a clean env so that the log
+            # is more meaningful
+            print "pkg: %s failed, re-testing in a clean(er) environment" % pkg.name
+            backend.restoreVMSnapshot("clean-base")
+            backend.watchdog_running = False
+            backend.start()
+            if not do_install_remove(backend, pkg.name):
+                outname = os.path.join(resultdir,"%s-fail.txt" % pkg.name)
+                failures.write("failed to install/remove %s (log at %s)\n" % (pkg.name, outname))
+                time.sleep(5)
+                backend._copyFromImage("/var/log/apt/term.log",outname)
+                                       
+                # now restore back to a clean state and continue testing
+                # (but do not record the package as succesful tested)
+                backend.restoreVMSnapshot("clean-base")
+                backend.watchdog_running = False
+                backend.start()
+                continue
+
+        # installation worked, record that we have tested this package
+        for pkg in cache:
+            if pkg.markedInstall or pkg.markedUpgrade:
+                pkgs_tested.add("%s-%s" % (pkg.name, pkg.candidateVersion))
+        statusfile.flush()
+        failures.flush()
+            
+    # all done, stop the backend
+    backend.stop()
+

=== added file 'AutoUpgradeTester/auto-upgrade-tester'
--- AutoUpgradeTester/auto-upgrade-tester	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/auto-upgrade-tester	2012-05-22 15:21:19 +0000
@@ -0,0 +1,383 @@
+#!/usr/bin/python -u
+# "-u": Force stdin, stdout and stderr to be  totally  unbuffered.
+#       To get more accurate log files
+# 
+# see also 
+# http://www.faqts.com/knowledge_base/entry/versions/index.phtml?aid=4419
+
+import datetime
+import glob
+import logging
+import multiprocessing
+import os
+import shutil
+import sys
+import time
+import subprocess
+from ConfigParser import SafeConfigParser
+
+# check if we run from a bzr checkout
+if os.path.exists("./UpgradeTestBackend.py"):
+    sys.path.insert(0, "../")
+
+from optparse import OptionParser
+from AutoUpgradeTester.UpgradeTestBackend import UpgradeTestBackend
+
+# bigger exitcode means more problematic error,
+# exitcode 101 means generic error
+class FailedToBootstrapError(Exception):
+    """ Failed to initial bootstrap the test system """
+    exitcode = 99
+
+class FailedToUpgradeError(Exception):
+    """ Failed to upgrade the test system """
+    exitcode = 98
+
+class FailedPostUpgradeTestError(Exception):
+    """ Some post upgrade tests failed """
+    exitcode = 97
+
+class OutputThread(multiprocessing.Process):
+    def __init__(self, filename):
+        multiprocessing.Process.__init__(self)
+        self.file = os.open(filename, os.O_RDONLY)
+    def run(self):
+        while True:
+            # the read() seems to not block for some reason
+            # but return "" ?!?
+            s = os.read(self.file, 1024)
+            if s:
+                print s,
+            else:
+                time.sleep(0.1)
+
+# FIXME: move this into the generic backend code
+def login(backend):
+    """ login into a backend """
+    backend.bootstrap()
+    backend.login()
+
+def createBackend(backend_name, profile):
+    """ create a backend of the given name for the given profile """
+    try:
+        backend_full_name = "AutoUpgradeTester.%s" % backend_name
+        backend_modul = __import__(backend_full_name, fromlist="AutoUpgradeTester")
+        backend_class = getattr(backend_modul, backend_name)
+    except (ImportError, AttributeError, TypeError), e:
+        logging.exception("can not import '%s'" % backend_name)
+        return None
+    return backend_class(profile)
+
+class HtmlOutputStream:
+    HTML_HEADER=r"""
+<?xml version="1.0" encoding="ascii"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+          "DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Auto upgrade tester</title>
+<style type="text/css">
+.error { background-color:#FF6600; }
+.warning { background-color:#FFA000; }
+.aright { text-align:right; }
+table { width:90%%; }
+</style>
+</head>
+<body>
+<h1>Automatic upgrade tester test results</h1>
+
+<p>Upgrade test started %(date)s</p>
+
+<table border="1">
+<tr><th>Profile</th><th>Result</th><th>Bugs</th><th>Date Finished</th><th>Runtime</th><th>Full Logs</th></tr>
+"""
+
+    HTML_FOOTER="""
+</table>
+<p>Upgrade test finished %s</p>
+</body>
+"""
+
+    def __init__(self, outputdir=None):
+        self.html_output = None
+        if outputdir:
+            self.outputdir = outputdir
+            if not os.path.exists(outputdir):
+                os.makedirs(outputdir)
+            self.html_output = open(os.path.join(outputdir, "index.html"), "w")
+    def write(self, s):
+        if self.html_output:
+            self.html_output.write(s)
+            self.html_output.flush()
+    def copy_results_and_add_table_link(self, profile_name, resultdir):
+        if not self.html_output:
+            return
+        # copy logs & sanitize permissions
+        targetdir = os.path.join(self.outputdir, profile_name)
+        html_output.copytree(resultdir, targetdir)
+        for f in glob.glob(targetdir+"/*"):
+            os.chmod(f, 0644)
+        # write html line that links to output dir
+        s = "<td><a href=\"./%(logdir)s\">Logs for %(profile)s test</a></td>" %  {
+            'logdir' : profile_name,
+            'profile': profile_name, }
+        html_output.write(s)
+    def copytree(self, src, dst):
+        if self.html_output:
+            shutil.copytree(src, dst)
+    def write_html_header(self, time_started):
+        self.write(self.HTML_HEADER % { 'date' : time_started })
+    def write_html_footer(self):
+        self.write(self.HTML_FOOTER % datetime.datetime.now())
+    
+def testUpgrade(backend_name, profile, add_pkgs, quiet=False,
+                html_output=HtmlOutputStream()):
+    """ test upgrade for the given backend/profile """
+    backend = createBackend(backend_name, profile)
+    assert(backend != None)
+    if not os.path.exists(profile):
+        print "ERROR: Can't find '%s' " % profile
+        html_output.write("<tr><td>Can't find profile '%s'</td>" % profile)
+        html_output.write(4*"<td></td>")
+        return 2
+    print "Storing the result in '%s'" % backend.resultdir
+    profile_name = os.path.split(os.path.normpath(profile))[1]
+    # setup output
+    outfile = os.path.join(backend.resultdir, "bootstrap.log")
+    fd = os.open(outfile, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, 0644)
+    out = OutputThread(outfile)
+    out.daemon = True
+    if not quiet:
+        out.start()
+    old_stdout = os.dup(1)
+    old_stderr = os.dup(2)
+    os.dup2(fd, 1)
+    os.dup2(fd, 2)
+    time_started = datetime.datetime.now()
+    print "%s log started" % time_started
+    result = 0
+    try:
+        # write what we working on
+        html_output.write("<td>%s</td>" % profile_name)
+        # init 
+        if not backend.bootstrap():
+            print "FAILED: bootstrap for '%s'" % profile
+            html_output.write("<td class=\"error\">Failed to bootstrap</td>")
+            raise FailedToBootstrapError("Failed to bootstrap '%s'" % profile)
+        if add_pkgs:
+            if not backend.installPackages(add_pkgs):
+                print "FAILED: installPacakges '%s'" % add_pkgs
+                html_output.write("<td class=\"error\">Failed to add pkgs '%s'</td>" % ",".join(add_pkgs))
+                raise Exception, "Failed to install packages '%s'" % add_pkgs
+        if not backend.upgrade():
+            print "FAILED: upgrade for '%s'" % profile
+            html_output.write("<td class=\"error\">Failed to upgrade</td>")
+            raise FailedToUpgradeError("Failed to upgrade %s" % profile)
+        if not backend.test():
+            print "FAILED: test for '%s'" % profile
+            html_output.write("<td class=\"warning\">Upgraded, but post upgrade test failed</td>")
+            raise FailedPostUpgradeTestError("Failed in post upgrade test %s" % profile)
+        print "profile: %s worked" % profile
+        html_output.write("<td>ok</td>")
+    except (FailedToBootstrapError, FailedToUpgradeError, FailedPostUpgradeTestError) as e:
+        print e
+        result = e.exitcode
+    except Exception, e:
+        import traceback
+        traceback.print_exc()
+        print "Caught exception in testUpgrade for '%s' (%s)" % (profile, e)
+        html_output.write("<td class=\"error\">Unknown failure (should not happen)</td>")
+        result = 2
+    finally:
+        # print out result details
+        print "Logs can be found here:"
+        for n in ["bootstrap.log", "main.log", "apt.log"]:
+            print " %s/%s" % (backend.resultdir, n)
+
+        time_ended = datetime.datetime.now()
+        print "%s log ended." % time_ended
+        print "Duration: %s" % (time_ended - time_started)
+
+        # give the output time to settle and kill the daemon
+        time.sleep(2)
+        if out.is_alive():
+            out.terminate()
+            out.join()
+        # write result line
+        s="<td></td><td>%(date)s</td><td class=\"aright\">%(runtime)s</td>" % {
+            'date'    : datetime.datetime.now(),
+            'runtime' : datetime.datetime.now() - time_started}
+        html_output.write(s)
+        html_output.copy_results_and_add_table_link(profile_name, backend.resultdir)
+        html_output.write("</tr>")
+    # close and restore file descriptors
+    os.close(fd)
+    os.dup2(old_stdout, 1)
+    os.dup2(old_stderr, 2)
+    return result
+
+def profileFromAptClone(aptclonefile):
+    """ Create a profile from an apt-clone archive
+
+    :param aptclonefile: Path to an apt-clone archive
+    :return: path to profile or None if it fails to recognize the clone file
+    """
+    profile = None
+    try:
+        cmd = ('apt-clone', 'info', aptclonefile)
+        output = subprocess.check_output(cmd)
+        clone_properties = {}
+        for k, v in [ line.split(': ') for line in output.split('\n') if ': ' in line]:
+            clone_properties[k] = v
+        try:
+            clone_date = datetime.datetime.strptime(clone_properties['Date'], '%c').strftime('_%Y%m%d-%H%M%S')
+        except:
+            clone_date = ''
+        profilename = "%s_%s_%s%s" % (
+            clone_properties['Distro'],
+            clone_properties['Arch'],
+            clone_properties['Hostname'],
+            clone_date)
+
+        # Generate configuration file for this profile
+        # FIXME:
+        # update packaging to grant write access on base for upgrade-tester user
+        ppath = 'profile' if os.path.exists("./UpgradeTestBackend.py") else base
+        profile = os.path.join(ppath, profilename)
+        profilecfg = SafeConfigParser()
+        if not os.path.exists(profile):
+            os.makedirs(profile)
+
+        profilecfg.set('DEFAULT', 'SourceRelease', clone_properties['Distro'])
+        profilecfg.add_section('NonInteractive')
+        profilecfg.set('NonInteractive', 'ProfileName', profilename)
+        profilecfg.set('NonInteractive', 'AptcloneFile', os.path.abspath(aptclonefile))
+        profilecfg.add_section('KVM')
+        profilecfg.set('KVM', 'Arch', clone_properties['Arch'])
+        with open(os.path.join(profile, 'DistUpgrade.cfg'), 'wb') as profilefile:
+            profilecfg.write(profilefile)
+
+    except subprocess.CalledProcessError:
+        return None
+
+    return profile
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+
+    parser = OptionParser()
+    parser.add_option("--additinoal", "--additional-pkgs", dest="add_pkgs", 
+                      default="",
+                      help="add additional pkgs before running the upgrade")
+    parser.add_option("-a", "--auto", dest="auto", default=False,
+                      action="store_true",
+                      help="run all tests in profile/ dir")
+    parser.add_option("--bootstrap-only", "--bootstrap-only",dest="bootstrap_only", 
+                      default=False,
+                      action="store_true",
+                      help="only bootstrap the image")
+    parser.add_option("--tests-only", "", default=False,
+                      action="store_true",
+                      help="only run post_upgrade_tests in the image")
+    parser.add_option("-l", "--login", dest="login", default=False,
+                      action="store_true",
+                      help="log into the a profile")
+    parser.add_option("-b", "--backend", dest="backend",
+                      default="UpgradeTestBackendQemu",
+                      help="UpgradeTestBackend to use: UpgradeTestBackendChroot, UpgradeTestBackendQemu")
+    parser.add_option("-d", "--diff", dest="gen_diff",
+                      default=False, action="store_true",
+                      help="generate a diff of the upgraded image versus a fresh installed image")
+    parser.add_option("--quiet", "--quiet", default=False, action="store_true",
+                      help="quiet operation")
+    parser.add_option("", "--html-output-dir", default=None,
+                      help="html output directory")
+    
+    (options, args) = parser.parse_args()
+
+    # save for later
+    fd1 = os.dup(1)
+    fd2 = os.dup(2)
+
+    # FIXME: move this to a configuration
+    base="/usr/share/auto-upgrade-tester/profiles/"
+    # check if we have something to do
+    profiles = args
+    if not profiles and not options.auto:
+        print sys.argv[0]
+        print "No profile specified, available default profiles:"
+        print "\n".join(os.listdir(base))
+        print 
+        print "Or use '-a' for 'auto' mode"
+        sys.exit(1)
+
+    # generic
+    res = 0
+    add_pkgs = []
+    if  options.add_pkgs:
+        add_pkgs = options.add_pkgs.split(",")
+    # auto mode
+    if options.auto:
+        print "running in auto-mode"
+        for d in os.listdir(base):
+            os.dup2(fd1, 1)
+            os.dup2(fd2, 2)
+            print "Testing '%s'" % d
+            res = max(res, testUpgrade(options.backend, base+d, add_pkgs))
+        sys.exit(res)
+    # profile mode, test the given profiles
+    time_started = datetime.datetime.now()
+
+    # clean output dir
+    html_output = HtmlOutputStream(options.html_output_dir)
+    html_output.write_html_header(time_started)
+    for profile in profiles:
+
+        # case of an apt-clone archive
+        if os.path.isfile(profile):
+            profilename = profileFromAptClone(profile)
+            if not profilename:
+                print "File is not a valid apt-clone image: %s" % profilename
+                continue
+            profile = profilename
+            print "Using generated profile: %s" % profile
+
+        if not "/" in profile:
+            profile = base + profile
+        try:
+            if options.login:
+                backend = createBackend(options.backend, profile)
+                login(backend)
+            elif options.bootstrap_only:
+                backend = createBackend(options.backend, profile)
+                backend.bootstrap(force=True)
+            elif options.tests_only:
+                backend = createBackend(options.backend, profile)
+                backend.test()
+            elif options.gen_diff:
+                backend = createBackend(options.backend, profile)
+                backend.genDiff()
+            else:
+                print "Testing '%s'" % profile
+                now = datetime.datetime.now()
+                current_res = testUpgrade(options.backend, profile, 
+                                          add_pkgs, options.quiet,
+                                          html_output)
+                if current_res == 0: 
+                    print "Profile '%s' worked" % profile
+                else:
+                    print "Profile '%s' FAILED" % profile
+                res = max(res, current_res)
+        except Exception, e:
+            import traceback
+            print "ERROR: exception caught '%s' " % e
+            html_output.write('<pre class="error">unhandled ERROR %s:\n%s</pre>' % (e, traceback.format_exc()))
+            traceback.print_exc()
+            if hasattr(e, "exitcode"):
+                res = max(res, e.exitcode)
+            else:
+                res = max(res, 101)
+    html_output.write_html_footer()
+
+    # return exit code
+    sys.exit(res)

=== added file 'AutoUpgradeTester/auto-upgrade-tester-jenkins-slave'
--- AutoUpgradeTester/auto-upgrade-tester-jenkins-slave	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/auto-upgrade-tester-jenkins-slave	2012-05-22 15:21:19 +0000
@@ -0,0 +1,60 @@
+#!/usr/bin/python
+# 
+# Copyright (C) 2010, Canonical Ltd (http://www.canonical.com/)
+#
+# This file is part of ubuntu-server-iso-testing.
+# 
+# ubuntu-server-iso-testing 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 3 of 
+# the License, or (at your option) any later version.
+# 
+# ubuntu-server-iso-testing 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 ubuntu-server-iso-testing.  If not, see 
+# <http://www.gnu.org/licenses/>.
+# 
+
+import logging
+import optparse
+import os
+import urllib
+import sys
+import subprocess
+import socket
+
+usage="usage: %prog [options] HUDSON_URL"
+parser = optparse.OptionParser(usage=usage)
+parser.add_option("-d", "--debug", dest="debug", action="store_true",  default=False,
+                                help="enable debugging")
+parser.add_option("-n", "--nodename",  dest="nodename", default=socket.gethostname(), 
+                                help="hostname to use when registering with hudson (default=hostname)")
+(options, args) = parser.parse_args()
+
+if len(args) == 0:
+    logging.error("Need a HUDSON_URL to execute")
+    parser.print_help()
+    sys.exit(1)
+
+if options.debug:
+    logging.basicConfig(level=logging.DEBUG)
+else:
+    logging.basicConfig(level=logging.INFO)
+
+HUDSON_URL=args[0]
+HUDSON_PATH="/computer/%s/slave-agent.jnlp"
+SLAVE_URL=HUDSON_URL + 'jnlpJars/slave.jar'
+SLAVE_JAR=os.path.expanduser("~/.slave.jar")
+
+l_hudson_url= HUDSON_URL + HUDSON_PATH % options.nodename
+
+logging.debug("Retrieving hudson slave.jar")
+urllib.urlretrieve(SLAVE_URL, SLAVE_JAR)
+
+cmd = [ 'java','-jar', SLAVE_JAR, '-jnlpUrl', l_hudson_url ]
+logging.debug("Cmd: %s" % (cmd))
+subprocess.check_call(cmd)

=== added file 'AutoUpgradeTester/chart_dpkg_progress.py'
--- AutoUpgradeTester/chart_dpkg_progress.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/chart_dpkg_progress.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+
+
+import sys
+import string
+from heapq import heappush, heappop
+
+if __name__ == "__main__":
+    
+    start_time = 0.0
+    last_time = 0.0
+    total_time = 0.0
+    pkgs = {}
+    last_pkgname = None
+
+    log = open(sys.argv[1])
+    for line in map(string.strip, log):
+        line_data = line.split(":")
+
+        # special cases
+        if line_data[1].strip() == "Start":
+            start_time = float(line_data[0])
+            continue
+        elif line_data[1].strip() == "Finished":
+            total_time = float(line_data[0]) - start_time
+            continue
+
+        # we have a real pkg here
+        current_time = float(line_data[0])
+        pkgname = line_data[2]
+        
+        # special cases
+        if not last_time:
+            last_time = current_time
+        if not pkgname in pkgs:
+            pkgs[pkgname] = 0
+
+        # add up time
+        if last_pkgname:
+            pkgs[last_pkgname] += (current_time-last_time)
+        last_time = current_time
+        last_pkgname = pkgname
+    
+    
+    # put into heap and output by time it takes
+    heap = []
+    for pkg in pkgs:
+        heappush(heap, (pkgs[pkg], pkg))
+    while heap:
+        print "%.6ss: %s" % heappop(heap)
+    print "total: %4.7ss %4.6sm" % (total_time, total_time/60)

=== added file 'AutoUpgradeTester/install_all.py'
--- AutoUpgradeTester/install_all.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/install_all.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,235 @@
+#!/usr/bin/python
+
+
+import apt
+import apt_pkg
+import re
+import os
+import string
+import sys
+
+# global install blacklist
+pkg_blacklist = None
+
+# whitelist regexp to include only certain packages (useful for e.g.
+# installing only all python packages)
+pkg_whitelist = ""
+
+class InstallProgress(apt.progress.base.InstallProgress):
+   " Out install progress that can automatically remove broken pkgs "
+   def error(self, pkg, errormsg):
+      # on failure: 
+      # - add failing package to "install_failures.txt"  [done]
+      # - remove package from best.txt [done]
+      # FIXME: - remove all rdepends from best.txt
+      # - remove the failed install attempts [done]
+      #   * explode if a package can not be removed and let the user cleanup
+      open("install_failures.txt","a").write("%s _:_ %s" % (pkg, errormsg))
+      bad = set()
+      bad.add(os.path.basename(pkg).split("_")[0])
+      # FIXME: just run apt-cache rdepends $pkg here?
+      #        or use apt.Package.candidateDependencies ?
+      #        or calculate the set again? <- BEST!
+      for name in bad:
+         new_best = open("best.txt").read().replace(name+"\n","")
+         open("best.txt","w").write(new_best)
+         open("install_blacklist.cfg","a").write("# auto added by install_all.py\n%s\n" % name)
+
+def do_install(cache):
+   # go and install
+   res = False
+   current = 0
+   maxRetries = 5
+   while current < maxRetries:
+      print "Retry: ", current
+      try:
+         res = cache.commit(apt.progress.text.AcquireProgress(),
+                            InstallProgress())
+         break
+      except IOError, e:
+         # fetch failed, will be retried
+         current += 1
+         print "Retrying to fetch: ", current, e
+         continue
+      except SystemError, e:
+         print "Error installing packages! "
+         print e
+         print "Install result: ",res
+         break
+   # check for failed packages and remove them
+   if os.path.exists("install_failures.txt"):
+      failures =  set(map(lambda s: os.path.basename(s.split("_:_")[0]).split("_")[0], 
+                          open("install_failures.txt").readlines()))
+      print "failed: ", failures
+      assert(os.system("dpkg -r %s" % " ".join(failures)) == 0)
+      assert(os.system("dpkg --configure -a") == 0)
+      # remove pos.txt and best.txt to force recalculation
+      os.unlink("pos.txt")
+      os.unlink("best.txt")
+   return res
+
+def blacklisted(name):
+   global pkg_blacklist
+   if pkg_blacklist is None and os.path.exists("install_blacklist.cfg"):
+      pkg_blacklist = set()
+      for name in map(string.strip, open("install_blacklist.cfg").readlines()):
+         if name and not name.startswith("#"):
+            pkg_blacklist.add(name)
+      print "blacklist: ", pkg_blacklist
+   if pkg_blacklist:
+      for b in pkg_blacklist:
+	   if re.match(b, name):
+              return True
+   return False
+
+def reapply(cache, pkgnames):
+   for name in pkgnames:
+      cache[name].mark_install(False)
+
+def contains_blacklisted_pkg(cache):
+   for pkg in cache:
+      if pkg.marked_install and blacklisted(pkg.name):
+         return True
+   return False
+
+
+# ----------------------------------------------------------------
+
+#apt_pkg.Config.Set("Dir::State::status","./empty")
+
+# debug stuff
+#apt_pkg.Config.Set("Debug::pkgProblemResolver","true")
+#apt_pkg.Config.Set("Debug::pkgDepCache::AutoInstall","true")
+#apt_pkg.Config.Set("Debug::pkgDpkgPM","true")
+
+# Increase the maxsize limits here
+#
+# this code in apt that splits the argument list if its too long
+#  is problematic, because it may happen that
+# the argument list is split in a way that A depends on B
+# and they are in the same "--configure A B" run
+# - with the split they may now be configured in different
+#   runs 
+
+apt_pkg.config.set("Dpkg::MaxArgs",str(16*1024))
+apt_pkg.config.set("Dpkg::MaxArgBytes",str(64*1024))
+
+print "install_all.py"
+os.environ["DEBIAN_FRONTEND"] = "noninteractive"
+os.environ["APT_LISTCHANGES_FRONTEND"] = "none"
+
+cache = apt.Cache()
+
+# dapper does not have this yet 
+group = cache.actiongroup()
+#print [pkg.name for pkg in cache if pkg.is_installed]
+
+# see what gives us problems
+troublemaker = set()
+best = set()
+
+# first install all of main, then the rest
+comps= ["main","universe"]
+i=0
+
+# reapply checkpoints
+if os.path.exists("best.txt"):
+   best = map(string.strip, open("best.txt").readlines())
+   reapply(cache, best)
+
+if os.path.exists("pos.txt"):
+   (comp, i) = open("pos.txt").read().split()
+   i = int(i)
+   if comp == "universe":
+      comps = ["universe"]
+
+sorted_pkgs = cache.keys()[:]
+sorted_pkgs.sort()
+
+
+for comp in comps:
+   for pkgname in sorted_pkgs[i:]:
+      # skip multiarch packages
+      if ":" in pkgname:
+         continue
+      pkg = cache[pkgname]
+      i += 1
+      percent = (float(i)/len(cache))*100.0
+      print "\r%.3f     " % percent,
+      sys.stdout.flush()
+      # ignore stuff that does not match the whitelist pattern
+      # (if we use this)
+      if pkg_whitelist:
+         if not re.match(pkg_whitelist, pkg.name):
+            #print "skipping '%s' (not in whitelist)" % pkg.name
+            continue
+      print "looking at ", pkg.name
+      # only work on stuff that has a origin
+      if pkg.candidate:
+         for c in pkg.candidate.origins:
+            if comp == None or c.component == comp:
+               current = set([p.name for p in cache if p.marked_install])
+               if not (pkg.is_installed or blacklisted(pkg.name)):
+                  try:
+                     pkg.mark_install()
+                  except SystemError, e:
+                     print "Installing '%s' cause problems: %s" % (pkg.name, e)
+                     pkg.mark_keep()
+                  # check blacklist
+                  if contains_blacklisted_pkg(cache):
+                     cache.clear()
+                     reapply(cache, best)
+                     continue
+                  new = set([p.name for p in cache if p.marked_install])
+                  #if not pkg.marked_install or len(new) < len(current):
+                  if not (pkg.is_installed or pkg.marked_install):
+                     print "Can't install: %s" % pkg.name
+                  if len(current-new) > 0:
+                     troublemaker.add(pkg.name)
+                     print "Installing '%s' caused removals %s" % (pkg.name, current - new)
+                  # FIXME: instead of len() use score() and score packages
+                  #        according to criteria like "in main", "priority" etc
+                  if len(new) >= len(best):
+                     best = new
+                     open("best.txt","w").write("\n".join(best))
+                     open("pos.txt","w").write("%s %s" % (comp, i))
+                  else:
+                     print "Installing '%s' reduced the set (%s < %s)" % (pkg.name, len(new), len(best))
+                     cache.clear()
+                     reapply(cache, best)
+   i=0
+
+# make sure that the ubuntu base packages are installed (and a bootloader)
+print len(troublemaker)
+for pkg in ["ubuntu-desktop", "ubuntu-minimal", "ubuntu-standard", "grub-pc"]:
+    cache[pkg].mark_install()
+
+# make sure we don't install blacklisted stuff
+for pkg in cache:
+	if blacklisted(pkg.name):
+		pkg.mark_keep()
+
+# install it
+print "We can install:", len([pkg.name for pkg in cache if pkg.marked_install])
+# get size
+pm = apt_pkg.PackageManager(cache._depcache)
+fetcher = apt_pkg.Acquire()
+pm.get_archives(fetcher, cache._list, cache._records)
+print "Download: ", apt_pkg.size_to_str(fetcher.fetch_needed)
+print "Total space: ", apt_pkg.size_to_str(cache._depcache.usr_size)
+
+# write out file with all pkgs
+outf = "all_pkgs.cfg"
+print "writing out file with the selected package names to '%s'" % outf
+f = open(outf, "w")
+f.write("\n".join([pkg.name for pkg in cache if pkg.marked_install]))
+f.close()
+
+# now do the real install
+res = do_install(cache)
+
+if not res:
+   # FIXME: re-exec itself
+   sys.exit(1)
+
+sys.exit(0)

=== added file 'AutoUpgradeTester/install_all_main.py'
--- AutoUpgradeTester/install_all_main.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/install_all_main.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,79 @@
+#!/usr/bin/python
+
+import apt
+import apt_pkg
+
+def blacklisted(name):
+	# we need to blacklist linux-image-* as it does not install
+	# cleanly in the chroot (postinst failes)
+	blacklist = ["linux-image-","ltsp-client",
+		     "glibc-doc-reference", "libpthread-dev",
+		     "cman", "mysql-server", "fuse-utils",
+		     "ltspfs", "gfs2-tools", "edubuntu-server",
+		     "gnbd-client", "gnbd-server", "mysql-server-5.0",
+		     "rgmanager", "clvm","redhat-cluster-suit",
+		     # has a funny "can not be upgraded automatically" policy
+		     # see debian #368226
+		     "quagga",
+		     "system-config-cluster", "gfs-tools"]
+	for b in blacklist:
+		if name.startswith(b):
+			return True
+	return False
+
+#apt_pkg.Config.Set("Dir::State::status","./empty")
+
+cache = apt.Cache()
+group = apt_pkg.GetPkgActionGroup(cache._depcache)
+#print [pkg.name for pkg in cache if pkg.is_installed]
+
+troublemaker = set()
+for pkg in cache:
+    for c in pkg.candidateOrigin:
+        if c.component == "main":
+            current = set([p.name for p in cache if p.marked_install])
+	    if not (pkg.is_installed or blacklisted(pkg.name)):
+	            pkg.mark_install()
+            new = set([p.name for p in cache if p.marked_install])
+            #if not pkg.markedInstall or len(new) < len(current):
+	    if not (pkg.is_installed or pkg.marked_install):
+                print "Can't install: %s" % pkg.name
+            if len(current-new) > 0:
+                troublemaker.add(pkg.name)
+                print "Installing '%s' caused removals_ %s" % (pkg.name, current - new)
+
+#print len(troublemaker)
+for pkg in ["ubuntu-desktop", "ubuntu-minimal", "ubuntu-standard"]:
+    cache[pkg].mark_install()
+
+# make sure we don't install blacklisted stuff
+for pkg in cache:
+	if blacklisted(pkg.name):
+		pkg.mark_keep()
+
+print "We can install:"
+print len([pkg.name for pkg in cache if pkg.marked_install])
+print "Download: "
+pm = apt_pkg.GetPackageManager(cache._depcache)
+fetcher = apt_pkg.GetAcquire()
+pm.GetArchives(fetcher, cache._list, cache._records)
+print apt_pkg.SizeToStr(fetcher.FetchNeeded)
+print "Total space: ", apt_pkg.SizeToStr(cache._depcache.UsrSize)
+
+res = False
+current = 0
+maxRetries = 3
+while current < maxRetries:
+    try:
+        res = cache.commit(apt.progress.text.AcquireProgress(),
+                           apt.progress.base.InstallProgress())    
+    except IOError, e:
+        # fetch failed, will be retried
+        current += 1
+        print "Retrying to fetch: ", current
+        continue
+    except SystemError, e:
+        print "Error installing packages! "
+        print e
+    print "Install result: ",res
+    break

=== added file 'AutoUpgradeTester/install_blacklist.cfg'
--- AutoUpgradeTester/install_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/install_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,33 @@
+# file-overwrite problem with libc6-dev
+libpthread-dev
+# FUBAR (was removed in feisty)
+glibc-doc-reference
+# has a funny "can not be upgraded automatically" policy
+# see debian #368226
+quagga
+# the following packages try to access /lib/modules/`uname -r` and fail
+vmware-player-kernel-.*
+# not installable on a regular machine
+ltsp-client
+ltsp-client-core
+# why is this in the archive?
+debsig-verify
+# speedbar,ede fails for some reason
+speedbar
+ede
+ecb
+emacs-snapshot
+# ec2
+ec2-init
+linux-image-ec2
+linux-image-2.6.31-302-ec2
+
+bacula-director-mysql
+linux-backports-modules-wireless-2.6.32-21-generic-pae
+linux-backports-modules-wireless-2.6.32-22-generic-pae
+linux-backports-modules-wireless-2.6.32-23-generic-pae
+linux-backports-modules-wireless-2.6.32-24-generic-pae
+
+# no fun
+cloud-init
+eucalyptus-.*
\ No newline at end of file

=== added file 'AutoUpgradeTester/install_universe'
--- AutoUpgradeTester/install_universe	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/install_universe	2012-05-22 15:21:19 +0000
@@ -0,0 +1,263 @@
+#!/usr/bin/python
+"""
+Install all packages with a desktop file in app-install-data
+"""
+
+
+import apt
+import apt_pkg
+import re
+import os
+import string
+import sys
+
+# global install blacklist
+pkg_blacklist = None
+
+# whitelist regexp to include only certain packages (useful for e.g.
+# installing only all python packages)
+pkg_whitelist = ""
+
+class InstallProgress(apt.progress.base.InstallProgress):
+   " Out install progress that can automatically remove broken pkgs "
+   def error(self, pkg, errormsg):
+      # on failure: 
+      # - add failing package to "install_failures.txt"  [done]
+      # - remove package from best.txt [done]
+      # FIXME: - remove all rdepends from best.txt
+      # - remove the failed install attempts [done]
+      #   * explode if a package can not be removed and let the user cleanup
+      open("install_failures.txt","a").write("%s _:_ %s" % (pkg, errormsg))
+      bad = set()
+      bad.add(os.path.basename(pkg).split("_")[0])
+      # FIXME: just run apt-cache rdepends $pkg here?
+      #        or use apt.Package.candidateDependencies ?
+      #        or calculate the set again? <- BEST!
+      for name in bad:
+         new_best = open("best.txt").read().replace(name+"\n","")
+         open("best.txt","w").write(new_best)
+         open("install_blacklist.cfg","a").write("# auto added by install_all.py\n%s\n" % name)
+
+def do_install(cache):
+   # go and install
+   res = False
+   current = 0
+   maxRetries = 5
+   while current < maxRetries:
+      print "Retry: ", current
+      try:
+         res = cache.commit(apt.progress.text.AcquireProgress(),
+                            InstallProgress())
+         break
+      except IOError, e:
+         # fetch failed, will be retried
+         current += 1
+         print "Retrying to fetch: ", current, e
+         continue
+      except SystemError, e:
+         print "Error installing packages! "
+         print e
+         print "Install result: ",res
+         break
+   # check for failed packages and remove them
+   if os.path.exists("install_failures.txt"):
+      failures =  set(map(lambda s: os.path.basename(s.split("_:_")[0]).split("_")[0], 
+                          open("install_failures.txt").readlines()))
+      print "failed: ", failures
+      assert(os.system("dpkg -r %s" % " ".join(failures)) == 0)
+      assert(os.system("dpkg --configure -a") == 0)
+      # remove pos.txt and best.txt to force recalculation
+      os.unlink("pos.txt")
+      os.unlink("best.txt")
+   return res
+
+def blacklisted(name):
+   global pkg_blacklist
+   if pkg_blacklist is None and os.path.exists("install_blacklist.cfg"):
+      pkg_blacklist = set()
+      for name in map(string.strip, open("install_blacklist.cfg").readlines()):
+         if name and not name.startswith("#"):
+            pkg_blacklist.add(name)
+      print "blacklist: ", pkg_blacklist
+   if pkg_blacklist:
+      for b in pkg_blacklist:
+	   if re.match(b, name):
+              return True
+   return False
+
+def reapply(cache, pkgnames):
+   for name in pkgnames:
+      cache[name].mark_install(False)
+
+def contains_blacklisted_pkg(cache):
+   for pkg in cache:
+      if pkg.marked_install and blacklisted(pkg.name):
+         return True
+   return False
+
+def appinstall_pkgs():
+    import ConfigParser
+
+    APPINSTALL_DIR = "/usr/share/app-install/desktop"
+
+    content = ConfigParser.ConfigParser()
+    pkgs = []
+
+    # List of sections to skip. This must be a valid regular expression
+    # We must exclude window managers to not kill ourselves
+    for dsk in os.listdir(APPINSTALL_DIR):
+        dskfile = os.path.join(APPINSTALL_DIR, dsk)
+        if not 'desktop' in dsk[-7:]:
+            continue
+        try:
+            content.read(dskfile)
+            pkg = content.get('Desktop Entry', 'X-AppInstall-Package')
+            if not pkg in pkgs:
+                pkgs.append(pkg)
+        except:
+            print "Error: unable to parse %s" % dskfile
+            continue
+
+    return pkgs
+
+# ----------------------------------------------------------------
+
+#apt_pkg.Config.Set("Dir::State::status","./empty")
+
+# debug stuff
+#apt_pkg.Config.Set("Debug::pkgProblemResolver","true")
+#apt_pkg.Config.Set("Debug::pkgDepCache::AutoInstall","true")
+#apt_pkg.Config.Set("Debug::pkgDpkgPM","true")
+
+# Increase the maxsize limits here
+#
+# this code in apt that splits the argument list if its too long
+#  is problematic, because it may happen that
+# the argument list is split in a way that A depends on B
+# and they are in the same "--configure A B" run
+# - with the split they may now be configured in different
+#   runs
+
+apt_pkg.config.set("Dpkg::MaxArgs",str(16*1024))
+apt_pkg.config.set("Dpkg::MaxArgBytes",str(64*1024))
+
+print "*** installings all packages from app-install-data ***"
+os.environ["DEBIAN_FRONTEND"] = "noninteractive"
+os.environ["APT_LISTCHANGES_FRONTEND"] = "none"
+
+cache = apt.Cache()
+
+# dapper does not have this yet
+group = cache.actiongroup()
+#print [pkg.name for pkg in cache if pkg.is_installed]
+
+# see what gives us problems
+troublemaker = set()
+best = set()
+
+# first install all of main, then the rest
+comps= ["main","universe"]
+i=0
+
+# reapply checkpoints
+if os.path.exists("best.txt"):
+   best = map(string.strip, open("best.txt").readlines())
+   reapply(cache, best)
+
+comp = None
+if os.path.exists("pos.txt"):
+   (comp, i) = open("pos.txt").read().split()
+   i = int(i)
+
+sorted_pkgs = appinstall_pkgs()
+sorted_pkgs.sort()
+
+for pkgname in sorted_pkgs[i:]:
+  # skip multiarch packages
+  i += 1
+  if ":" in pkgname:
+     continue
+  try:
+     pkg = cache[pkgname]
+  except:
+     print "WARNING: No package named %s" % pkg
+     continue
+  percent = (float(i)/len(sorted_pkgs))*100.0
+  print "\r%.3f     " % percent,
+  sys.stdout.flush()
+  # ignore stuff that does not match the whitelist pattern
+  # (if we use this)
+  if pkg_whitelist:
+     if not re.match(pkg_whitelist, pkg.name):
+        #print "skipping '%s' (not in whitelist)" % pkg.name
+        continue
+  print "looking at ", pkg.name
+  # only work on stuff that has a origin
+  if pkg.candidate:
+     for c in pkg.candidate.origins:
+        comp = c.component
+        if not (pkg.is_installed or blacklisted(pkg.name)):
+          current = set([p.name for p in cache if p.marked_install])
+          try:
+             pkg.mark_install()
+          except SystemError, e:
+             print "Installing '%s' cause problems: %s" % (pkg.name, e)
+             pkg.mark_keep()
+          # check blacklist
+          if contains_blacklisted_pkg(cache):
+             cache.clear()
+             reapply(cache, best)
+             continue
+          new = set([p.name for p in cache if p.marked_install])
+          #if not pkg.marked_install or len(new) < len(current):
+          if not (pkg.is_installed or pkg.marked_install):
+             print "Can't install: %s" % pkg.name
+          if len(current-new) > 0:
+             troublemaker.add(pkg.name)
+             print "Installing '%s' caused removals %s" % (pkg.name, current - new)
+          # FIXME: instead of len() use score() and score packages
+          #        according to criteria like "in main", "priority" etc
+          if len(new) >= len(best):
+             best = new
+             open("best.txt","w").write("\n".join(best))
+             open("pos.txt","w").write("%s %s" % (comp, i))
+          else:
+             print "Installing '%s' reduced the set (%s < %s)" % (pkg.name, len(new), len(best))
+             cache.clear()
+             reapply(cache, best)
+i=0
+
+# make sure that the ubuntu base packages are installed (and a bootloader)
+print len(troublemaker)
+for pkg in ["ubuntu-desktop", "ubuntu-minimal", "ubuntu-standard", "grub-pc"]:
+    cache[pkg].mark_install()
+
+# make sure we don't install blacklisted stuff
+for pkg in cache:
+	if blacklisted(pkg.name):
+		pkg.mark_keep()
+
+# install it
+print "We can install:", len([pkg.name for pkg in cache if pkg.marked_install])
+# get size
+pm = apt_pkg.PackageManager(cache._depcache)
+fetcher = apt_pkg.Acquire()
+pm.get_archives(fetcher, cache._list, cache._records)
+print "Download: ", apt_pkg.size_to_str(fetcher.fetch_needed)
+print "Total space: ", apt_pkg.size_to_str(cache._depcache.usr_size)
+
+# write out file with all pkgs
+outf = "all_pkgs.cfg"
+print "writing out file with the selected package names to '%s'" % outf
+f = open(outf, "w")
+f.write("\n".join([pkg.name for pkg in cache if pkg.marked_install]))
+f.close()
+
+# now do the real install
+res = do_install(cache)
+
+if not res:
+   # FIXME: re-exec itself
+   sys.exit(1)
+
+sys.exit(0)

=== added directory 'AutoUpgradeTester/jenkins'
=== added file 'AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave'
--- AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave	2012-05-22 15:21:19 +0000
@@ -0,0 +1,12 @@
+# init configuration script for hudson-slave 
+# User and Group to execute slave daemon asa
+# defaults to the ubuntu server iso testing
+# account as part of this package
+USER=upgrade-tester
+GROUP=nogroup
+# URL to access Hudson Master Server
+HUDSON_MASTER=
+# Options to pass to hudson-slave
+# OPTS="-d"
+# Run at startup
+STARTUP=false

=== added file 'AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave.conf'
--- AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave.conf	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/jenkins/auto-upgrade-tester-jenkins-slave.conf	2012-05-22 15:21:19 +0000
@@ -0,0 +1,28 @@
+# Hudson Slave
+
+description "auto-upgrade-tester-jenkins-slave: distributed job control"
+author "James Page <[e-mail]>"
+
+start on (local-filesystems and net-device-up IFACE!=lo)
+stop on runlevel [!2345]
+
+pre-start script
+    . /etc/default/auto-upgrade-tester-jenkins-slave
+    test -x /usr/bin/auto-upgrade-tester-jenkins-slave || { stop ; exit 0; }
+    test -r /etc/default/auto-upgrade-tester-jenkins-slave || { stop ; exit 0; }
+    test "${STARTUP}" = "true" || { stop; exit 0; }
+end script
+
+script
+    . /etc/default/auto-upgrade-tester-jenkins-slave
+
+    JDK_DIRS="/usr/lib/jvm/java-6-openjdk /usr/lib/jvm/java-6-sun"
+    for jdir in $JDK_DIRS; do
+        if [ -r "$jdir/bin/java" -a -z "${JAVA_HOME}" ]; then
+            JAVA_HOME="$jdir"
+        fi
+    done
+    export JAVA_HOME
+    
+    exec start-stop-daemon --start --chuid $USER:$GROUP --exec /usr/bin/auto-upgrade-tester-jenkins-slave -- $OPTS $HUDSON_MASTER 
+end script

=== added directory 'AutoUpgradeTester/jeos'
=== added file 'AutoUpgradeTester/jeos/README'
--- AutoUpgradeTester/jeos/README	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/jeos/README	2012-05-22 15:21:19 +0000
@@ -0,0 +1,49 @@
+Create the images by simply running 
+$ ./create-base-image.sh maverick 
+(or whatever distroibution release you want to create)
+
+
+===== old info below ====
+
+Images created with:
+
+First create a ssh key:
+$ ssh-keygen -N '' -f ssh-key
+
+[intrepid]
+
+Can use the official ubuntu-vm-builder pacakges]
+
+$ sudo ubuntu-vm-builder kvm intrepid --kernel-flavour generic  --ssh-key `pwd`/ssh-key.pub  --components main,restricted  --rootsize 80000 --arch i386
+$ mv ubuntu-kvm/disk0.qcow2 intrepid-i386.qcow2
+- login and check if openssh-server is installed (intrepid ubuntu-vm-builder FTW)
+
+For old releases:
+
+$ bzr get http://bazaar.launchpad.net/~mvo/ubuntu-jeos/mvo
+
+[hardy]
+$ ./ubuntu-jeos-builder --vm kvm --kernel-flavour generic --suite hardy --ssh-key `pwd`/ssh-key.pub  --components main,restricted  --rootsize 80G --no-opt
+
+[gutsy]
+$ ./ubuntu-jeos-builder --vm kvm --kernel-flavour generic --suite gutsy --ssh-key `pwd`/ssh-key.pub  --components main,restricted  --rootsize 80G --no-opt
+
+
+[feisty]
+$ ./ubuntu-jeos-builder --vm kvm --kernel-flavour generic --suite feisty --ssh-key `pwd`/ssh-key.pub  --components main,restricted  --rootsize 80G --no-opt
+
+[dapper]
+$ ./ubuntu-jeos-builder --vm kvm --kernel-flavour 386 --suite dapper --ssh-key `pwd`/foo.pub  --components main,restricted  --rootsize 80G --no-opt
+
+(notice the different kernel names for dapper,feisty). The ssh-key is the 
+key that is used by the upgrade tester to log into the virtual machine.
+
+The copy it from 
+"jeos/ubuntu-jeos-$dist-i386/root.qcow2"
+to 
+"jeos/$dist-i386.qcow2"
+
+Make sure you copy the "ssh-key" file into the profile dir so that the 
+upgrade tester can access it
+
+

=== added file 'AutoUpgradeTester/jeos/create-base-image.sh'
--- AutoUpgradeTester/jeos/create-base-image.sh	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/jeos/create-base-image.sh	2012-05-22 15:21:19 +0000
@@ -0,0 +1,36 @@
+#!/bin/sh
+
+set -e
+
+DIST=$(lsb_release -c -s)
+
+if [ -z "$1" ]; then
+    echo "need distro codename to create as first argument "
+    exit 1
+fi
+
+# check depends
+if [ ! -f /usr/bin/ubuntu-vm-builder ]; then
+    apt-get install -y ubuntu-vm-builder
+fi
+
+if [ ! -f /usr/bin/kvm ]; then
+    apt-get install -y kvm
+fi
+
+# create a default ssh key
+if [ ! -e ssh-key ]; then
+    ssh-keygen -N '' -f ssh-key
+fi
+
+KERNEL=generic
+if [ "$1" = "dapper" ]; then
+	KERNEL=386
+fi
+
+# create the image
+ubuntu-vm-builder kvm $1 --kernel-flavour $KERNEL --ssh-key $(pwd)/ssh-key.pub \
+    --components main,restricted --rootsize 80000 --arch i386 --dest ubuntu-$1
+
+# move into place
+mv ubuntu-$1/*.qcow2 $1-i386.qcow2

=== added directory 'AutoUpgradeTester/post_upgrade_tests'
=== added file 'AutoUpgradeTester/post_upgrade_tests/README'
--- AutoUpgradeTester/post_upgrade_tests/README	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/README	2012-05-22 15:21:19 +0000
@@ -0,0 +1,8 @@
+The scripts in this folder are run after the upgrade was performed
+and after a reboot. They can test various functionality like
+- is the latest kernel running
+- is the xserver running
+- is python still working
+- are my daemons still running
+
+etc

=== added file 'AutoUpgradeTester/post_upgrade_tests/conffiles_test.sh'
--- AutoUpgradeTester/post_upgrade_tests/conffiles_test.sh	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/conffiles_test.sh	2012-05-22 15:21:19 +0000
@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e
+
+find /etc -name "*.dpkg-dist" -exec cp '{}' /tmp \;
+
+# check if we have a dpkg-dist file
+if ls /tmp/*.dpkg-dist 2>/dev/null; then
+   exit 1
+fi
+
+exit 0
\ No newline at end of file

=== added file 'AutoUpgradeTester/post_upgrade_tests/debconf_test.py'
--- AutoUpgradeTester/post_upgrade_tests/debconf_test.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/debconf_test.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,65 @@
+#!/usr/bin/python
+"""
+Parse debconf log file and split in a file per prompt
+Exit with status 1 if there is a debconf prompt not in whitelist
+"""
+import re, os, sys
+
+# Keep this path in sync with the corresponding setting in
+# profile/defaults.cfg.d/defaults.cfg
+DEBCONF_LOG_PATH = '/var/log/dist-upgrade/debconf.log'
+RESULT_DIR = '/tmp'
+
+# Prompts in this list won't generate a test failure
+# i.e WHITELIST = ['libraries/restart-without-asking']
+WHITELIST = [
+    'glibc/restart-services',
+    'libraries/restart-without-asking' ]
+
+def run_test(logfile, resultdir):
+    """ Run the test and slice debconf log
+
+    :param logfile: Path to debconf log
+    :param resultdir: Output directory to write log file to
+    """
+    global WHITELIST
+
+    ret = 0
+    if not os.path.exists(logfile):
+        return ret
+
+    re_dsetting = re.compile('^\w')
+    inprompt = False
+    prompt = dsetting = ""
+
+    with open(logfile, 'r') as f_in:
+        for line in f_in.readlines():
+            # Only keep interesting bits of the prompt
+            if line.startswith('#####'):
+                inprompt = not inprompt
+
+                # Reached the second separator, write content to result file
+                # One per  prompt
+                if not inprompt:
+                    print "Got debconf prompt for '%s'" % dsetting
+                    if dsetting in WHITELIST:
+                        print '    But it is in Whitelist. Skipping!'
+                        continue
+                    else:
+                        ret = 1
+
+                    with open(os.path.join(
+                        resultdir,
+                        'debconf_%s.log' % dsetting.replace('/', '_')),
+                        'w') as f_out:
+                        f_out.write(prompt)
+
+            if inprompt:
+                prompt += line
+                if re_dsetting.match(line) and '=' in line:
+                    dsetting = line.split('=')[0]
+
+    return ret
+
+if __name__ == '__main__':
+    sys.exit(run_test(DEBCONF_LOG_PATH, RESULT_DIR))

=== added file 'AutoUpgradeTester/post_upgrade_tests/debsums_lite.py'
--- AutoUpgradeTester/post_upgrade_tests/debsums_lite.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/debsums_lite.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,19 @@
+#!/usr/bin/python
+
+import glob
+import os
+import subprocess
+import sys
+
+basepath = "/var/lib/dpkg/info/*.md5sums"
+ok = True
+for f in glob.glob(basepath):
+    ret = subprocess.call(["md5sum", "--quiet", "-c", 
+                           os.path.join(basepath, f)],
+                          cwd="/")
+    if ret != 0:
+        ok = False
+
+if not ok:
+    print "WARNING: at least one md5sum mismatch"
+    sys.exit(1)

=== added file 'AutoUpgradeTester/post_upgrade_tests/kernel_test.py'
--- AutoUpgradeTester/post_upgrade_tests/kernel_test.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/kernel_test.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,24 @@
+#!/usr/bin/python
+
+import apt_pkg
+import glob
+import os
+import sys
+
+current_kernelver = os.uname()[2]
+
+apt_pkg.init()
+
+vers = set()
+for k in glob.glob("/boot/vmlinuz-*"):
+    ver = "-".join(k.split("-")[1:3])
+    vers.add(ver)
+    if apt_pkg.VersionCompare(current_kernelver, ver) < 0:
+        print "WARNING: there is a kernel version '%s' installed higher than the running kernel" % (ver, current_kernelver)
+        sys.exit(1)
+
+print "kernel versions: %s" % ", ".join(vers)
+if len(vers) < 2:
+    print "WARNING: only one kernel version found '%s'" % vers
+    print "expected at least two (new + previous)"
+    sys.exit(1)

=== added file 'AutoUpgradeTester/post_upgrade_tests/python_import_test.py'
--- AutoUpgradeTester/post_upgrade_tests/python_import_test.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/python_import_test.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,104 @@
+#!/usr/bin/python -u
+
+import logging
+import os
+import subprocess
+import sys
+
+
+OLD_PYTHONVER="python2.6"
+NEW_PYTHONVER="python2.7"
+
+OLD_BASEPATH="/usr/lib/%s/dist-packages/" % OLD_PYTHONVER
+NEW_BASEPATH="/usr/lib/%s/dist-packages/" % NEW_PYTHONVER
+
+# total imports
+TOTAL = 0
+FAIL = 0
+
+# stuff that we know does not work when doing a simple "import"
+blacklist = ["speechd_config", 
+             "PAMmodule.so", 
+             "aomodule.so",
+             "plannerui.so",
+             # needs a KeyringDaemon
+             "desktopcouch",
+             # just hangs
+             "ropemacs",
+             # needs X
+             "keyring",
+             "invest",
+             "Onboard",
+             "goocanvasmodule.so",
+             ]
+
+def get_module_from_path(path):
+    f = os.path.basename(path)
+    if path and os.path.exists(os.path.join(path, "__init__.py")):
+        return f
+    elif f.endswith(".py"):
+        return f.split(".")[0]
+    # swig uses this, calls it "foomodule.so" but the import is "foo"
+    # (eg xdelta3module.so, pqueuemodule.so)
+    elif f.endswith("module.so"):
+        return f.split("modules.so")[0]
+    elif f.endswith(".so"):
+        return f.split(".")[0]
+
+def try_import(path):
+    global TOTAL, FAIL
+    logging.info("Importing %s" % path)
+    # a simple __import__(module) does not work, the problem
+    # is that module import have funny side-effects (like
+    # "import uno; import pyatspi" will fail, but importing
+    # them individually is fine
+    module = get_module_from_path(path)
+    if not module:
+        logging.warn("could not get module for '%s'" % path)
+        return True
+    cmd = ["python", "-c","import %s" % module]
+    logging.debug("cmd: '%s'" % cmd)
+    TOTAL += 1
+    ret = subprocess.call(cmd)
+    if ret != 0:
+        FAIL += 1
+        print "WARNING: failed to import '%s'" % module
+        subprocess.call(["dpkg", "-S", os.path.realpath(path)])
+        print "\n\n"
+        return False
+    return True
+
+def py_module_filter(pymodule):
+    f = pymodule
+    # ignore a bunch of modules that 
+    if (f.endswith(".egg-info") or
+        f.endswith(".pth") or 
+        f.startswith("_") or
+        f.endswith(".pyc") or 
+        f.endswith("_d.so") or
+        f in blacklist):
+        return False
+    return True
+            
+if __name__ == "__main__":
+    #logging.basicConfig(level=logging.DEBUG)
+
+    # Only compare if old and new paths exists
+    # When previous version of python is dropped then only new exists
+    if os.path.exists(OLD_BASEPATH) and os.path.exists(NEW_BASEPATH):
+        old_modules = set(filter(py_module_filter, os.listdir(OLD_BASEPATH)))
+        new_modules = set(filter(py_module_filter, os.listdir(NEW_BASEPATH)))
+        print "Available for the old version, but *not* the new: %s\n" % (
+            ", ".join(old_modules - new_modules))
+
+    res = True
+    # FIXME: instead os os.listdir() use os.walk() to catch subdirs
+    #        like lazr/* ?
+    for f in filter(py_module_filter, os.listdir(NEW_BASEPATH)):
+        logging.debug("looking at '%s'" % f)
+        res &= try_import(os.path.join(NEW_BASEPATH, f))
+
+    print "Total imports: %s" % TOTAL
+    print "Failures: %s" % FAIL
+    if not res:
+        sys.exit(1)

=== added file 'AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_system.py'
--- AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_system.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_system.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,66 @@
+#!/usr/bin/python
+#
+# This script checks system-wide configuration settings after an Ubuntu 10.04
+# LTS to Ubuntu 12.04 LTS upgrade. Run this after upgrading to 12.04 or later.
+# It reads the old gdm settings and ensures that they were appropriately
+# migrated to lightdm and that lightdm is the default DM.
+# It does not need any particular privileges, it is fine to run this as any
+# user.
+#
+# (C) 2012 Canonical Ltd.
+# Author: Martin Pitt <[e-mail]>
+# License: GPL v2 or higher
+
+import unittest
+import os, sys
+import ConfigParser
+
+class T(unittest.TestCase):
+    @classmethod
+    def setUpClass(klass):
+        # read gdm configuration
+        klass.gdm_config = klass._read_conf('/etc/gdm/custom.conf', 'daemon')
+        klass.lightdm_config = klass._read_conf('/etc/lightdm/lightdm.conf', 'SeatDefaults')
+
+    def test_lightdm_default_dm(self):
+        '''lightdm is the default display manager'''
+
+        with open('/etc/X11/default-display-manager') as f:
+            default_dm = f.read().strip()
+
+        self.assertTrue(os.access(default_dm, os.X_OK))
+        self.assertEqual(os.path.basename(default_dm), 'lightdm')
+
+    def test_autologin_migration(self):
+        '''autologin migration from gdm to lightdm'''
+
+        if self.gdm_config.get('automaticloginenable', 'false') == 'true':
+            gdm_autologin = self.gdm_config.get('automaticlogin', '')
+        else:
+            gdm_autologin = ''
+
+        self.assertEqual(gdm_autologin, self.lightdm_config.get('autologin-user', ''))
+
+    @classmethod
+    def _read_conf(klass, filename, section):
+        '''Read section from an INI configuration file.
+
+        Return a dictionary with the configuration of the given section.
+        '''
+        p = ConfigParser.ConfigParser()
+        p.read(filename)
+        config = {}
+        try:
+            for (key, value) in p.items(section):
+                config[key] = value
+        except ConfigParser.NoSectionError:
+            # just keep an empty config
+            pass
+        return config
+
+# Only run on lts-ubuntu testcases
+if not os.path.exists('/upgrade-tester/prepare_lts_desktop'):
+    print "Not an Ubuntu Desktop LTS upgrade. Skipping!"
+    sys.exit(0)
+
+unittest.main()

=== added file 'AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_user.py'
--- AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_user.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/test_lts_upgrade_user.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,98 @@
+#!/usr/bin/python
+#
+# This script checks user configuration settings after an Ubuntu 10.04
+# LTS to Ubuntu 12.04 LTS upgrade. Run prepare_lts_upgrade_user.sh in 10.04
+# LTS, then upgrade to 12.04 LTS (or later), and run this script to confirm
+# that settings were migrated properly. In particular this checks for gconf ->
+# gsettings migration (and sometimes changing the format of the values) for
+# popular settings, as well as custom panel/desktop launchers.
+#
+# You need to run both the prepare and this test script as the same user,
+# in a full desktop session.
+#
+# (C) 2012 Canonical Ltd.
+# Author: Martin Pitt <[e-mail]>
+# License: GPL v2 or higher
+
+import unittest
+import os, sys
+import subprocess
+
+try:
+    from gi.repository import Gio
+except:
+    # Not a desktop
+    print "Failed to import gi.repository. Not a LTS Desktop Upgrade. Skipping!"
+    sys.exit(0)
+
+class T(unittest.TestCase):
+    def test_background(self):
+        '''background image'''
+
+        bg_settings = Gio.Settings('org.gnome.desktop.background')
+        # note: original gconf value does not have a file:// prefix, but GNOME
+        # 3.x requires this prefix
+        self.assertEqual(bg_settings.get_string('picture-uri'),
+                'file://%s/mybackground.jpg' % os.environ['HOME'])
+
+    def test_gtk_theme(self):
+        '''GTK theme'''
+
+        iface_settings = Gio.Settings('org.gnome.desktop.interface')
+        self.assertEqual(iface_settings.get_string('gtk-theme'), 'Radiance')
+
+    def test_custom_launchers(self):
+        '''Custom panel/desktop launchers appear in Unity launcher'''
+
+        launcher_settings = Gio.Settings('com.canonical.Unity.Launcher')
+        favorites = launcher_settings['favorites']
+
+        # gedit was dragged from Application menu to panel, pointing to system
+        # .desktop file
+        self.assertTrue('gedit.desktop' in favorites)
+
+        # custom "echo hello" panel starter uses its own .desktop file
+        for starter in favorites:
+            if 'echo' in starter:
+                self.assertTrue(os.path.exists(starter))
+                break
+        else:
+            self.fail('custom hello starter not found')
+
+        # gucharmap was dragged from Application menu to desktop, should be
+        # converted to system .desktop file
+        self.assertTrue('gucharmap.desktop' in favorites)
+
+        # custom "bc -l" desktop starter uses its own .desktop file
+        self.assertTrue('%s/Desktop/termcalc.desktop' % os.environ['HOME'] in favorites)
+
+    def test_keyboard_layouts(self):
+        '''Custom keyboard layouts are migrated and applied'''
+
+        # verify gconf->gsettings migration
+        kbd_settings = Gio.Settings('org.gnome.libgnomekbd.keyboard')
+        self.assertEqual(kbd_settings['layouts'],
+                '[us,de\tnodeadkeys,gb,gb\tdvorak]')
+
+# NO DISPLAY IN AUTOMATED TEST
+#        # verify that they get applied to the X server correctly
+#        xprop = subprocess.Popen(['xprop', '-root', '_XKB_RULES_NAMES'],
+#                stdout=subprocess.PIPE)
+#        out = xprop.communicate()[0]
+#        self.assertEqual(xprop.returncode, 0)
+#
+#        # chop off key name
+#        out = out.split('=', 1)[1].strip()
+#
+#        self.assertEqual(out, '"evdev", "pc105", "us,de,gb,gb", ",nodeadkeys,,dvorak", "grp:alts_toggle"')
+
+# Only run on lts-ubuntu testcases
+if not os.path.exists('/upgrade-tester/prepare_lts_desktop'):
+    print "Not an Ubuntu Desktop LTS upgrade. Skipping!"
+    sys.exit(0)
+
+if os.getuid() == 0:
+    # Root ? reexecute itself as user ubuntu
+    subprocess.call('sudo -H -u ubuntu dbus-launch %s' % os.path.abspath(__file__), shell=True)
+else:
+    unittest.main()

=== added file 'AutoUpgradeTester/post_upgrade_tests/xserver_test.py'
--- AutoUpgradeTester/post_upgrade_tests/xserver_test.py	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/post_upgrade_tests/xserver_test.py	2012-05-22 15:21:19 +0000
@@ -0,0 +1,29 @@
+#!/usr/bin/python
+
+import glob
+import os
+import subprocess
+import sys
+import time
+
+def is_process_running(procname):
+    proclist = subprocess.Popen(["ps","-eo","comm"], stdout=subprocess.PIPE).communicate()[0]
+    for line in proclist.split("\n"):
+        if line == procname:
+            return True
+    return False
+    
+if __name__ == "__main__":
+    if os.path.exists("/usr/bin/X") or glob.glob("/var/log/Xorg*.log"):
+        #print "Checking for running Xorg"
+	for i in range(10):
+            if not is_process_running("Xorg"):
+                print "Xorg not running yet, waiting"
+                # wait a bit to and see if it comes up
+                time.sleep(10)
+                if not is_process_running("Xorg"):
+                    print "WARNING: /usr/bin/X found but no Xorg running"
+                    sys.exit(1)
+
+            
+    

=== added file 'AutoUpgradeTester/prepare_lts_desktop'
--- AutoUpgradeTester/prepare_lts_desktop	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/prepare_lts_desktop	2012-05-22 15:21:19 +0000
@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# Setup Autologin
+cat > /etc/gdm/custom.conf <<EOF
+
+[daemon]
+TimedLoginEnable=false
+AutomaticLoginEnable=true
+TimedLogin=ubuntu
+AutomaticLogin=ubuntu
+TimedLoginDelay=30
+DefaultSession=gnome
+EOF
+
+# Execute User setup script
+USERSETUP="/upgrade-tester/data/prepare_lts_user"
+TARGETUSER="ubuntu"
+
+if [ -f "$USERSETUP" ]; then
+    chmod +x $USERSETUP
+    sudo -i -u $TARGETUSER sh $USERSETUP
+fi

=== added file 'AutoUpgradeTester/prepare_lts_user'
--- AutoUpgradeTester/prepare_lts_user	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/prepare_lts_user	2012-05-22 15:21:19 +0000
@@ -0,0 +1,116 @@
+#!/bin/sh
+# This script sets some popular user configuration settings in an Ubuntu 10.04
+# LTS GNOME system. Run this, then upgrade to 12.04 LTS (or later), and run
+# test_lts_upgrade_user.py to confirm that settings were migrated properly. In
+# particular this checks for gconf -> gsettings migration (and sometimes
+# changing the format of the values) for popular settings, as well as custom
+# panel/desktop launchers.
+#
+# You need to run this script in a fully running GNOME desktop session.
+
+#
+# (C) 2012 Canonical Ltd.
+# Author: Martin Pitt <[e-mail]>
+# License: GPL v2 or higher
+
+set -e
+
+echo "Setting custom background..."
+cp `ls /usr/share/backgrounds/*.jpg | head -n1` $HOME/mybackground.jpg
+gconftool -s /desktop/gnome/background/picture_filename --type string $HOME/mybackground.jpg
+
+echo "Setting Radiance theme..."
+gconftool -s /desktop/gnome/interface/gtk_theme --type string Radiance
+
+echo "Adding custom panel launchers..."
+# add launcher for system desktop file (gedit)
+gconftool -s /apps/panel/objects/object_0/menu_path --type string 'applications:/'
+gconftool -s /apps/panel/objects/object_0/launcher_location --type string '/usr/share/applications/gedit.desktop'
+gconftool -s /apps/panel/objects/object_0/bonobo_iid --type string ''
+gconftool -s /apps/panel/objects/object_0/custom_icon --type string ''
+gconftool -s /apps/panel/objects/object_0/locked --type bool false
+gconftool -s /apps/panel/objects/object_0/panel_right_stick --type bool false
+gconftool -s /apps/panel/objects/object_0/object_type --type string 'launcher-object'
+gconftool -s /apps/panel/objects/object_0/use_custom_icon --type bool false
+gconftool -s /apps/panel/objects/object_0/tooltip --type string ''
+gconftool -s /apps/panel/objects/object_0/toplevel_id --type string 'top_panel_screen0'
+gconftool -s /apps/panel/objects/object_0/action_type --type string 'lock'
+gconftool -s /apps/panel/objects/object_0/use_menu_path --type bool false
+gconftool -s /apps/panel/objects/object_0/position --type int 60
+gconftool -s /apps/panel/objects/object_0/attached_toplevel_id --type string ''
+
+# add launcher for custom desktop file
+mkdir -p $HOME/.gnome2/panel2.d/default/launchers/
+mkdir -p $HOME/Desktop
+
+cat <<EOF > $HOME/.gnome2/panel2.d/default/launchers/echo-1.desktop
+#!/usr/bin/env xdg-open
+[Desktop Entry]
+Version=1.0
+Type=Application
+Terminal=true
+Icon[en_US]=partner
+Name[en_US]=hello
+Exec=echo hello
+Name=hello
+Icon=gnome-panel-launcher
+EOF
+chmod 755 $HOME/.gnome2/panel2.d/default/launchers/echo-1.desktop
+gconftool -s /apps/panel/objects/object_1/menu_path --type string 'applications:/'
+gconftool -s /apps/panel/objects/object_1/launcher_location --type string 'echo-1.desktop'
+gconftool -s /apps/panel/objects/object_1/bonobo_iid --type string ''
+gconftool -s /apps/panel/objects/object_1/custom_icon --type string ''
+gconftool -s /apps/panel/objects/object_1/locked --type bool false
+gconftool -s /apps/panel/objects/object_1/panel_right_stick --type bool false
+gconftool -s /apps/panel/objects/object_1/object_type --type string 'launcher-object'
+gconftool -s /apps/panel/objects/object_1/use_custom_icon --type bool false
+gconftool -s /apps/panel/objects/object_1/tooltip --type string ''
+gconftool -s /apps/panel/objects/object_1/toplevel_id --type string 'top_panel_screen0'
+gconftool -s /apps/panel/objects/object_1/action_type --type string 'lock'
+gconftool -s /apps/panel/objects/object_1/use_menu_path --type bool false
+gconftool -s /apps/panel/objects/object_1/position --type int 90
+gconftool -s /apps/panel/objects/object_1/attached_toplevel_id --type string ''
+
+# add the two new launchers to the panel object list
+old_list=`gconftool -g /apps/panel/general/object_id_list | sed 's/]$//'`
+gconftool -s /apps/panel/general/object_id_list --type list --list-type string "$old_list,object_0,object_1]"
+
+echo "Adding custom desktop launchers ..."
+cat <<EOF > $HOME/Desktop/gucharmap.desktop
+#!/usr/bin/env xdg-open
+[Desktop Entry]
+Name=Character Map
+Comment=Insert special characters into documents
+Exec=gucharmap
+Icon=accessories-character-map
+Terminal=false
+Type=Application
+Categories=GNOME;GTK;Utility;
+X-GNOME-Bugzilla-Bugzilla=GNOME
+X-GNOME-Bugzilla-Product=gucharmap
+X-GNOME-Bugzilla-Component=general
+X-GNOME-Bugzilla-Version=2.30.0
+StartupNotify=true
+X-Ubuntu-Gettext-Domain=gucharmap
+EOF
+chmod 755 $HOME/Desktop/gucharmap.desktop
+
+cat <<EOF > $HOME/Desktop/termcalc.desktop
+#!/usr/bin/env xdg-open
+
+[Desktop Entry]
+Version=1.0
+Type=Application
+Terminal=true
+Icon[en_US]=/usr/share/icons/gnome/scalable/apps/calc.svg
+Name[en_US]=termcalc
+Exec=bc -l
+Name=termcalc
+Icon=/usr/share/icons/gnome/scalable/apps/calc.svg
+EOF
+chmod 755 $HOME/Desktop/termcalc.desktop
+
+echo "Setting custom keyboard layouts..."
+gconftool -s /desktop/gnome/peripherals/keyboard/kbd/layouts --type list --list-type string "[us,de	nodeadkeys,gb,gb	dvorak]"
+
+echo 'Success. Now upgrade to 12.04 LTS and run test_lts_upgrade_user.py'

=== added directory 'AutoUpgradeTester/profile'
=== added directory 'AutoUpgradeTester/profile/auto-install-tester'
=== added file 'AutoUpgradeTester/profile/auto-install-tester/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/auto-install-tester/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/auto-install-tester/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,60 @@
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+[Distro]
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+
+[Aufs]
+;EnableFullOverlay=yes
+;EnableChrootOverlay=yes
+;EnableChrootRsync=yes
+
+[Sources]
+From=lucid
+To=lucid
+
+[NonInteractive]
+ProfileName=auto-install-tester
+BasePkg = ubuntu-standard
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+;Mirror = http://us.ec2.archive.ubuntu.com/ubuntu
+;Proxy=http://192.168.1.1:3128/
+ForceOverwrite=no
+Components=main,restricted,universe
+Pockets=security,updates
+UpgradeFromDistOnBootstrap=true
+;AddRepo=local_testing.list
+DpkgProgressLog=yes
+ResultDir=/var/cache/auto-upgrade-tester/result
+SSHKey=/var/cache/auto-upgrade-tester/ssh-key
+DebugBrokenScripts=yes
+
+[KVM]
+Virtio=True
+VncNum=3
+SshPort=54324
+ImageDir=/var/cache/auto-upgrade-tester/
+CacheImageDir=/var/cache/auto-upgrade-tester/
+BaseImage=%(ImageDir)s/lucid-i386.qcow2
+;SwapImage=jeos/swap.qcow2
+CacheBaseImage=yes
+
+[EC2]
+; Ubuntu official images:
+; https://help.ubuntu.com/community/EC2StartersGuide#Getting%20the%20images
+;AMI=ami-44bb5c2d
+; inofficial image
+AMI=ami-0d729464
+SSHKey=./ec2-keypair.pem
+;Specify the security groups you want attached to
+;the instance. For example:
+;SecurityGroups = ssh,web
+; Set this to "yes" if using an Ubuntu official AMI as we need to
+; allow root logins
+;UbuntuOfficialAMI = yes
+
+[CHROOT]
+Tempdir=/tmp/upgrade-tester
+CacheTarball=yes

=== added file 'AutoUpgradeTester/profile/auto-install-tester/pkgs.cfg'
--- AutoUpgradeTester/profile/auto-install-tester/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/auto-install-tester/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,1 @@
+update-manager-core

=== added file 'AutoUpgradeTester/profile/auto-install-tester/pkgs_blacklist.txt'
--- AutoUpgradeTester/profile/auto-install-tester/pkgs_blacklist.txt	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/auto-install-tester/pkgs_blacklist.txt	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+emacspeak
+espeak
+pioneers-meta-server

=== added directory 'AutoUpgradeTester/profile/dapper-hardy-lucid-server'
=== added file 'AutoUpgradeTester/profile/dapper-hardy-lucid-server/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/dapper-hardy-lucid-server/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/dapper-hardy-lucid-server/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,67 @@
+# 
+# this is a dapper->hardy->lucid test image
+# - its cheated because the base image was dapper and then it was
+#   *manually* upgraded to hardy, but because we cache the base
+#   image this is ok and its a dapper->hardy->lucid upgrade from 
+#   that point on
+
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+[Distro]
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+
+[Aufs]
+;EnableFullOverlay=yes
+;EnableChrootOverlay=yes
+;EnableChrootRsync=yes
+
+[Sources]
+From=hardy
+To=lucid
+
+[NonInteractive]
+ProfileName=dapper-hardy-lucid-server
+BasePkg = ubuntu-standard
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+;Mirror = http://us.ec2.archive.ubuntu.com/ubuntu
+;Proxy=http://192.168.1.1:3128/
+ForceOverwrite=no
+Components=main,restricted
+Pockets=security,updates
+UpgradeFromDistOnBootstrap=true
+;AddRepo=local_testing.list
+DpkgProgressLog=yes
+ResultDir=/var/cache/auto-upgrade-tester/result
+SSHKey=/var/cache/auto-upgrade-tester/ssh-key
+DebugBrokenScripts=yes
+
+[KVM]
+Virtio=True
+VncNum=1
+SshPort=54322
+ImageDir=/var/cache/auto-upgrade-tester/
+CacheImageDir=/var/cache/auto-upgrade-tester/
+BaseImage=%(ImageDir)s/dapper-i386.qcow2
+;SwapImage=jeos/swap.qcow2
+CacheBaseImage=yes
+
+[EC2]
+; Ubuntu official images:
+; https://help.ubuntu.com/community/EC2StartersGuide#Getting%20the%20images
+;AMI=ami-44bb5c2d
+; inofficial image
+AMI=ami-0d729464
+SSHKey=./ec2-keypair.pem
+;Specify the security groups you want attached to
+;the instance. For example:
+;SecurityGroups = ssh,web
+; Set this to "yes" if using an Ubuntu official AMI as we need to
+; allow root logins
+;UbuntuOfficialAMI = yes
+
+[CHROOT]
+Tempdir=/tmp/upgrade-tester
+CacheTarball=yes

=== added directory 'AutoUpgradeTester/profile/dapper-hardy-lucid-ubuntu'
=== added file 'AutoUpgradeTester/profile/dapper-hardy-lucid-ubuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/dapper-hardy-lucid-ubuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/dapper-hardy-lucid-ubuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,67 @@
+# 
+# this is a dapper->hardy->lucid test image
+# - its cheated because the base image was dapper and then it was
+#   *manually* upgraded to hardy, but because we cache the base
+#   image this is ok and its a dapper->hardy->lucid upgrade from 
+#   that point on
+
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+[Distro]
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+
+[Aufs]
+;EnableFullOverlay=yes
+;EnableChrootOverlay=yes
+;EnableChrootRsync=yes
+
+[Sources]
+From=hardy
+To=lucid
+
+[NonInteractive]
+ProfileName=dapper-hardy-lucid-ubuntu
+BasePkg = ubuntu-desktop
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+;Mirror = http://us.ec2.archive.ubuntu.com/ubuntu
+;Proxy=http://192.168.1.1:3128/
+ForceOverwrite=no
+Components=main,restricted
+Pockets=security,updates
+UpgradeFromDistOnBootstrap=true
+;AddRepo=local_testing.list
+DpkgProgressLog=yes
+ResultDir=/var/cache/auto-upgrade-tester/result
+SSHKey=/var/cache/auto-upgrade-tester/ssh-key
+DebugBrokenScripts=yes
+
+[KVM]
+Virtio=True
+VncNum=1
+SshPort=54322
+ImageDir=/var/cache/auto-upgrade-tester/
+CacheImageDir=/var/cache/auto-upgrade-tester/
+BaseImage=%(ImageDir)s/dapper-i386.qcow2
+;SwapImage=jeos/swap.qcow2
+CacheBaseImage=yes
+
+[EC2]
+; Ubuntu official images:
+; https://help.ubuntu.com/community/EC2StartersGuide#Getting%20the%20images
+;AMI=ami-44bb5c2d
+; inofficial image
+AMI=ami-0d729464
+SSHKey=./ec2-keypair.pem
+;Specify the security groups you want attached to
+;the instance. For example:
+;SecurityGroups = ssh,web
+; Set this to "yes" if using an Ubuntu official AMI as we need to
+; allow root logins
+;UbuntuOfficialAMI = yes
+
+[CHROOT]
+Tempdir=/tmp/upgrade-tester
+CacheTarball=yes

=== added directory 'AutoUpgradeTester/profile/defaults.cfg.d'
=== added file 'AutoUpgradeTester/profile/defaults.cfg.d/defaults.cfg'
--- AutoUpgradeTester/profile/defaults.cfg.d/defaults.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/defaults.cfg.d/defaults.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,63 @@
+# global defaults, override as needed in the indivual configuration
+# files
+#
+[DEFAULT]
+AutoUpgradeTesterBaseDir=/var/cache
+SourceRelease=oneiric
+TargetRelease=precise
+
+[Distro]
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+
+[Distro]
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+
+[Sources]
+From=%(SourceRelease)s
+To=%(TargetRelease)s
+
+[NonInteractive]
+BasePkg = ubuntu-standard
+Mirror = http://archive.ubuntu.com/ubuntu
+ForceOverwrite=no
+Components=main,restricted
+Pockets=security,updates
+UpgradeFromDistOnBootstrap=false
+DpkgProgressLog=no
+ResultDir=%(AutoUpgradeTesterBaseDir)s/auto-upgrade-tester/result
+SSHKey=%(AutoUpgradeTesterBaseDir)s/auto-upgrade-tester/ssh-key
+DebugBrokenScripts=yes
+UseUpgraderFromBzr=false
+;AddRepo=local_testing.list
+DebconfLog=/var/log/dist-upgrade/debconf.log
+
+
+[KVM]
+Virtio=True
+Arch=i386
+ImageDir=%(AutoUpgradeTesterBaseDir)s/auto-upgrade-tester/
+CacheImageDir=%(AutoUpgradeTesterBaseDir)s/auto-upgrade-tester/
+BaseImage=%(ImageDir)s/%(SourceRelease)s-%(Arch)s.qcow2
+CacheBaseImage=yes
+VncNum=1
+SshPort=54322
+VirtualRam=1536
+RootSize=80000
+
+[EC2]
+; Ubuntu official images:
+; https://help.ubuntu.com/community/EC2StartersGuide#Getting%20the%20images
+;AMI=ami-44bb5c2d
+; inofficial image
+AMI=ami-0d729464
+SSHKey=./ec2-keypair.pem
+;Specify the security groups you want attached to
+;the instance. For example:
+;SecurityGroups = ssh,web
+; Set this to "yes" if using an Ubuntu official AMI as we need to
+; allow root logins
+;UbuntuOfficialAMI = yes
+
+[CHROOT]
+Tempdir=/tmp/upgrade-tester
+CacheTarball=yes

=== added directory 'AutoUpgradeTester/profile/edubuntu'
=== added file 'AutoUpgradeTester/profile/edubuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/edubuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/edubuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,8 @@
+[Sources]
+Components=main,restricted,universe,multiverse
+
+[NonInteractive]
+ProfileName = edubuntu
+BasePkg = edubuntu-desktop
+Components=main,restricted,universe,multiverse
+

=== added symlink 'AutoUpgradeTester/profile/edubuntu/demoted.cfg'
=== target is u'../../demoted.cfg'
=== added directory 'AutoUpgradeTester/profile/edubuntu/result'
=== added symlink 'AutoUpgradeTester/profile/edubuntu/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/euca-cloud'
=== added file 'AutoUpgradeTester/profile/euca-cloud/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/euca-cloud/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/euca-cloud/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,4 @@
+[NonInteractive]
+ProfileName=eua-cloud
+AdditionalPkgs = pkgs.cfg
+

=== added file 'AutoUpgradeTester/profile/euca-cloud/pkgs.cfg'
--- AutoUpgradeTester/profile/euca-cloud/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/euca-cloud/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,5 @@
+python-apt
+eucalyptus-cc
+eucalyptus-cloud
+eucalyptus-walrus
+eucalyptus-sc

=== added directory 'AutoUpgradeTester/profile/euca-nc'
=== added file 'AutoUpgradeTester/profile/euca-nc/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/euca-nc/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/euca-nc/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+[NonInteractive]
+ProfileName=eua-nc
+AdditionalPkgs = pkgs.cfg

=== added file 'AutoUpgradeTester/profile/euca-nc/pkgs.cfg'
--- AutoUpgradeTester/profile/euca-nc/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/euca-nc/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,2 @@
+python-apt
+eucalyptus-nc

=== added directory 'AutoUpgradeTester/profile/kubuntu'
=== added file 'AutoUpgradeTester/profile/kubuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/kubuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/kubuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+[NonInteractive]
+ProfileName=kubuntu
+BasePkg = kubuntu-desktop

=== added symlink 'AutoUpgradeTester/profile/kubuntu/demoted.cfg'
=== target is u'../../demoted.cfg'
=== added directory 'AutoUpgradeTester/profile/kubuntu/result'
=== added symlink 'AutoUpgradeTester/profile/kubuntu/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-kubuntu'
=== added file 'AutoUpgradeTester/profile/lts-kubuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-kubuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-kubuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,6 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-kubuntu
+BasePkg = kubuntu-desktop

=== added symlink 'AutoUpgradeTester/profile/lts-kubuntu/demoted.cfg'
=== target is u'../../demoted.cfg'
=== added directory 'AutoUpgradeTester/profile/lts-kubuntu/result'
=== added symlink 'AutoUpgradeTester/profile/lts-kubuntu/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-main-all'
=== added directory 'AutoUpgradeTester/profile/lts-main-all-amd64'
=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,12 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName = lts-main-all-amd64
+AdditionalPkgs = pkgs.cfg
+PostBootstrapScript=/usr/share/pyshared/AutoUpgradeTester/install_all.py
+;PostBootstrapScript=/home/upgrade-tester/update-manager/AutoUpgradeTester/install_all.py
+
+[KVM]
+Arch=amd64
+

=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg.dapper'
--- AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg.dapper	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/DistUpgrade.cfg.dapper	2012-05-22 15:21:19 +0000
@@ -0,0 +1,65 @@
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+# Distro contains global information about the upgrade
+[Distro]
+# the meta-pkgs we support
+MetaPkgs=ubuntu-desktop, kubuntu-desktop, edubuntu-desktop, xubuntu-desktop
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+PostUpgradePurge=xorg-common, libgl1-mesa
+Demotions=demoted.cfg
+RemoveEssentialOk=sysvinit
+RemovalBlacklistFile=removal_blacklist.cfg
+
+# information about the individual meta-pkgs
+[ubuntu-desktop]
+KeyDependencies=gdm, gnome-panel, ubuntu-artwork
+# those pkgs will be marked remove right after the distUpgrade in the cache
+PostUpgradeRemove=xchat, xscreensaver
+
+[kubuntu-desktop]
+KeyDependencies=kdm, kicker, kubuntu-artwork-usplash
+# those packages are marked as obsolete right after the upgrade
+ForcedObsoletes=ivman
+
+[edubuntu-desktop]
+KeyDependencies=edubuntu-artwork, tuxpaint
+
+[xubuntu-desktop]
+KeyDependencies=xubuntu-artwork-usplash, xubuntu-default-settings, xfce4
+
+
+[Files]
+BackupExt=distUpgrade
+
+[Sources]
+From=dapper
+To=hardy
+ValidOrigin=Ubuntu
+ValidMirrors = mirrors.cfg
+
+[Network]
+MaxRetries=3
+
+[PreRequists]
+Packages=release-upgrader-apt,release-upgrader-dpkg
+SourcesList=prerequists-sources.list
+
+[NonInteractive]
+ProfileName = main-all
+BasePkg = ubuntu-standard
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+Proxy=http://192.168.1.1:3128/
+ForceOverwrite=yes
+CacheTarball=yes
+PostBootstrapScript=install_all.py
+Components=main,restricted
+Pockets=security,updates
+BaseImage=jeos/dapper-i386.qcow2
+CacheBaseImage=yes
+SwapImage=jeos/swap.qcow2
+UpgradeFromDistOnBootstrap=true
+SSHKey=ssh-key
+ReadReboot=yes
\ No newline at end of file

=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/demoted.cfg'
=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/install_blacklist.cfg'
--- AutoUpgradeTester/profile/lts-main-all-amd64/install_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/install_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,46 @@
+# jaunty: endless loop with DEBIAN_FRONTEND=noninteractive
+moodle
+# has a funny "can not be upgraded automatically" policy
+# see debian #368226
+quagga
+# not installable on a regular machine (preinst error)
+ltsp-client
+# gwenview-i18n has some file conflicts
+gwenview-i18n
+# ipppd needs MAKEDEV
+ipppd
+# cmake has incorrect emacs dependencies
+cmake
+# cluster manager hangs on shutdown
+cman
+
+# Conflicts/uninstallable packages in Oneiric
+libgladeui-doc
+mythes-it
+amavisd-new
+grub-legacy-ec2
+
+# LP:#901638
+tdsodbc
+
+# Only useful on livecd
+casper
+ubiquity
+
+# No need for so many kernels
+linux-image-.*
+
+# Failed to install
+bacula-director-mysql
+dovecot-common
+rabbitmq-server
+
+# cloud/ec2 no fun
+cloud-init
+ec2-init
+linux-image-ec2
+linux-image-2.6.31-302-ec2
+
+# not installable on a regular machine
+ltsp-client
+ltsp-client-core

=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-main-all-amd64/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+python-apt
+python-gnupginterface
+grub-pc

=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/prerequists-sources.list'
--- AutoUpgradeTester/profile/lts-main-all-amd64/prerequists-sources.list	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/prerequists-sources.list	2012-05-22 15:21:19 +0000
@@ -0,0 +1,5 @@
+# sources.list fragment for pre-requists (one with countrymirror, one fallback)
+deb http://archive.ubuntu.com/ubuntu dapper-backports main/debian-installer
+#deb http://archive.ubuntu.com/ubuntu feisty-backports main/debian-installer
+# below is just for testing
+#deb http://archive.dogfood.launchpad.net/ubuntu feisty-backports main/debian-installer

=== added file 'AutoUpgradeTester/profile/lts-main-all-amd64/removal_blacklist.cfg'
--- AutoUpgradeTester/profile/lts-main-all-amd64/removal_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all-amd64/removal_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,11 @@
+# blacklist of packages that should never be removed
+ubuntu-standard
+ubuntu-minimal
+ubuntu-desktop
+kubuntu-desktop
+edubuntu-desktop
+gobuntu-desktop
+# never remove nvidia-glx and friends
+^nvidia-glx$
+^nvidia-glx-new$
+^nvidia-glx-legacy$

=== added file 'AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,8 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName = lts-main-all
+AdditionalPkgs = pkgs.cfg
+PostBootstrapScript=/usr/share/pyshared/AutoUpgradeTester/install_all.py
+;PostBootstrapScript=/home/upgrade-tester/update-manager/AutoUpgradeTester/install_all.py

=== added file 'AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg.dapper'
--- AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg.dapper	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/DistUpgrade.cfg.dapper	2012-05-22 15:21:19 +0000
@@ -0,0 +1,65 @@
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+# Distro contains global information about the upgrade
+[Distro]
+# the meta-pkgs we support
+MetaPkgs=ubuntu-desktop, kubuntu-desktop, edubuntu-desktop, xubuntu-desktop
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+PostUpgradePurge=xorg-common, libgl1-mesa
+Demotions=demoted.cfg
+RemoveEssentialOk=sysvinit
+RemovalBlacklistFile=removal_blacklist.cfg
+
+# information about the individual meta-pkgs
+[ubuntu-desktop]
+KeyDependencies=gdm, gnome-panel, ubuntu-artwork
+# those pkgs will be marked remove right after the distUpgrade in the cache
+PostUpgradeRemove=xchat, xscreensaver
+
+[kubuntu-desktop]
+KeyDependencies=kdm, kicker, kubuntu-artwork-usplash
+# those packages are marked as obsolete right after the upgrade
+ForcedObsoletes=ivman
+
+[edubuntu-desktop]
+KeyDependencies=edubuntu-artwork, tuxpaint
+
+[xubuntu-desktop]
+KeyDependencies=xubuntu-artwork-usplash, xubuntu-default-settings, xfce4
+
+
+[Files]
+BackupExt=distUpgrade
+
+[Sources]
+From=dapper
+To=hardy
+ValidOrigin=Ubuntu
+ValidMirrors = mirrors.cfg
+
+[Network]
+MaxRetries=3
+
+[PreRequists]
+Packages=release-upgrader-apt,release-upgrader-dpkg
+SourcesList=prerequists-sources.list
+
+[NonInteractive]
+ProfileName = main-all
+BasePkg = ubuntu-standard
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+Proxy=http://192.168.1.1:3128/
+ForceOverwrite=yes
+CacheTarball=yes
+PostBootstrapScript=install_all.py
+Components=main,restricted
+Pockets=security,updates
+BaseImage=jeos/dapper-i386.qcow2
+CacheBaseImage=yes
+SwapImage=jeos/swap.qcow2
+UpgradeFromDistOnBootstrap=true
+SSHKey=ssh-key
+ReadReboot=yes
\ No newline at end of file

=== added symlink 'AutoUpgradeTester/profile/lts-main-all/demoted.cfg'
=== target is u'../../DistUpgrade/demoted.cfg'
=== added file 'AutoUpgradeTester/profile/lts-main-all/install_blacklist.cfg'
--- AutoUpgradeTester/profile/lts-main-all/install_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/install_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,46 @@
+# jaunty: endless loop with DEBIAN_FRONTEND=noninteractive
+moodle
+# has a funny "can not be upgraded automatically" policy
+# see debian #368226
+quagga
+# not installable on a regular machine (preinst error)
+ltsp-client
+# gwenview-i18n has some file conflicts
+gwenview-i18n
+# ipppd needs MAKEDEV
+ipppd
+# cmake has incorrect emacs dependencies
+cmake
+# cluster manager hangs on shutdown
+cman
+
+# Conflicts/uninstallable packages in Oneiric
+libgladeui-doc
+mythes-it
+amavisd-new
+grub-legacy-ec2
+
+# LP:#901638
+tdsodbc
+
+# Only useful on livecd
+casper
+ubiquity
+
+# No need for so many kernels
+linux-image-.*
+
+# Failed to install
+bacula-director-mysql
+dovecot-common
+rabbitmq-server
+
+# cloud/ec2 no fun
+cloud-init
+ec2-init
+linux-image-ec2
+linux-image-2.6.31-302-ec2
+
+# not installable on a regular machine
+ltsp-client
+ltsp-client-core

=== added file 'AutoUpgradeTester/profile/lts-main-all/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-main-all/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+python-apt
+python-gnupginterface
+grub-pc

=== added file 'AutoUpgradeTester/profile/lts-main-all/prerequists-sources.list'
--- AutoUpgradeTester/profile/lts-main-all/prerequists-sources.list	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/prerequists-sources.list	2012-05-22 15:21:19 +0000
@@ -0,0 +1,5 @@
+# sources.list fragment for pre-requists (one with countrymirror, one fallback)
+deb http://archive.ubuntu.com/ubuntu dapper-backports main/debian-installer
+#deb http://archive.ubuntu.com/ubuntu feisty-backports main/debian-installer
+# below is just for testing
+#deb http://archive.dogfood.launchpad.net/ubuntu feisty-backports main/debian-installer

=== added file 'AutoUpgradeTester/profile/lts-main-all/removal_blacklist.cfg'
--- AutoUpgradeTester/profile/lts-main-all/removal_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-main-all/removal_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,11 @@
+# blacklist of packages that should never be removed
+ubuntu-standard
+ubuntu-minimal
+ubuntu-desktop
+kubuntu-desktop
+edubuntu-desktop
+gobuntu-desktop
+# never remove nvidia-glx and friends
+^nvidia-glx$
+^nvidia-glx-new$
+^nvidia-glx-legacy$

=== added symlink 'AutoUpgradeTester/profile/lts-main-all/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-mythbuntu'
=== added file 'AutoUpgradeTester/profile/lts-mythbuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-mythbuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-mythbuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,8 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-mythbuntu
+BasePkg = mythbuntu-desktop
+Components=main,restricted,universe,multiverse
+Pockets=security,updates

=== added directory 'AutoUpgradeTester/profile/lts-server'
=== added directory 'AutoUpgradeTester/profile/lts-server-amd64'
=== added file 'AutoUpgradeTester/profile/lts-server-amd64/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-server-amd64/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server-amd64/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,9 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-server-amd64
+AdditionalPkgs = pkgs.cfg
+
+[KVM]
+Arch=amd64

=== added file 'AutoUpgradeTester/profile/lts-server-amd64/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-server-amd64/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server-amd64/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+grub-pc
+python-apt
+python-gnupginterface

=== added symlink 'AutoUpgradeTester/profile/lts-server-amd64/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-server-tasks'
=== added file 'AutoUpgradeTester/profile/lts-server-tasks/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-server-tasks/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server-tasks/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,6 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName = lts-server-tasks
+AdditionalPkgs = pkgs.cfg

=== added file 'AutoUpgradeTester/profile/lts-server-tasks/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-server-tasks/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server-tasks/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,10 @@
+grub-pc
+python-apt
+python-gnupginterface
+dns-server^
+lamp-server^
+mail-server^
+openssh-server^
+postgresql-server^
+print-server^
+samba-server^

=== added file 'AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,7 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-server
+AdditionalPkgs = pkgs.cfg
+;UseUpgraderFromBzr=true
\ No newline at end of file

=== added file 'AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg.dapper'
--- AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg.dapper	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server/DistUpgrade.cfg.dapper	2012-05-22 15:21:19 +0000
@@ -0,0 +1,53 @@
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+Depends=python-gnupginterface
+
+# Distro contains global information about the upgrade
+[Distro]
+# the meta-pkgs we support
+MetaPkgs=ubuntu-standard
+BaseMetaPkgs=ubuntu-minimal
+Demotions=demotions.cfg
+RemoveEssentialOk=sysvinit
+AllowUnauthenticated=yes
+
+[Files]
+BackupExt=distUpgrade
+
+[ubuntu-standard]
+KeyDependencies=w3m, wget
+
+[Sources]
+From=dapper
+To=hardy
+ValidOrigin=Ubuntu
+ValidMirrors = mirrors.cfg
+
+[Network]
+MaxRetries=3
+
+[PreRequists]
+Packages=release-upgrader-apt,release-upgrader-dpkg
+SourcesList=prerequists-sources.dapper.list
+SourcesList-ia64=prerequists-sources.dapper-ports.list
+SourcesList-hppa=prerequists-sources.dapper-ports.list
+
+[NonInteractive]
+ProfileName=server
+BasePkg = ubuntu-standard
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+Proxy=http://192.168.1.1:3128/
+ForceOverwrite=no
+SSHKey=ssh-key
+BaseImage=jeos/dapper-i386.qcow2
+SwapImage=jeos/swap.qcow2
+Components=main,restricted
+Pockets=security,updates
+UpgradeFromDistOnBoostrap=true
+CacheBaseImage=yes
+RealReboot=yes
+; WARNING: if AddRepo is used, remember to set Distro/AllowUnauthenticted too
+;AddRepo=local_testing.list
+;PreRequistsFiles=backports/release-upgrader-apt_0.7.9ubuntu1_i386.udeb, backports/release-upgrader-dpkg_1.14.5ubuntu11.6_i386.udeb

=== added file 'AutoUpgradeTester/profile/lts-server/local_testing.list'
--- AutoUpgradeTester/profile/lts-server/local_testing.list	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server/local_testing.list	2012-05-22 15:21:19 +0000
@@ -0,0 +1,1 @@
+deb http://ppa.launchpad.net/mvo/apt-lucid-chris/ubuntu lucid main 

=== added file 'AutoUpgradeTester/profile/lts-server/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-server/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-server/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+grub-pc
+python-apt
+python-gnupginterface

=== added symlink 'AutoUpgradeTester/profile/lts-server/prerequists-sources.dapper.list'
=== target is u'../../DistUpgrade/prerequists-sources.dapper.list'
=== added symlink 'AutoUpgradeTester/profile/lts-server/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-ubuntu'
=== added directory 'AutoUpgradeTester/profile/lts-ubuntu-amd64'
=== added file 'AutoUpgradeTester/profile/lts-ubuntu-amd64/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-ubuntu-amd64/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-ubuntu-amd64/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,13 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-ubuntu-amd64
+BasePkg = ubuntu-desktop
+AdditionalPkgs = pkgs.cfg
+PostBootstrapData = /usr/share/pyshared/AutoUpgradeTester/prepare_lts_user
+PostBootstrapScript = /usr/share/pyshared/AutoUpgradeTester/prepare_lts_desktop
+
+[KVM]
+Arch=amd64
+

=== added file 'AutoUpgradeTester/profile/lts-ubuntu-amd64/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-ubuntu-amd64/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-ubuntu-amd64/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+ubuntu-minimal
+ubuntu-standard
+grub-pc

=== added symlink 'AutoUpgradeTester/profile/lts-ubuntu-amd64/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added file 'AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,10 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName=lts-ubuntu
+BasePkg = ubuntu-desktop
+AdditionalPkgs = pkgs.cfg
+PostBootstrapData = /usr/share/pyshared/AutoUpgradeTester/prepare_lts_user
+PostBootstrapScript = /usr/share/pyshared/AutoUpgradeTester/prepare_lts_desktop
+;UseUpgraderFromBzr=true

=== added file 'AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg.dapper'
--- AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg.dapper	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-ubuntu/DistUpgrade.cfg.dapper	2012-05-22 15:21:19 +0000
@@ -0,0 +1,67 @@
+[View]
+#View=DistUpgradeViewGtk
+View=DistUpgradeViewNonInteractive
+
+# Distro contains global information about the upgrade
+[Distro]
+# the meta-pkgs we support
+MetaPkgs=ubuntu-desktop, kubuntu-desktop, edubuntu-desktop, xubuntu-desktop
+BaseMetaPkgs=ubuntu-minimal, ubuntu-standard
+PostUpgradePurge=xorg-common, libgl1-mesa
+Demotions=demoted.cfg
+RemoveEssentialOk=sysvinit
+RemovalBlacklistFile=removal_blacklist.cfg
+AllowUnauthenticated=yes
+PostInstallScripts=/usr/lib/udev/migrate-fstab-to-uuid.sh
+
+# information about the individual meta-pkgs
+[ubuntu-desktop]
+KeyDependencies=gdm, gnome-panel, ubuntu-artwork
+# those pkgs will be marked remove right after the distUpgrade in the cache
+PostUpgradeRemove=xchat, xscreensaver
+
+[kubuntu-desktop]
+KeyDependencies=kdm, kicker, kubuntu-artwork-usplash
+# those packages are marked as obsolete right after the upgrade
+ForcedObsoletes=ivman
+
+[edubuntu-desktop]
+KeyDependencies=edubuntu-artwork, tuxpaint
+
+[xubuntu-desktop]
+KeyDependencies=xubuntu-artwork-usplash, xubuntu-default-settings, xfce4
+
+
+[Files]
+BackupExt=distUpgrade
+
+[PreRequists]
+Packages=release-upgrader-apt,release-upgrader-dpkg
+SourcesList=prerequists-sources.dapper.list
+
+[Sources]
+From=dapper
+To=hardy
+ValidOrigin=Ubuntu
+ValidMirrors = mirrors.cfg
+
+[Network]
+MaxRetries=3
+
+[NonInteractive]
+ProfileName = ubuntu
+BasePkg = ubuntu-desktop
+AdditionalPkgs = pkgs.cfg
+Mirror = http://archive.ubuntu.com/ubuntu
+Proxy=http://192.168.1.1:3128/
+ForceOverwrite=yes
+Components=main,restricted
+Pockets=security,updates
+SSHKey=ssh-key
+BaseImage=jeos/dapper-i386.qcow2
+CacheBaseImage=yes
+SwapImage=jeos/swap.qcow2
+UpgradeFromDistOnBootstrap=true
+WorkaroundNetworkManager=true
+; WARNING: if AddRepo is used, remember to set Distro/AllowUnauthenticted too
+AddRepo=local_testing.list

=== added file 'AutoUpgradeTester/profile/lts-ubuntu/pkgs.cfg'
--- AutoUpgradeTester/profile/lts-ubuntu/pkgs.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-ubuntu/pkgs.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,3 @@
+ubuntu-minimal
+ubuntu-standard
+grub-pc

=== added symlink 'AutoUpgradeTester/profile/lts-ubuntu/prerequists-sources.dapper.list'
=== target is u'../../DistUpgrade/prerequists-sources.dapper.list'
=== added symlink 'AutoUpgradeTester/profile/lts-ubuntu/ssh-key'
=== target is u'../../jeos/ssh-key'
=== added directory 'AutoUpgradeTester/profile/lts-universe-amd64'
=== added file 'AutoUpgradeTester/profile/lts-universe-amd64/DistUpgrade.cfg'
--- AutoUpgradeTester/profile/lts-universe-amd64/DistUpgrade.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-universe-amd64/DistUpgrade.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,12 @@
+[DEFAULT]
+SourceRelease=lucid
+
+[NonInteractive]
+ProfileName = lts-universe-amd64
+AdditionalPkgs = pkgs.cfg
+Components=main,restricted,universe
+PostBootstrapScript=/home/upgrade-tester/update-manager/AutoUpgradeTester/install_universe
+
+[KVM]
+Arch = amd64
+VirtualRam = 3072

=== added symlink 'AutoUpgradeTester/profile/lts-universe-amd64/demoted.cfg'
=== target is u'../../DistUpgrade/demoted.cfg'
=== added file 'AutoUpgradeTester/profile/lts-universe-amd64/install_blacklist.cfg'
--- AutoUpgradeTester/profile/lts-universe-amd64/install_blacklist.cfg	1970-01-01 00:00:00 +0000
+++ AutoUpgradeTester/profile/lts-universe-amd64/install_blacklist.cfg	2012-05-22 15:21:19 +0000
@@ -0,0 +1,40 @@
+# jaunty: endless loop with DEBIAN_FRONTEND=noninteractive
+moodle
+# has a funny "can not be upgraded automatically" policy
+# see debian #368226
+quagga
+# not installable on a regular machine (preinst error)
+ltsp-client
+# gwenview-i18n has some file conflicts
+gwenview-i18n
+# ipppd needs MAKEDEV
+ipppd
+# cmake has incorrect emacs dependencies
+cmake
+# cluster manager hangs on shutdown
+cman
+
+# Conflicts/uninstallable packages in Oneiric
+libgladeui-doc
+mythes-it
+amavisd-new
+grub-legacy-ec2
+
+# LP:#901638
+tdsodbc
+
+# Only useful on livecd
+casper
+ubiquity
+
+# Breaks apache
+lwat
+
+# Broken on collectd
+kcollectd