X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=katie;h=19e8a7f7c246173a327767e768b304e09aca0823;hb=791e932971b92146d3621efdd29facc02b109774;hp=31553ec5e781e5ae453e341337326dad55f47b1d;hpb=efed042a00ba9dd5ff54fcf59773dffe0959df1b;p=dak.git

diff --git a/katie b/katie
index 31553ec5..19e8a7f7 100755
--- a/katie
+++ b/katie
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
-# Installs Debian packaes
+# Installs Debian packages
 # Copyright (C) 2000, 2001  James Troup <james@nocrew.org>
-# $Id: katie,v 1.36 2001-04-03 10:01:08 troup Exp $
+# $Id: katie,v 1.67 2001-11-25 01:21:34 troup Exp $
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@
 
 # Originally based almost entirely on dinstall by Guy Maor <maor@debian.org>
 
-#########################################################################################
+###############################################################################
 
 #    Cartman: "I'm trying to make the best of a bad situation, I don't
 #              need to hear crap from a bunch of hippy freaks living in
@@ -30,24 +30,30 @@
 #
 #    Cartman: "uhh.. screw you guys... home."
 
-#########################################################################################
+###############################################################################
 
-import FCNTL, commands, fcntl, getopt, gzip, os, pg, pwd, re, shutil, stat, string, sys, tempfile, time
+import FCNTL, commands, fcntl, getopt, gzip, os, pg, pwd, re, shutil, stat, string, sys, tempfile, time, traceback
 import apt_inst, apt_pkg
-import utils, db_access
+import utils, db_access, logging
+
+from types import *;
 
 ###############################################################################
 
-re_isanum = re.compile (r'^\d+$');
-re_changes = re.compile (r'changes$');
+re_isanum = re.compile (r"^\d+$");
+re_changes = re.compile (r"changes$");
 re_default_answer = re.compile(r"\[(.*)\]");
 re_fdnic = re.compile("\n\n");
 re_bad_diff = re.compile("^[\-\+][\-\+][\-\+] /dev/null");
+re_bin_only_nmu_of_mu = re.compile("\.\d+\.\d+$");
+re_bin_only_nmu_of_nmu = re.compile("\.\d+$");
 
 #########################################################################################
 
 # Globals
 Cnf = None;
+Options = None;
+Logger = None;
 reject_message = "";
 changes = {};
 dsc = {};
@@ -63,20 +69,49 @@ orig_tar_id = None;
 orig_tar_location = "";
 legacy_source_untouchable = {};
 Subst = {};
+nmu = None;
+katie_version = "$Revision: 1.67 $";
 
-#########################################################################################
+###############################################################################
+
+def init():
+    global Cnf, Options;
+
+    Cnf = utils.get_conf()
+
+    Arguments = [('a',"automatic","Dinstall::Options::Automatic"),
+                 ('h',"help","Dinstall::Options::Help"),
+                 ('k',"ack-new","Dinstall::Options::Ack-New"),
+                 ('m',"manual-reject","Dinstall::Options::Manual-Reject", "HasArg"),
+                 ('n',"no-action","Dinstall::Options::No-Action"),
+                 ('p',"no-lock", "Dinstall::Options::No-Lock"),
+                 ('s',"no-mail", "Dinstall::Options::No-Mail"),
+                 ('u',"override-distribution", "Dinstall::Options::Override-Distribution", "HasArg"),
+                 ('V',"version","Dinstall::Options::Version")];
 
-def usage (exit_code):
+    for i in ["automatic", "help", "ack-new", "manual-reject", "no-action",
+              "no-lock", "no-mail", "override-distribution", "version"]:
+	if not Cnf.has_key("Dinstall::Options::%s" % (i)):
+	    Cnf["Dinstall::Options::%s" % (i)] = "";
+
+    changes_files = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv);
+    Options = Cnf.SubTree("Dinstall::Options")
+
+    return changes_files;
+
+###############################################################################
+
+def usage (exit_code=0):
     print """Usage: dinstall [OPTION]... [CHANGES]...
   -a, --automatic           automatic run
-  -D, --debug=VALUE         turn on debugging
   -h, --help                show this help and exit.
   -k, --ack-new             acknowledge new packages !! for cron.daily only !!
   -m, --manual-reject=MSG   manual reject with `msg'
   -n, --no-action           don't do anything
   -p, --no-lock             don't check lockfile !! for cron.daily only !!
+  -s, --no-mail             don't send any mail
   -u, --distribution=DIST   override distribution to `dist'
-  -v, --version             display the version number and exit"""
+  -V, --version             display the version number and exit"""
     sys.exit(exit_code)
 
 #########################################################################################
@@ -86,17 +121,85 @@ def check_signature (filename):
 
     (result, output) = commands.getstatusoutput("gpg --emulate-md-encode-bug --batch --no-options --no-default-keyring --always-trust --keyring=%s --keyring=%s < %s >/dev/null" % (Cnf["Dinstall::PGPKeyring"], Cnf["Dinstall::GPGKeyring"], filename))
     if (result != 0):
-        reject_message = "Rejected: GPG signature check failed on `%s'.\n%s\n" % (os.path.basename(filename), output)
+        reject_message = reject_message + "Rejected: GPG signature check failed on `%s'.\n%s\n" % (os.path.basename(filename), output)
         return 0
     return 1
 
-#####################################################################################################################
+######################################################################################################
+
+class nmu_p:
+    # Read in the group maintainer override file
+    def __init__ (self):
+        self.group_maint = {};
+        if Cnf.get("Dinstall::GroupOverrideFilename"):
+            filename = Cnf["Dir::OverrideDir"] + Cnf["Dinstall::GroupOverrideFilename"];
+            file = utils.open_file(filename);
+            for line in file.readlines():
+                line = string.strip(utils.re_comments.sub('', line));
+                if line != "":
+                    self.group_maint[line] = 1;
+            file.close();
+
+    def is_an_nmu (self, changes, dsc):
+        (dsc_rfc822, dsc_name, dsc_email) = utils.fix_maintainer (dsc.get("maintainer",Cnf["Dinstall::MyEmailAddress"]));
+        # changes["changedbyname"] == dsc_name is probably never true, but better safe than sorry
+        if dsc_name == changes["maintainername"] and (changes["changedby822"] == "" or changes["changedbyname"] == dsc_name):
+            return 0;
+
+        if dsc.has_key("uploaders"):
+            uploaders = string.split(dsc["uploaders"], ",");
+            uploadernames = {};
+            for i in uploaders:
+                (rfc822, name, email) = utils.fix_maintainer (string.strip(i));
+                uploadernames[name] = "";
+            if uploadernames.has_key(changes["changedbyname"]):
+                return 0;
+
+        # Some group maintained packages (e.g. Debian QA) are never NMU's
+        if self.group_maint.has_key(changes["maintaineremail"]):
+            return 0;
+
+        return 1;
+
+######################################################################################################
+
+# Ensure that source exists somewhere in the archive for the binary
+# upload being processed.
+#
+# (1) exact match                      => 1.0-3
+# (2) Bin-only NMU of an MU            => 1.0-3.0.1
+# (3) Bin-only NMU of a sourceful-NMU  => 1.0-3.1.1
+
+def source_exists (package, source_version):
+    q = projectB.query("SELECT s.version FROM source s WHERE s.source = '%s'" % (package));
+
+    # Reduce the query results to a list of version numbers
+    ql = map(lambda x: x[0], q.getresult());
+
+    # Try (1)
+    if ql.count(source_version):
+        return 1;
+
+    # Try (2)
+    orig_source_version = re_bin_only_nmu_of_mu.sub('', source_version);
+    if ql.count(orig_source_version):
+        return 1;
+
+    # Try (3)
+    orig_source_version = re_bin_only_nmu_of_nmu.sub('', source_version);
+    if ql.count(orig_source_version):
+        return 1;
+
+    # No source found...
+    return 0;
+
+######################################################################################################
 
 # See if a given package is in the override table
 
 def in_override_p (package, component, suite, binary_type, file):
     global files;
-    
+
     if binary_type == "": # must be source
         type = "dsc";
     else:
@@ -131,7 +234,7 @@ def in_override_p (package, component, suite, binary_type, file):
     if result != []:
         files[file]["override section"] = result[0][0];
         files[file]["override priority"] = result[0][1];
-        
+
     return result;
 
 #####################################################################################################################
@@ -140,34 +243,39 @@ def check_changes(filename):
     global reject_message, changes, files
 
     # Default in case we bail out
-    changes["maintainer822"] = Cnf["Dinstall::MyEmailAddress"]; 
+    changes["maintainer822"] = Cnf["Dinstall::MyEmailAddress"];
+    changes["changedby822"] = Cnf["Dinstall::MyEmailAddress"];
+    changes["architecture"] = {};
 
     # Parse the .changes field into a dictionary
     try:
         changes = utils.parse_changes(filename, 0)
     except utils.cant_open_exc:
-        reject_message = "Rejected: can't read changes file '%s'.\n" % (filename)
+        reject_message = reject_message + "Rejected: can't read changes file '%s'.\n" % (filename)
         return 0;
     except utils.changes_parse_error_exc, line:
-        reject_message = "Rejected: error parsing changes file '%s', can't grok: %s.\n" % (filename, line)
+        reject_message = reject_message + "Rejected: error parsing changes file '%s', can't grok: %s.\n" % (filename, line)
         return 0;
 
     # Parse the Files field from the .changes into another dictionary
     try:
         files = utils.build_file_list(changes, "");
     except utils.changes_parse_error_exc, line:
-        reject_message = "Rejected: error parsing changes file '%s', can't grok: %s.\n" % (filename, line);
+        reject_message = reject_message + "Rejected: error parsing changes file '%s', can't grok: %s.\n" % (filename, line);
+    except utils.nk_format_exc, format:
+        reject_message = reject_message + "Rejected: unknown format '%s' of changes file '%s'.\n" % (format, filename);
+        return 0;
 
     # Check for mandatory fields
-    for i in ("source", "binary", "architecture", "version", "distribution","maintainer", "files"):
+    for i in ("source", "binary", "architecture", "version", "distribution", "maintainer", "files"):
         if not changes.has_key(i):
-            reject_message = "Rejected: Missing field `%s' in changes file.\n" % (i)
+            reject_message = reject_message + "Rejected: Missing field `%s' in changes file.\n" % (i)
             return 0    # Avoid <undef> errors during later tests
 
     # Override the Distribution: field if appropriate
-    if Cnf["Dinstall::Options::Override-Distribution"] != "":
-        reject_message = reject_message + "Warning: Distribution was overriden from %s to %s.\n" % (changes["distribution"], Cnf["Dinstall::Options::Override-Distribution"])
-        changes["distribution"] = Cnf["Dinstall::Options::Override-Distribution"]
+    if Options["Override-Distribution"] != "":
+        reject_message = reject_message + "Warning: Distribution was overriden from %s to %s.\n" % (changes["distribution"], Options["Override-Distribution"])
+        changes["distribution"] = Options["Override-Distribution"]
 
     # Split multi-value fields into a lower-level dictionary
     for i in ("architecture", "distribution", "binary", "closes"):
@@ -184,17 +292,16 @@ def check_changes(filename):
     # Fix the Changed-By: field to be RFC822 compatible; if it exists.
     (changes["changedby822"], changes["changedbyname"], changes["changedbyemail"]) = utils.fix_maintainer(changes.get("changed-by",""));
 
-    # For source uploads the Changed-By field wins; otherwise Maintainer wins.
-    if changes["architecture"].has_key("source"):
-        changes["uploader822"] = "To: %s\nCc: %s" % (changes["changedby822"], changes["maintainer822"]);
-         #         changes["uploadername"], changes["uploaderemail"]) = (changes["changedby822"], changes["changedbyname"], changes["changedbyemail"]);
-        
     # Ensure all the values in Closes: are numbers
     if changes.has_key("closes"):
         for i in changes["closes"].keys():
             if re_isanum.match (i) == None:
                 reject_message = reject_message + "Rejected: `%s' from Closes field isn't a number.\n" % (i)
 
+    # Ensure there _is_ a target distribution
+    if not changes["distribution"].keys():
+        reject_message = reject_message + "Rejected: huh? Distribution field is empty in changes file.\n";
+
     # Map frozen to unstable if frozen doesn't exist
     if changes["distribution"].has_key("frozen") and not Cnf.has_key("Suite::Frozen"):
         del changes["distribution"]["frozen"]
@@ -203,19 +310,17 @@ def check_changes(filename):
 
     # Map testing to unstable
     if changes["distribution"].has_key("testing"):
-        del changes["distribution"]["testing"]
-        changes["distribution"]["unstable"] = 1;
-        reject_message = reject_message + "Mapping testing to unstable.\n"
+        if len(changes["distribution"].keys()) > 1:
+            del changes["distribution"]["testing"];
+            reject_message = reject_message + "Warning: Ignoring testing as a target suite.\n";
+        else:
+            reject_message = reject_message + "Rejected: invalid distribution 'testing'.\n";
 
     # Ensure target distributions exist
     for i in changes["distribution"].keys():
         if not Cnf.has_key("Suite::%s" % (i)):
             reject_message = reject_message + "Rejected: Unknown distribution `%s'.\n" % (i)
 
-    # Ensure there _is_ a target distribution
-    if changes["distribution"].keys() == []:
-        reject_message = reject_message + "Rejected: huh? Distribution field is empty in changes file.\n";
-            
     # Map unreleased arches from stable to unstable
     if changes["distribution"].has_key("stable"):
         for i in changes["architecture"].keys():
@@ -223,7 +328,7 @@ def check_changes(filename):
                 reject_message = reject_message + "Mapping stable to unstable for unreleased arch `%s'.\n" % (i)
                 del changes["distribution"]["stable"]
                 changes["distribution"]["unstable"] = 1;
-    
+
     # Map arches not being released from frozen to unstable
     if changes["distribution"].has_key("frozen"):
         for i in changes["architecture"].keys():
@@ -236,16 +341,17 @@ def check_changes(filename):
     if changes["distribution"].has_key("stable"):
         # If running from within proposed-updates; assume an install to stable
         if string.find(os.getcwd(), 'proposed-updates') != -1:
-            # FIXME: should probably remove anything that != stable
-            for i in ("frozen", "unstable"):
-                if changes["distribution"].has_key(i):
-                    reject_message = reject_message + "Removing %s from distribution list.\n"
-                    del changes["distribution"][i]
-            changes["stable upload"] = 1;
+            # Remove non-stable target distributions
+            for dist in changes["distribution"].keys():
+                if dist != "stable":
+                    reject_message = reject_message + "Removing %s from distribution list.\n" % (dist);
+                    del changes["distribution"][dist];
+            changes["stable install"] = 1;
             # If we can't find a file from the .changes; assume it's a package already in the pool and move into the pool
             file = files.keys()[0];
             if os.access(file, os.R_OK) == 0:
                 pool_dir = Cnf["Dir::PoolDir"] + '/' + utils.poolify(changes["source"], files[file]["component"]);
+                changes["installing from the pool"] = 1;
                 os.chdir(pool_dir);
         # Otherwise (normal case) map stable to updates
         else:
@@ -256,21 +362,25 @@ def check_changes(filename):
     # chopversion = no epoch; chopversion2 = no epoch and no revision (e.g. for .orig.tar.gz comparison)
     changes["chopversion"] = utils.re_no_epoch.sub('', changes["version"])
     changes["chopversion2"] = utils.re_no_revision.sub('', changes["chopversion"])
-    
+
     if string.find(reject_message, "Rejected:") != -1:
         return 0
-    else: 
+    else:
         return 1
 
 def check_files():
     global reject_message
-    
+
     archive = utils.where_am_i();
 
     for file in files.keys():
         # Check the file is readable
         if os.access(file,os.R_OK) == 0:
-            reject_message = reject_message + "Rejected: Can't read `%s'.\n" % (file)
+            if os.path.exists(file):
+                reject_message = reject_message + "Rejected: Can't read `%s'. [permission denied]\n" % (file)
+            else:
+                reject_message = reject_message + "Rejected: Can't read `%s'. [file not found]\n" % (file)
+
             files[file]["type"] = "unreadable";
             continue
         # If it's byhand skip remaining checks
@@ -283,7 +393,7 @@ def check_files():
 
             # Extract package information using dpkg-deb
             try:
-                control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(file,"r")))
+                control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(file)));
             except:
                 reject_message = reject_message + "Rejected: %s: debExtractControl() raised %s.\n" % (file, sys.exc_type);
                 # Can't continue, none of the checks on control would work.
@@ -296,7 +406,7 @@ def check_files():
                 reject_message = reject_message + "Rejected: %s: No architecture field in control.\n" % (file)
             if control.Find("Version") == None:
                 reject_message = reject_message + "Rejected: %s: No version field in control.\n" % (file)
-                
+
             # Ensure the package name matches the one give in the .changes
             if not changes["binary"].has_key(control.Find("Package", "")):
                 reject_message = reject_message + "Rejected: %s: control file lists name as `%s', which isn't in changes file.\n" % (file, control.Find("Package", ""))
@@ -330,6 +440,18 @@ def check_files():
             files[file]["source"] = control.Find("Source", "");
             if files[file]["source"] == "":
                 files[file]["source"] = files[file]["package"];
+            # Get the source version
+            source = files[file]["source"];
+            source_version = ""
+            if string.find(source, "(") != -1:
+                m = utils.re_extract_src_version.match(source)
+                source = m.group(1)
+                source_version = m.group(2)
+            if not source_version:
+                source_version = files[file]["version"];
+            files[file]["source package"] = source;
+            files[file]["source version"] = source_version;
+
         # Checks for a source package...
         else:
             m = utils.re_issource.match(file)
@@ -337,7 +459,7 @@ def check_files():
                 files[file]["package"] = m.group(1)
                 files[file]["version"] = m.group(2)
                 files[file]["type"] = m.group(3)
-                
+
                 # Ensure the source package name matches the Source filed in the .changes
                 if changes["source"] != files[file]["package"]:
                     reject_message = reject_message + "Rejected: %s: changes file doesn't say %s for Source\n" % (file, files[file]["package"])
@@ -359,6 +481,7 @@ def check_files():
                     check_signature(file)
 
                 files[file]["fullname"] = file
+                files[file]["architecture"] = "source";
 
             # Not a binary or source package?  Assume byhand...
             else:
@@ -378,10 +501,10 @@ def check_files():
             # See if the package is NEW
             if not in_override_p(files[file]["package"], files[file]["component"], suite, files[file].get("dbtype",""), file):
                 files[file]["new"] = 1
-                
-            # Find any old binary packages
+
             if files[file]["type"] == "deb":
-                q = projectB.query("SELECT b.id, b.version, f.filename, l.path, c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f WHERE b.package = '%s' AND s.suite_name = '%s' AND a.arch_string = '%s' AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id AND f.location = l.id AND l.component = c.id AND b.file = f.id"
+                # Find any old binary packages
+                q = projectB.query("SELECT b.id, b.version, f.filename, l.path, c.name FROM binaries b, bin_associations ba, suite s, location l, component c, architecture a, files f WHERE b.package = '%s' AND s.suite_name = '%s' AND (a.arch_string = '%s' OR a.arch_string = 'all') AND ba.bin = b.id AND ba.suite = s.id AND b.architecture = a.id AND f.location = l.id AND l.component = c.id AND b.file = f.id"
                                    % (files[file]["package"], suite, files[file]["architecture"]))
                 oldfiles = q.dictresult()
                 for oldfile in oldfiles:
@@ -390,11 +513,21 @@ def check_files():
                     if apt_pkg.VersionCompare(files[file]["version"], oldfile["version"]) != 1:
                         reject_message = reject_message + "Rejected: %s Old version `%s' >= new version `%s'.\n" % (file, oldfile["version"], files[file]["version"])
                 # Check for existing copies of the file
-                if not changes.has_key("stable upload"):
+                if not changes.has_key("stable install"):
                     q = projectB.query("SELECT b.id FROM binaries b, architecture a WHERE b.package = '%s' AND b.version = '%s' AND a.arch_string = '%s' AND a.id = b.architecture" % (files[file]["package"], files[file]["version"], files[file]["architecture"]))
                     if q.getresult() != []:
                         reject_message = reject_message + "Rejected: can not overwrite existing copy of '%s' already in the archive.\n" % (file)
 
+                # Check for existent source
+                # FIXME: this is no longer per suite
+                if changes["architecture"].has_key("source"):
+                    source_version = files[file]["source version"];
+                    if source_version != changes["version"]:
+                        reject_message = reject_message + "Rejected: source version (%s) for %s doesn't match changes version %s.\n" % (files[file]["source version"], file, changes["version"]);
+                else:
+                    if not source_exists (files[file]["source package"], source_version):
+                        reject_message = reject_message + "Rejected: no source found for %s %s (%s).\n" % (files[file]["source package"], source_version, file);
+
             # Find any old .dsc files
             elif files[file]["type"] == "dsc":
                 q = projectB.query("SELECT s.id, s.version, f.filename, l.path, c.name FROM source s, src_associations sa, suite su, location l, component c, files f WHERE s.source = '%s' AND su.suite_name = '%s' AND sa.source = s.id AND sa.suite = su.id AND f.location = l.id AND l.component = c.id AND f.id = s.file"
@@ -413,7 +546,7 @@ def check_files():
             # Validate the priority
             if string.find(files[file]["priority"],'/') != -1:
                 reject_message = reject_message + "Rejected: file '%s' has invalid priority '%s' [contains '/'].\n" % (file, files[file]["priority"]);
-            
+
             # Check the md5sum & size against existing files (if any)
             location = Cnf["Dir::PoolDir"];
             files[file]["location id"] = db_access.get_location_id (location, component, archive);
@@ -430,10 +563,10 @@ def check_files():
             if files[file]["oldfiles"].has_key(suite) and files[file]["oldfiles"][suite]["name"] != files[file]["component"]:
                 files[file]["othercomponents"] = files[file]["oldfiles"][suite]["name"];
 
-                
+
     if string.find(reject_message, "Rejected:") != -1:
         return 0
-    else: 
+    else:
         return 1
 
 ###############################################################################
@@ -460,9 +593,40 @@ def check_dsc ():
                 reject_message = reject_message + "Rejected: no Files: field in .dsc file.\n";
                 continue;
             except utils.changes_parse_error_exc, line:
-                reject_message = "Rejected: error parsing .dsc file '%s', can't grok: %s.\n" % (file, line);
+                reject_message = reject_message + "Rejected: error parsing .dsc file '%s', can't grok: %s.\n" % (file, line);
                 continue;
 
+            # Enforce mandatory fields
+            for i in ("format", "source", "version", "binary", "maintainer", "architecture", "files"):
+                if not dsc.has_key(i):
+                    reject_message = reject_message + "Rejected: Missing field `%s' in dsc file.\n" % (i)
+
+            # The dpkg maintainer from hell strikes again! Bumping the
+            # version number of the .dsc breaks extraction by stable's
+            # dpkg-source.
+            if dsc["format"] != "1.0":
+                reject_message = reject_message + """Rejected: [dpkg-sucks] source package was produced by a broken version
+          of dpkg-dev 1.9.1{3,4}; please rebuild with >= 1.9.15 version
+          installed.
+""";
+
+            # Ensure the version number in the .dsc matches the version number in the .changes
+            epochless_dsc_version = utils.re_no_epoch.sub('', dsc.get("version"));
+            changes_version = files[file]["version"];
+            if epochless_dsc_version != files[file]["version"]:
+                reject_message = reject_message + "Rejected: version ('%s') in .dsc does not match version ('%s') in .changes\n" % (epochless_dsc_version, changes_version);
+
+            # Ensure source is newer than existing source in target suites
+            package = dsc.get("source");
+            new_version = dsc.get("version");
+            for suite in changes["distribution"].keys():
+                q = projectB.query("SELECT s.version FROM source s, src_associations sa, suite su WHERE s.source = '%s' AND su.suite_name = '%s' AND sa.source = s.id AND sa.suite = su.id"
+                                   % (package, suite));
+                ql = map(lambda x: x[0], q.getresult());
+                for old_version in ql:
+                    if apt_pkg.VersionCompare(new_version, old_version) != 1:
+                        reject_message = reject_message + "Rejected: %s Old version `%s' >= new version `%s'.\n" % (file, old_version, new_version)
+
             # Try and find all files mentioned in the .dsc.  This has
             # to work harder to cope with the multiple possible
             # locations of an .orig.tar.gz.
@@ -472,7 +636,7 @@ def check_dsc ():
                     actual_size = int(files[dsc_file]["size"]);
                     found = "%s in incoming" % (dsc_file)
                     # Check the file does not already exist in the archive
-                    if not changes.has_key("stable upload"):
+                    if not changes.has_key("stable install"):
                         q = projectB.query("SELECT f.id FROM files f, location l WHERE (f.filename ~ '/%s$' OR f.filename = '%s') AND l.id = f.location" % (utils.regex_safe(dsc_file), dsc_file));
 
                         # "It has not broken them.  It has fixed a
@@ -504,7 +668,7 @@ def check_dsc ():
                         if len(ql) > 1:
                             for i in ql:
                                 old_file = i[0] + i[1];
-                                actual_md5 = apt_pkg.md5sum(utils.open_file(old_file,"r"));
+                                actual_md5 = apt_pkg.md5sum(utils.open_file(old_file));
                                 actual_size = os.stat(old_file)[stat.ST_SIZE];
                                 if actual_md5 == dsc_files[dsc_file]["md5sum"] and actual_size == int(dsc_files[dsc_file]["size"]):
                                     x = i;
@@ -512,7 +676,7 @@ def check_dsc ():
                                     legacy_source_untouchable[i[3]] = "";
 
                         old_file = x[0] + x[1];
-                        actual_md5 = apt_pkg.md5sum(utils.open_file(old_file,"r"));
+                        actual_md5 = apt_pkg.md5sum(utils.open_file(old_file));
                         actual_size = os.stat(old_file)[stat.ST_SIZE];
                         found = old_file;
                         suite_type = x[2];
@@ -527,7 +691,7 @@ def check_dsc ():
                         # Not there? Check in Incoming...
                         # [See comment above process_it() for explanation
                         #  of why this is necessary...]
-                        if os.access(dsc_file, os.R_OK) != 0:
+                        if os.path.exists(dsc_file):
                             files[dsc_file] = {};
                             files[dsc_file]["size"] = os.stat(dsc_file)[stat.ST_SIZE];
                             files[dsc_file]["md5sum"] = dsc_files[dsc_file]["md5sum"];
@@ -550,7 +714,7 @@ def check_dsc ():
 
     if string.find(reject_message, "Rejected:") != -1:
         return 0
-    else: 
+    else:
         return 1
 
 ###############################################################################
@@ -574,7 +738,7 @@ def check_diff ():
 
     if string.find(reject_message, "Rejected:") != -1:
         return 0
-    else: 
+    else:
         return 1
 
 ###############################################################################
@@ -584,7 +748,7 @@ def check_md5sums ():
 
     for file in files.keys():
         try:
-            file_handle = utils.open_file(file,"r");
+            file_handle = utils.open_file(file);
         except utils.cant_open_exc:
             pass;
         else:
@@ -593,9 +757,9 @@ def check_md5sums ():
 
 def check_override ():
     global Subst;
-    
-    # Only check section & priority on sourceful uploads
-    if not changes["architecture"].has_key("source"):
+
+    # Only check section & priority on sourceful non-stable installs
+    if not changes["architecture"].has_key("source") or changes.has_key("stable install"):
         return;
 
     summary = ""
@@ -627,14 +791,27 @@ def check_override ():
 def update_subst (changes_filename):
     global Subst;
 
-    if changes.has_key("architecture"):
-        Subst["__ARCHITECTURE__"] = string.join(changes["architecture"].keys(), ' ' );
-    else:
-        Subst["__ARCHITECTURE__"] = "Unknown";
+    # If katie crashed out in the right place, architecture may still be a string.
+    if not changes.has_key("architecture") or not isinstance(changes["architecture"], DictType):
+        changes["architecture"] = { "Unknown" : "" };
+    # and maintainer822 may not exist.
+    if not changes.has_key("maintainer822"):
+        changes["maintainer822"] = Cnf["Dinstall::MyEmailAddress"];
+
+    Subst["__ARCHITECTURE__"] = string.join(changes["architecture"].keys(), ' ' );
     Subst["__CHANGES_FILENAME__"] = os.path.basename(changes_filename);
     Subst["__FILE_CONTENTS__"] = changes.get("filecontents", "");
-    Subst["__MAINTAINER_ADDRESS__"] = changes["maintainer822"];
-    Subst["__MAINTAINER__"] = changes.get("maintainer", "Unknown");
+
+    # For source uploads the Changed-By field wins; otherwise Maintainer wins.
+    if changes["architecture"].has_key("source") and changes["changedby822"] != "" and (changes["changedby822"] != changes["maintainer822"]):
+        Subst["__MAINTAINER_FROM__"] = changes["changedby822"];
+        Subst["__MAINTAINER_TO__"] = changes["changedby822"] + ", " + changes["maintainer822"];
+        Subst["__MAINTAINER__"] = changes.get("changed-by", "Unknown");
+    else:
+        Subst["__MAINTAINER_FROM__"] = changes["maintainer822"];
+        Subst["__MAINTAINER_TO__"] = changes["maintainer822"];
+        Subst["__MAINTAINER__"] = changes.get("maintainer", "Unknown");
+
     Subst["__REJECT_MESSAGE__"] = reject_message;
     Subst["__SOURCE__"] = changes.get("source", "Unknown");
     Subst["__VERSION__"] = changes.get("version", "Unknown");
@@ -642,21 +819,23 @@ def update_subst (changes_filename):
 #####################################################################################################################
 
 def action (changes_filename):
-    byhand = confirm = suites = summary = new = "";
+    byhand = summary = new = "";
 
     # changes["distribution"] may not exist in corner cases
     # (e.g. unreadable changes files)
-    if not changes.has_key("distribution"):
+    if not changes.has_key("distribution") or not isinstance(changes["distribution"], DictType):
         changes["distribution"] = {};
-    
+
+    confirm = []
+    suites = []
     for suite in changes["distribution"].keys():
         if Cnf.has_key("Suite::%s::Confirm"):
-            confirm = confirm + suite + ", "
-        suites = suites + suite + ", "
-    confirm = confirm[:-2]
-    suites = suites[:-2]
+            confirm.append(suite)
+        suites.append(suite)
 
-    for file in files.keys():
+    file_keys = files.keys();
+    file_keys.sort();
+    for file in file_keys:
         if files[file].has_key("byhand"):
             byhand = 1
             summary = summary + file + " byhand\n"
@@ -666,7 +845,7 @@ def action (changes_filename):
             if files[file].has_key("othercomponents"):
                 summary = summary + "WARNING: Already present in %s distribution.\n" % (files[file]["othercomponents"])
             if files[file]["type"] == "deb":
-                summary = summary + apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(file,"r")))["Description"] + '\n';
+                summary = summary + apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(file)))["Description"] + '\n';
         else:
             files[file]["pool name"] = utils.poolify (changes["source"], files[file]["component"])
             destination = Cnf["Dir::PoolRoot"] + files[file]["pool name"] + file
@@ -681,35 +860,39 @@ def action (changes_filename):
         summary = summary + "Changes: " + f;
 
     summary = summary + announce (short_summary, 0)
-    
+
     (prompt, answer) = ("", "XXX")
-    if Cnf["Dinstall::Options::No-Action"] or Cnf["Dinstall::Options::Automatic"]:
+    if Options["No-Action"] or Options["Automatic"]:
         answer = 'S'
 
     if string.find(reject_message, "Rejected") != -1:
-        if time.time()-os.path.getmtime(changes_filename) < 86400:
+        try:
+            modified_time = time.time()-os.path.getmtime(changes_filename);
+        except: # i.e. ignore errors like 'file does not exist';
+            modified_time = 0;
+        if modified_time < 86400:
             print "SKIP (too new)\n" + reject_message,;
             prompt = "[S]kip, Manual reject, Quit ?";
         else:
             print "REJECT\n" + reject_message,;
             prompt = "[R]eject, Manual reject, Skip, Quit ?";
-            if Cnf["Dinstall::Options::Automatic"]:
+            if Options["Automatic"]:
                 answer = 'R';
     elif new:
-        print "NEW to %s\n%s%s" % (suites, reject_message, summary),;
+        print "NEW to %s\n%s%s" % (string.join(suites, ", "), reject_message, summary),;
         prompt = "[S]kip, New ack, Manual reject, Quit ?";
-        if Cnf["Dinstall::Options::Automatic"] and Cnf["Dinstall::Options::Ack-New"]:
+        if Options["Automatic"] and Options["Ack-New"]:
             answer = 'N';
     elif byhand:
         print "BYHAND\n" + reject_message + summary,;
         prompt = "[I]nstall, Manual reject, Skip, Quit ?";
     elif confirm:
-        print "CONFIRM to %s\n%s%s" % (confirm, reject_message, summary),
+        print "CONFIRM to %s\n%s%s" % (string.join(confirm, ", "), reject_message, summary),
         prompt = "[I]nstall, Manual reject, Skip, Quit ?";
     else:
         print "INSTALL\n" + reject_message + summary,;
         prompt = "[I]nstall, Manual reject, Skip, Quit ?";
-        if Cnf["Dinstall::Options::Automatic"]:
+        if Options["Automatic"]:
             answer = 'I';
 
     while string.find(prompt, answer) == -1:
@@ -731,18 +914,20 @@ def action (changes_filename):
     elif answer == 'Q':
         sys.exit(0)
 
-#####################################################################################################################
+###############################################################################
 
 def install (changes_filename, summary, short_summary):
     global install_count, install_bytes, Subst;
 
-    # Stable uploads are a special case
-    if changes.has_key("stable upload"):
+    # stable installs are a special case
+    if changes.has_key("stable install"):
         stable_install (changes_filename, summary, short_summary);
         return;
-    
+
     print "Installing."
 
+    Logger.log(["installing changes",changes_filename]);
+
     archive = utils.where_am_i();
 
     # Begin a transaction; if we bomb out anywhere between here and the COMMIT WORK below, the DB will not be changed.
@@ -762,7 +947,7 @@ def install (changes_filename, summary, short_summary):
                 files[file]["files id"] = db_access.set_files_id (filename, files[file]["size"], files[file]["md5sum"], dsc_location_id)
             projectB.query("INSERT INTO source (source, version, maintainer, file) VALUES ('%s', '%s', %d, %d)"
                            % (package, version, maintainer_id, files[file]["files id"]))
-            
+
             for suite in changes["distribution"].keys():
                 suite_id = db_access.get_suite_id(suite);
                 projectB.query("INSERT INTO src_associations (suite, source) VALUES (%d, currval('source_id_seq'))" % (suite_id))
@@ -780,7 +965,7 @@ def install (changes_filename, summary, short_summary):
                 if files_id == None:
                     files_id = db_access.set_files_id (filename, dsc_files[dsc_file]["size"], dsc_files[dsc_file]["md5sum"], dsc_location_id);
                 projectB.query("INSERT INTO dsc_files (source, file) VALUES (currval('source_id_seq'), %d)" % (files_id));
-            
+
     # Add the .deb files to the DB
     for file in files.keys():
         if files[file]["type"] == "deb":
@@ -793,14 +978,8 @@ def install (changes_filename, summary, short_summary):
             architecture_id = db_access.get_architecture_id (architecture);
             type = files[file]["dbtype"];
             dsc_component = files[file]["component"]
-            source = files[file]["source"]
-            source_version = ""
-            if string.find(source, "(") != -1:
-                m = utils.re_extract_src_version.match(source)
-                source = m.group(1)
-                source_version = m.group(2)
-            if not source_version:
-                source_version = version
+            source = files[file]["source package"]
+            source_version = files[file]["source version"];
             filename = files[file]["pool name"] + file;
             if not files[file]["files id"]:
                 files[file]["files id"] = db_access.set_files_id (filename, files[file]["size"], files[file]["md5sum"], files[file]["location id"])
@@ -859,6 +1038,7 @@ def install (changes_filename, summary, short_summary):
         destination = Cnf["Dir::PoolDir"] + files[file]["pool name"] + file
         destdir = os.path.dirname(destination)
         utils.move (file, destination)
+        Logger.log(["installed", file, files[file]["type"], files[file]["size"], files[file]["architecture"]]);
         install_bytes = install_bytes + float(files[file]["size"])
 
     # Copy the .changes file across for suite which need it.
@@ -871,11 +1051,11 @@ def install (changes_filename, summary, short_summary):
     try:
         utils.move (changes_filename, Cnf["Dir::IncomingDir"] + 'DONE/' + os.path.basename(changes_filename))
     except:
-        sys.stderr.write("W: couldn't move changes file '%s' to DONE directory [Got %s].\n" % (os.path.basename(changes_filename), sys.exc_type));
+        utils.warn("couldn't move changes file '%s' to DONE directory. [Got %s]" % (os.path.basename(changes_filename), sys.exc_type));
 
     install_count = install_count + 1;
 
-    if not Cnf["Dinstall::Options::No-Mail"]:
+    if not Options["No-Mail"]:
         Subst["__SUITE__"] = "";
         Subst["__SUMMARY__"] = summary;
         mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.installed","r").read());
@@ -883,11 +1063,11 @@ def install (changes_filename, summary, short_summary):
         announce (short_summary, 1)
         check_override ();
 
-#####################################################################################################################
+################################################################################
 
 def stable_install (changes_filename, summary, short_summary):
     global install_count, install_bytes, Subst;
-    
+
     print "Installing to stable."
 
     archive = utils.where_am_i();
@@ -902,15 +1082,15 @@ def stable_install (changes_filename, summary, short_summary):
             version = dsc["version"]  # NB: not files[file]["version"], that has no epoch
             q = projectB.query("SELECT id FROM source WHERE source = '%s' AND version = '%s'" % (package, version))
             ql = q.getresult()
-            if ql == []:
-                sys.stderr.write("INTERNAL ERROR: couldn't find '%s' (%s) in source table.\n" % (package, version));
-                sys.exit(1);
+            if not ql:
+                utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s) in source table." % (package, version));
             source_id = ql[0][0];
             suite_id = db_access.get_suite_id('proposed-updates');
             projectB.query("DELETE FROM src_associations WHERE suite = '%s' AND source = '%s'" % (suite_id, source_id));
             suite_id = db_access.get_suite_id('stable');
             projectB.query("INSERT INTO src_associations (suite, source) VALUES ('%s', '%s')" % (suite_id, source_id));
-                
+            install_bytes = install_bytes + float(files[file]["size"])
+
     # Add the .deb files to the DB
     for file in files.keys():
         if files[file]["type"] == "deb":
@@ -919,18 +1099,19 @@ def stable_install (changes_filename, summary, short_summary):
             architecture = files[file]["architecture"]
             q = projectB.query("SELECT b.id FROM binaries b, architecture a WHERE b.package = '%s' AND b.version = '%s' AND (a.arch_string = '%s' OR a.arch_string = 'all') AND b.architecture = a.id" % (package, version, architecture))
             ql = q.getresult()
-            if ql == []:
-                sys.stderr.write("INTERNAL ERROR: couldn't find '%s' (%s for %s architecture) in binaries table.\n" % (package, version, architecture));
-                sys.exit(1);
+            if not ql:
+                utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s for %s architecture) in binaries table." % (package, version, architecture));
             binary_id = ql[0][0];
             suite_id = db_access.get_suite_id('proposed-updates');
             projectB.query("DELETE FROM bin_associations WHERE suite = '%s' AND bin = '%s'" % (suite_id, binary_id));
             suite_id = db_access.get_suite_id('stable');
             projectB.query("INSERT INTO bin_associations (suite, bin) VALUES ('%s', '%s')" % (suite_id, binary_id));
+            install_bytes = install_bytes + float(files[file]["size"])
 
     projectB.query("COMMIT WORK");
 
-    utils.move (changes_filename, Cnf["Rhona::Morgue"] + os.path.basename(changes_filename));
+    # FIXME
+    utils.move (changes_filename, Cnf["Dir::Morgue"] + '/katie/' + os.path.basename(changes_filename));
 
     # Update the Stable ChangeLog file
 
@@ -938,7 +1119,7 @@ def stable_install (changes_filename, summary, short_summary):
     changelog_filename = Cnf["Dir::RootDir"] + Cnf["Suite::Stable::ChangeLogBase"] + "ChangeLog";
     if os.path.exists(new_changelog_filename):
         os.unlink (new_changelog_filename);
-    
+
     new_changelog = utils.open_file(new_changelog_filename, 'w');
     for file in files.keys():
         if files[file]["type"] == "deb":
@@ -950,7 +1131,7 @@ def stable_install (changes_filename, summary, short_summary):
     chop_changes = re_fdnic.sub("\n", changes["changes"]);
     new_changelog.write(chop_changes + '\n\n');
     if os.access(changelog_filename, os.R_OK) != 0:
-        changelog = utils.open_file(changelog_filename, 'r');
+        changelog = utils.open_file(changelog_filename);
         new_changelog.write(changelog.read());
     new_changelog.close();
     if os.access(changelog_filename, os.R_OK) != 0:
@@ -959,17 +1140,18 @@ def stable_install (changes_filename, summary, short_summary):
 
     install_count = install_count + 1;
 
-    if not Cnf["Dinstall::Options::No-Mail"]:
+    if not Options["No-Mail"]:
         Subst["__SUITE__"] = " into stable";
         Subst["__SUMMARY__"] = summary;
+        mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.installed","r").read());
         utils.send_mail (mail_message, "")
         announce (short_summary, 1)
 
-#####################################################################################################################
+################################################################################
 
 def reject (changes_filename, manual_reject_mail_filename):
     global Subst;
-    
+
     print "Rejecting.\n"
 
     base_changes_filename = os.path.basename(changes_filename);
@@ -980,15 +1162,39 @@ def reject (changes_filename, manual_reject_mail_filename):
     try:
         utils.move (changes_filename, "%s/REJECT/%s" % (Cnf["Dir::IncomingDir"], base_changes_filename));
     except:
-        sys.stderr.write("W: couldn't reject changes file '%s' [Got %s].\n" % (base_changes_filename, sys.exc_type));
+        utils.warn("couldn't reject changes file '%s'. [Got %s]" % (base_changes_filename, sys.exc_type));
         pass;
-    for file in files.keys():
-        if os.path.exists(file):
-            try:
-                utils.move (file, "%s/REJECT/%s" % (Cnf["Dir::IncomingDir"], file));
-            except:
-                sys.stderr.write("W: couldn't reject file '%s' [Got %s].\n" % (file, sys.exc_type));
-                pass;
+    if not changes.has_key("stable install"):
+        for file in files.keys():
+            if os.path.exists(file):
+                try:
+                    utils.move (file, "%s/REJECT/%s" % (Cnf["Dir::IncomingDir"], file));
+                except:
+                    utils.warn("couldn't reject file '%s'. [Got %s]" % (file, sys.exc_type));
+                    pass;
+    else:
+        suite_id = db_access.get_suite_id('proposed-updates');
+        # Remove files from proposed-updates suite
+        for file in files.keys():
+            if files[file]["type"] == "dsc":
+                package = dsc["source"];
+                version = dsc["version"];  # NB: not files[file]["version"], that has no epoch
+                q = projectB.query("SELECT id FROM source WHERE source = '%s' AND version = '%s'" % (package, version));
+                ql = q.getresult();
+                if not ql:
+                    utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s) in source table." % (package, version));
+                source_id = ql[0][0];
+                projectB.query("DELETE FROM src_associations WHERE suite = '%s' AND source = '%s'" % (suite_id, source_id));
+            elif files[file]["type"] == "deb":
+                package = files[file]["package"];
+                version = files[file]["version"];
+                architecture = files[file]["architecture"];
+                q = projectB.query("SELECT b.id FROM binaries b, architecture a WHERE b.package = '%s' AND b.version = '%s' AND (a.arch_string = '%s' OR a.arch_string = 'all') AND b.architecture = a.id" % (package, version, architecture));
+                ql = q.getresult();
+                if not ql:
+                    utils.fubar("[INTERNAL ERROR] couldn't find '%s' (%s for %s architecture) in binaries table." % (package, version, architecture));
+                binary_id = ql[0][0];
+                projectB.query("DELETE FROM bin_associations WHERE suite = '%s' AND bin = '%s'" % (suite_id, binary_id));
 
     # If this is not a manual rejection generate the .reason file and rejection mail message
     if manual_reject_mail_filename == "":
@@ -998,27 +1204,34 @@ def reject (changes_filename, manual_reject_mail_filename):
         os.write(fd, reject_message);
         os.close(fd);
         Subst["__MANUAL_REJECT_MESSAGE__"] = "";
+        Subst["__CC__"] = "X-Katie-Rejection: automatic (moo)";
         reject_mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.rejected","r").read());
     else: # Have a manual rejection file to use
         reject_mail_message = ""; # avoid <undef>'s
-        
+
     # Send the rejection mail if appropriate
-    if not Cnf["Dinstall::Options::No-Mail"]:
+    if not Options["No-Mail"]:
         utils.send_mail (reject_mail_message, manual_reject_mail_filename);
 
+    Logger.log(["rejected", changes_filename]);
+
 ##################################################################
 
 def manual_reject (changes_filename):
     global Subst;
-    
-    # Build up the rejection email 
-    user_email_address = string.replace(string.split(pwd.getpwuid(os.getuid())[4],',')[0], '.', '')
-    user_email_address = user_email_address + " <%s@%s>" % (pwd.getpwuid(os.getuid())[0], Cnf["Dinstall::MyHost"])
-    manual_reject_message = Cnf.get("Dinstall::Options::Manual-Reject", "")
+
+    # Build up the rejection email
+    user_email_address = utils.whoami() + " <%s@%s>" % (pwd.getpwuid(os.getuid())[0], Cnf["Dinstall::MyHost"])
+    manual_reject_message = Options.get("Manual-Reject", "")
 
     Subst["__MANUAL_REJECT_MESSAGE__"] = manual_reject_message;
-    reject_mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.rejected","r").read());
-    
+    Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"];
+    if changes.has_key("stable install"):
+        template = "katie.stable-rejected";
+    else:
+        template = "katie.rejected";
+    reject_mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/"+template,"r").read());
+
     # Write the rejection email out as the <foo>.reason file
     reason_filename = re_changes.sub("reason", os.path.basename(changes_filename));
     reject_filename = "%s/REJECT/%s" % (Cnf["Dir::IncomingDir"], reason_filename)
@@ -1027,24 +1240,25 @@ def manual_reject (changes_filename):
     fd = os.open(reject_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644);
     os.write(fd, reject_mail_message);
     os.close(fd);
-    
+
     # If we weren't given one, spawn an editor so the user can add one in
     if manual_reject_message == "":
-        result = os.system("vi +6 %s" % (reject_file))
+        result = os.system("vi +6 %s" % (reject_filename))
         if result != 0:
-            sys.stderr.write ("vi invocation failed for `%s'!\n" % (reject_file))
-            sys.exit(result)
+            utils.fubar("vi invocation failed for `%s'!" % (reject_filename), result);
 
     # Then process it as if it were an automatic rejection
     reject (changes_filename, reject_filename)
 
 #####################################################################################################################
- 
+
 def acknowledge_new (changes_filename, summary):
     global new_ack_new, Subst;
 
     changes_filename = os.path.basename(changes_filename);
 
+    Logger.log(["new",changes_filename]);
+
     new_ack_new[changes_filename] = 1;
 
     if new_ack_old.has_key(changes_filename):
@@ -1052,7 +1266,7 @@ def acknowledge_new (changes_filename, summary):
         return;
 
     print "Sending new ack.";
-    if not Cnf["Dinstall::Options::No-Mail"]:
+    if not Options["No-Mail"]:
         Subst["__SUMMARY__"] = summary;
         new_ack_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.new","r").read());
         utils.send_mail(new_ack_message,"");
@@ -1061,7 +1275,7 @@ def acknowledge_new (changes_filename, summary):
 
 def announce (short_summary, action):
     global Subst;
-    
+
     # Only do announcements for source uploads with a recent dpkg-dev installed
     if float(changes.get("format", 0)) < 1.6 or not changes["architecture"].has_key("source"):
         return ""
@@ -1082,12 +1296,9 @@ def announce (short_summary, action):
             mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.announce","r").read());
             utils.send_mail (mail_message, "")
 
-    (dsc_rfc822, dsc_name, dsc_email) = utils.fix_maintainer (dsc.get("maintainer",Cnf["Dinstall::MyEmailAddress"]));
     bugs = changes["closes"].keys()
     bugs.sort()
-    # changes["changedbyname"] == dsc_name is probably never true, but better
-    # safe than sorry
-    if dsc_name == changes["maintainername"] and (changes["changedbyname"] == "" or changes["changedbyname"] == dsc_name):
+    if not nmu.is_an_nmu(changes, dsc):
         summary = summary + "Closing bugs: "
         for bug in bugs:
             summary = summary + "%s " % (bug)
@@ -1104,6 +1315,8 @@ distribution."""
                     Subst["__STABLE_WARNING__"] = "";
                 mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.bug-close","r").read());
                 utils.send_mail (mail_message, "")
+        if action:
+            Logger.log(["closing bugs"]+bugs);
     else:                     # NMU
         summary = summary + "Setting bugs to severity fixed: "
         control_message = ""
@@ -1114,6 +1327,8 @@ distribution."""
             Subst["__CONTROL_MESSAGE__"] = control_message;
             mail_message = utils.TemplateSubst(Subst,open(Cnf["Dir::TemplatesDir"]+"/katie.bug-nmu-fixed","r").read());
             utils.send_mail (mail_message, "")
+        if action:
+            Logger.log(["setting bugs to fixed"]+bugs);
     summary = summary + "\n"
 
     return summary
@@ -1149,16 +1364,21 @@ def process_it (changes_file):
     # And since handling of installs to stable munges with the CWD;
     # save and restore it.
     cwd = os.getcwd();
-    
-    check_signature (changes_file);
-    check_changes (changes_file);
-    while reprocess:
-        reprocess = 0;
-        check_files ();
-        check_md5sums ();
-        check_dsc ();
-        check_diff ();
-        
+
+    try:
+        check_signature (changes_file);
+        check_changes (changes_file);
+        while reprocess:
+            reprocess = 0;
+            check_files ();
+            check_md5sums ();
+            check_dsc ();
+            check_diff ();
+    except:
+        print "ERROR";
+	traceback.print_exc(file=sys.stdout);
+        pass;
+
     update_subst(changes_file);
     action(changes_file);
 
@@ -1168,75 +1388,66 @@ def process_it (changes_file):
 ###############################################################################
 
 def main():
-    global Cnf, projectB, install_bytes, new_ack_old, Subst
+    global Cnf, Options, projectB, install_bytes, new_ack_old, Subst, nmu, Logger
 
-    apt_pkg.init();
-    
-    Cnf = apt_pkg.newConfiguration();
-    apt_pkg.ReadConfigFileISC(Cnf,utils.which_conf_file());
+    changes_files = init();
 
-    Arguments = [('a',"automatic","Dinstall::Options::Automatic"),
-                 ('d',"debug","Dinstall::Options::Debug", "IntVal"),
-                 ('h',"help","Dinstall::Options::Help"),
-                 ('k',"ack-new","Dinstall::Options::Ack-New"),
-                 ('m',"manual-reject","Dinstall::Options::Manual-Reject", "HasArg"),
-                 ('n',"no-action","Dinstall::Options::No-Action"),
-                 ('p',"no-lock", "Dinstall::Options::No-Lock"),
-                 ('s',"no-mail", "Dinstall::Options::No-Mail"),
-                 ('u',"override-distribution", "Dinstall::Options::Override-Distribution", "HasArg"),
-                 ('v',"version","Dinstall::Options::Version")];
-    
-    changes_files = apt_pkg.ParseCommandLine(Cnf,Arguments,sys.argv);
-
-    if Cnf["Dinstall::Options::Help"]:
-        usage(0);
-        
-    if Cnf["Dinstall::Options::Version"]:
-        print "katie version 0.0000000000";
-        usage(0);
+    if Options["Help"]:
+        usage();
 
-    postgresql_user = None; # Default == Connect as user running program.
+    if Options["Version"]:
+        print "katie %s" % (katie_version);
+        sys.exit(0);
 
     # -n/--dry-run invalidates some other options which would involve things happening
-    if Cnf["Dinstall::Options::No-Action"]:
-        Cnf["Dinstall::Options::Automatic"] = ""
-        Cnf["Dinstall::Options::Ack-New"] = ""
-        postgresql_user = Cnf["DB::ROUser"];
+    if Options["No-Action"]:
+        Options["Automatic"] = "";
+        Options["Ack-New"] = "";
 
-    projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]), None, None, postgresql_user);
+    projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"]));
 
     db_access.init(Cnf, projectB);
 
     # Check that we aren't going to clash with the daily cron job
 
-    if os.path.exists("%s/Archive_Maintenance_In_Progress" % (Cnf["Dir::RootDir"])) and not Cnf["Dinstall::Options::No-Lock"]:
-        sys.stderr.write("Archive maintenance in progress.  Try again later.\n");
-        sys.exit(2);
-    
-    # Obtain lock if not in no-action mode
+    if not Options["No-Action"] and os.path.exists("%s/Archive_Maintenance_In_Progress" % (Cnf["Dir::RootDir"])) and not Options["No-Lock"]:
+        utils.fubar("Archive maintenance in progress.  Try again later.");
 
-    if not Cnf["Dinstall::Options::No-Action"]:
-        lock_fd = os.open(Cnf["Dinstall::LockFile"], os.O_RDWR);
-        fcntl.lockf(lock_fd, FCNTL.F_TLOCK);
+    # Obtain lock if not in no-action mode and initialize the log
 
-    # Read in the list of already-acknowledged NEW packages
-    new_ack_list = utils.open_file(Cnf["Dinstall::NewAckList"],'r');
-    new_ack_old = {};
-    for line in new_ack_list.readlines():
-        new_ack_old[line[:-1]] = 1;
-    new_ack_list.close();
+    if not Options["No-Action"]:
+        lock_fd = os.open(Cnf["Dinstall::LockFile"], os.O_RDWR | os.O_CREAT);
+        fcntl.lockf(lock_fd, FCNTL.F_TLOCK);
+        Logger = logging.Logger(Cnf, "katie");
+
+    if Options["Ack-New"]:
+        # Read in the list of already-acknowledged NEW packages
+        if not os.path.exists(Cnf["Dinstall::NewAckList"]):
+            utils.touch_file(Cnf["Dinstall::NewAckList"]);
+        new_ack_list = utils.open_file(Cnf["Dinstall::NewAckList"]);
+        new_ack_old = {};
+        for line in new_ack_list.readlines():
+            new_ack_old[line[:-1]] = 1;
+        new_ack_list.close();
 
     # Initialize the substitution template mapping global
     Subst = {}
     Subst["__ADMIN_ADDRESS__"] = Cnf["Dinstall::MyAdminAddress"];
     Subst["__BUG_SERVER__"] = Cnf["Dinstall::BugServer"];
-    bcc = "X-Katie: $Revision: 1.36 $"
+    bcc = "X-Katie: %s" % (katie_version);
     if Cnf.has_key("Dinstall::Bcc"):
         Subst["__BCC__"] = bcc + "\nBcc: %s" % (Cnf["Dinstall::Bcc"]);
     else:
         Subst["__BCC__"] = bcc;
     Subst["__DISTRO__"] = Cnf["Dinstall::MyDistribution"];
     Subst["__KATIE_ADDRESS__"] = Cnf["Dinstall::MyEmailAddress"];
+    Subst["__STABLE_REJECTOR__"] = Cnf["Dinstall::StableRejector"];
+
+    # Read in the group-maint override file
+    nmu = nmu_p();
+
+    # Sort the .changes files so that we process sourceful ones first
+    changes_files.sort(utils.changes_compare);
 
     # Process the changes files
     for changes_file in changes_files:
@@ -1248,15 +1459,18 @@ def main():
         if install_count > 1:
             sets = "sets"
         sys.stderr.write("Installed %d package %s, %s.\n" % (install_count, sets, utils.size_type(int(install_bytes))));
+        Logger.log(["total",install_count,install_bytes]);
 
     # Write out the list of already-acknowledged NEW packages
-    if Cnf["Dinstall::Options::Ack-New"]:
+    if Options["Ack-New"]:
         new_ack_list = utils.open_file(Cnf["Dinstall::NewAckList"],'w')
         for i in new_ack_new.keys():
             new_ack_list.write(i+'\n')
         new_ack_list.close()
-    
-            
+
+    if not Options["No-Action"]:
+        Logger.close();
+
 if __name__ == '__main__':
     main()