X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=dak%2Fprocess_new.py;h=3dd93ada1a68ba480c2dcf6c6a9d186e09ef7da4;hb=e79e9a1395528354b5978fc4b92a8fcdd1559d70;hp=e3786cb950fd54c21299a48f046af90565ab8be0;hpb=7c0d299579cf1a4ed71f1bf116d231e0ae3a71fd;p=dak.git

diff --git a/dak/process_new.py b/dak/process_new.py
index e3786cb9..3dd93ada 100755
--- a/dak/process_new.py
+++ b/dak/process_new.py
@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+# vim:set et ts=4 sw=4:
 
 # Handles NEW and BYHAND packages
 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006  James Troup <james@nocrew.org>
@@ -39,10 +40,10 @@
 import copy, errno, os, readline, stat, sys, time
 import apt_pkg, apt_inst
 import examine_package
-import daklib.database
-import daklib.logging
-import daklib.queue 
-import daklib.utils
+from daklib import database
+from daklib import logging
+from daklib import queue
+from daklib import utils
 
 # Globals
 Cnf = None
@@ -70,28 +71,33 @@ def recheck():
     files = Upload.pkg.files
     reject_message = ""
 
-    for file in files.keys():
+    for f in files.keys():
         # The .orig.tar.gz can disappear out from under us is it's a
         # duplicate of one in the archive.
-        if not files.has_key(file):
+        if not files.has_key(f):
             continue
         # Check that the source still exists
-        if files[file]["type"] == "deb":
-            source_version = files[file]["source version"]
-            source_package = files[file]["source package"]
+        if files[f]["type"] == "deb":
+            source_version = files[f]["source version"]
+            source_package = files[f]["source package"]
             if not Upload.pkg.changes["architecture"].has_key("source") \
                and not Upload.source_exists(source_package, source_version, Upload.pkg.changes["distribution"].keys()):
-                source_epochless_version = daklib.utils.re_no_epoch.sub('', source_version)
+                source_epochless_version = utils.re_no_epoch.sub('', source_version)
                 dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
-                if not os.path.exists(Cnf["Dir::Queue::Accepted"] + '/' + dsc_filename):
-                    reject("no source found for %s %s (%s)." % (source_package, source_version, file))
+                found = 0
+                for q in ["Accepted", "Embargoed", "Unembargoed"]:
+                    if Cnf.has_key("Dir::Queue::%s" % (q)):
+                        if os.path.exists(Cnf["Dir::Queue::%s" % (q)] + '/' + dsc_filename):
+                            found = 1
+                if not found:
+                    reject("no source found for %s %s (%s)." % (source_package, source_version, f))
 
         # Version and file overwrite checks
-        if files[file]["type"] == "deb":
-            reject(Upload.check_binary_against_db(file))
-        elif files[file]["type"] == "dsc":
-            reject(Upload.check_source_against_db(file))
-            (reject_msg, is_in_incoming) = Upload.check_dsc_against_db(file)
+        if files[f]["type"] == "deb":
+            reject(Upload.check_binary_against_db(f))
+        elif files[f]["type"] == "dsc":
+            reject(Upload.check_source_against_db(f))
+            (reject_msg, is_in_incoming) = Upload.check_dsc_against_db(f)
             reject(reject_msg, "")
 
     if reject_message.find("Rejected") != -1:
@@ -103,8 +109,8 @@ def recheck():
         prompt = "[R]eject, Skip, Quit ?"
 
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.match(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.match(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
@@ -116,6 +122,7 @@ def recheck():
         elif answer == 'S':
             return 0
         elif answer == 'Q':
+            end()
             sys.exit(0)
 
     return 1
@@ -145,7 +152,7 @@ def indiv_sg_compare (a, b):
 def sg_compare (a, b):
     a = a[1]
     b = b[1]
-    """Sort by have note, time of oldest upload."""
+    """Sort by have note, source already in database and time of oldest upload."""
     # Sort by have note
     a_note_state = a["note_state"]
     b_note_state = b["note_state"]
@@ -153,6 +160,10 @@ def sg_compare (a, b):
         return -1
     elif a_note_state > b_note_state:
         return 1
+    # Sort by source already in database (descending)
+    source_in_database = cmp(a["source_in_database"], b["source_in_database"])
+    if source_in_database:
+        return -source_in_database
 
     # Sort by time of oldest upload
     return cmp(a["oldest"], b["oldest"])
@@ -187,6 +198,9 @@ def sort_changes(changes_files):
         per_source[source]["list"].append(cache[filename])
     # Determine oldest time and have note status for each source group
     for source in per_source.keys():
+        q = projectB.query("SELECT 1 FROM source WHERE source = '%s'" % source)
+        ql = q.getresult()
+        per_source[source]["source_in_database"] = len(ql)>0
         source_list = per_source[source]["list"]
         first = source_list[0]
         oldest = os.stat(first["filename"])[stat.ST_MTIME]
@@ -256,7 +270,7 @@ class Priority_Completer:
 ################################################################################
 
 def print_new (new, indexed, file=sys.stdout):
-    daklib.queue.check_valid(new)
+    queue.check_valid(new)
     broken = 0
     index = 0
     for pkg in new.keys():
@@ -295,17 +309,17 @@ def index_range (index):
 
 def edit_new (new):
     # Write the current data to a temporary file
-    temp_filename = daklib.utils.temp_filename()
-    temp_file = daklib.utils.open_file(temp_filename, 'w')
+    temp_filename = utils.temp_filename()
+    temp_file = utils.open_file(temp_filename, 'w')
     print_new (new, 0, temp_file)
     temp_file.close()
     # Spawn an editor on that file
     editor = os.environ.get("EDITOR","vi")
     result = os.system("%s %s" % (editor, temp_filename))
     if result != 0:
-        daklib.utils.fubar ("%s invocation failed for %s." % (editor, temp_filename), result)
+        utils.fubar ("%s invocation failed for %s." % (editor, temp_filename), result)
     # Read the edited data back in
-    temp_file = daklib.utils.open_file(temp_filename)
+    temp_file = utils.open_file(temp_filename)
     lines = temp_file.readlines()
     temp_file.close()
     os.unlink(temp_filename)
@@ -319,16 +333,16 @@ def edit_new (new):
         s[len(s):3] = [None] * (3-len(s))
         (pkg, priority, section) = s[:3]
         if not new.has_key(pkg):
-            daklib.utils.warn("Ignoring unknown package '%s'" % (pkg))
+            utils.warn("Ignoring unknown package '%s'" % (pkg))
         else:
             # Strip off any invalid markers, print_new will readd them.
             if section.endswith("[!]"):
                 section = section[:-3]
             if priority.endswith("[!]"):
                 priority = priority[:-3]
-            for file in new[pkg]["files"]:
-                Upload.pkg.files[file]["section"] = section
-                Upload.pkg.files[file]["priority"] = priority
+            for f in new[pkg]["files"]:
+                Upload.pkg.files[f]["section"] = section
+                Upload.pkg.files[f]["priority"] = priority
             new[pkg]["section"] = section
             new[pkg]["priority"] = priority
 
@@ -337,21 +351,21 @@ def edit_new (new):
 def edit_index (new, index):
     priority = new[index]["priority"]
     section = new[index]["section"]
-    type = new[index]["type"]
+    ftype = new[index]["type"]
     done = 0
     while not done:
         print "\t".join([index, priority, section])
 
         answer = "XXX"
-        if type != "dsc":
+        if ftype != "dsc":
             prompt = "[B]oth, Priority, Section, Done ? "
         else:
             prompt = "[S]ection, Done ? "
         edit_priority = edit_section = 0
 
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.match(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.match(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
@@ -370,7 +384,7 @@ def edit_index (new, index):
             readline.set_completer(Priorities.complete)
             got_priority = 0
             while not got_priority:
-                new_priority = daklib.utils.our_raw_input("New priority: ").strip()
+                new_priority = utils.our_raw_input("New priority: ").strip()
                 if new_priority not in Priorities.priorities:
                     print "E: '%s' is not a valid priority, try again." % (new_priority)
                 else:
@@ -382,7 +396,7 @@ def edit_index (new, index):
             readline.set_completer(Sections.complete)
             got_section = 0
             while not got_section:
-                new_section = daklib.utils.our_raw_input("New section: ").strip()
+                new_section = utils.our_raw_input("New section: ").strip()
                 if new_section not in Sections.sections:
                     print "E: '%s' is not a valid section, try again." % (new_section)
                 else:
@@ -392,9 +406,9 @@ def edit_index (new, index):
         # Reset the readline completer
         readline.set_completer(None)
 
-    for file in new[index]["files"]:
-        Upload.pkg.files[file]["section"] = section
-        Upload.pkg.files[file]["priority"] = priority
+    for f in new[index]["files"]:
+        Upload.pkg.files[f]["section"] = section
+        Upload.pkg.files[f]["priority"] = priority
     new[index]["priority"] = priority
     new[index]["section"] = section
     return new
@@ -416,12 +430,12 @@ def edit_overrides (new):
 
         got_answer = 0
         while not got_answer:
-            answer = daklib.utils.our_raw_input(prompt)
+            answer = utils.our_raw_input(prompt)
             if not answer.isdigit():
                 answer = answer[:1].upper()
             if answer == "E" or answer == "D":
                 got_answer = 1
-            elif daklib.queue.re_isanum.match (answer):
+            elif queue.re_isanum.match (answer):
                 answer = int(answer)
                 if (answer < 1) or (answer > index):
                     print "%s is not a valid index (%s).  Please retry." % (answer, index_range(index))
@@ -441,24 +455,24 @@ def edit_overrides (new):
 
 def edit_note(note):
     # Write the current data to a temporary file
-    temp_filename = daklib.utils.temp_filename()
-    temp_file = daklib.utils.open_file(temp_filename, 'w')
+    temp_filename = utils.temp_filename()
+    temp_file = utils.open_file(temp_filename, 'w')
     temp_file.write(note)
     temp_file.close()
     editor = os.environ.get("EDITOR","vi")
     answer = 'E'
     while answer == 'E':
         os.system("%s %s" % (editor, temp_filename))
-        temp_file = daklib.utils.open_file(temp_filename)
+        temp_file = utils.open_file(temp_filename)
         note = temp_file.read().rstrip()
         temp_file.close()
         print "Note:"
-        print daklib.utils.prefix_multi_line_string(note,"  ")
+        print utils.prefix_multi_line_string(note,"  ")
         prompt = "[D]one, Edit, Abandon, Quit ?"
         answer = "XXX"
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.search(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.search(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
@@ -466,6 +480,7 @@ def edit_note(note):
     if answer == 'A':
         return
     elif answer == 'Q':
+        end()
         sys.exit(0)
     Upload.pkg.changes["process-new note"] = note
     Upload.dump_vars(Cnf["Dir::Queue::New"])
@@ -480,23 +495,23 @@ def check_pkg ():
             sys.stdout = less_fd
             examine_package.display_changes(Upload.pkg.changes_file)
             files = Upload.pkg.files
-            for file in files.keys():
-                if files[file].has_key("new"):
-                    type = files[file]["type"]
-                    if type == "deb":
-                        examine_package.check_deb(file)
-                    elif type == "dsc":
-                        examine_package.check_dsc(file)
+            for f in files.keys():
+                if files[f].has_key("new"):
+                    ftype = files[f]["type"]
+                    if ftype == "deb":
+                        examine_package.check_deb(f)
+                    elif ftype == "dsc":
+                        examine_package.check_dsc(f)
         finally:
             sys.stdout = stdout_fd
     except IOError, e:
-        if errno.errorcode[e.errno] == 'EPIPE':
-            daklib.utils.warn("[examine_package] Caught EPIPE; skipping.")
+        if e.errno == errno.EPIPE:
+            utils.warn("[examine_package] Caught EPIPE; skipping.")
             pass
         else:
             raise
     except KeyboardInterrupt:
-        daklib.utils.warn("[examine_package] Caught C-c; skipping.")
+        utils.warn("[examine_package] Caught C-c; skipping.")
         pass
 
 ################################################################################
@@ -506,15 +521,15 @@ def check_pkg ():
 def do_bxa_notification():
     files = Upload.pkg.files
     summary = ""
-    for file in files.keys():
-        if files[file]["type"] == "deb":
-            control = apt_pkg.ParseSection(apt_inst.debExtractControl(daklib.utils.open_file(file)))
+    for f in files.keys():
+        if files[f]["type"] == "deb":
+            control = apt_pkg.ParseSection(apt_inst.debExtractControl(utils.open_file(f)))
             summary += "\n"
             summary += "Package: %s\n" % (control.Find("Package"))
             summary += "Description: %s\n" % (control.Find("Description"))
     Upload.Subst["__BINARY_DESCRIPTIONS__"] = summary
-    bxa_mail = daklib.utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/process-new.bxa_notification")
-    daklib.utils.send_mail(bxa_mail)
+    bxa_mail = utils.TemplateSubst(Upload.Subst,Cnf["Dir::Templates"]+"/process-new.bxa_notification")
+    utils.send_mail(bxa_mail)
 
 ################################################################################
 
@@ -524,16 +539,16 @@ def add_overrides (new):
 
     projectB.query("BEGIN WORK")
     for suite in changes["suite"].keys():
-        suite_id = daklib.database.get_suite_id(suite)
+        suite_id = database.get_suite_id(suite)
         for pkg in new.keys():
-            component_id = daklib.database.get_component_id(new[pkg]["component"])
-            type_id = daklib.database.get_override_type_id(new[pkg]["type"])
+            component_id = database.get_component_id(new[pkg]["component"])
+            type_id = database.get_override_type_id(new[pkg]["type"])
             priority_id = new[pkg]["priority id"]
             section_id = new[pkg]["section id"]
             projectB.query("INSERT INTO override (suite, component, type, package, priority, section, maintainer) VALUES (%s, %s, %s, '%s', %s, %s, '')" % (suite_id, component_id, type_id, pkg, priority_id, section_id))
-            for file in new[pkg]["files"]:
-                if files[file].has_key("new"):
-                    del files[file]["new"]
+            for f in new[pkg]["files"]:
+                if files[f].has_key("new"):
+                    del files[f]["new"]
             del new[pkg]
 
     projectB.query("COMMIT WORK")
@@ -545,21 +560,21 @@ def add_overrides (new):
 
 def prod_maintainer ():
     # Here we prepare an editor and get them ready to prod...
-    temp_filename = daklib.utils.temp_filename()
+    temp_filename = utils.temp_filename()
     editor = os.environ.get("EDITOR","vi")
     answer = 'E'
     while answer == 'E':
         os.system("%s %s" % (editor, temp_filename))
-        file = daklib.utils.open_file(temp_filename)
-        prod_message = "".join(file.readlines())
-        file.close()
+        f = utils.open_file(temp_filename)
+        prod_message = "".join(f.readlines())
+        f.close()
         print "Prod message:"
-        print daklib.utils.prefix_multi_line_string(prod_message,"  ",include_blank_lines=1)
+        print utils.prefix_multi_line_string(prod_message,"  ",include_blank_lines=1)
         prompt = "[P]rod, Edit, Abandon, Quit ?"
         answer = "XXX"
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.search(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.search(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
@@ -567,9 +582,10 @@ def prod_maintainer ():
         if answer == 'A':
             return
         elif answer == 'Q':
+            end()
             sys.exit(0)
     # Otherwise, do the proding...
-    user_email_address = daklib.utils.whoami() + " <%s>" % (
+    user_email_address = utils.whoami() + " <%s>" % (
         Cnf["Dinstall::MyAdminAddress"])
 
     Subst = Upload.Subst
@@ -578,12 +594,12 @@ def prod_maintainer ():
     Subst["__PROD_MESSAGE__"] = prod_message
     Subst["__CC__"] = "Cc: " + Cnf["Dinstall::MyEmailAddress"]
 
-    prod_mail_message = daklib.utils.TemplateSubst(
+    prod_mail_message = utils.TemplateSubst(
         Subst,Cnf["Dir::Templates"]+"/process-new.prod")
 
     # Send the prod mail if appropriate
     if not Cnf["Dinstall::Options::No-Mail"]:
-        daklib.utils.send_mail(prod_mail_message)
+        utils.send_mail(prod_mail_message)
 
     print "Sent proding message"
 
@@ -601,27 +617,27 @@ def do_new():
     for suite in changes["suite"].keys():
         override = Cnf.Find("Suite::%s::OverrideSuite" % (suite))
         if override:
-	    (olderr, newerr) = (daklib.database.get_suite_id(suite) == -1,
-	      daklib.database.get_suite_id(override) == -1)
-	    if olderr or newerr:
-	        (oinv, newinv) = ("", "")
-		if olderr: oinv = "invalid "
-		if newerr: ninv = "invalid "
-	        print "warning: overriding %ssuite %s to %ssuite %s" % (
-			oinv, suite, ninv, override)
+            (olderr, newerr) = (database.get_suite_id(suite) == -1,
+              database.get_suite_id(override) == -1)
+            if olderr or newerr:
+                (oinv, newinv) = ("", "")
+                if olderr: oinv = "invalid "
+                if newerr: ninv = "invalid "
+                print "warning: overriding %ssuite %s to %ssuite %s" % (
+                        oinv, suite, ninv, override)
             del changes["suite"][suite]
             changes["suite"][override] = 1
     # Validate suites
     for suite in changes["suite"].keys():
-        suite_id = daklib.database.get_suite_id(suite)
+        suite_id = database.get_suite_id(suite)
         if suite_id == -1:
-            daklib.utils.fubar("%s has invalid suite '%s' (possibly overriden).  say wha?" % (changes, suite))
+            utils.fubar("%s has invalid suite '%s' (possibly overriden).  say wha?" % (changes, suite))
 
     # The main NEW processing loop
     done = 0
     while not done:
         # Find out what's new
-        new = daklib.queue.determine_new(changes, files, projectB)
+        new = queue.determine_new(changes, files, projectB)
 
         if not new:
             break
@@ -644,8 +660,8 @@ def do_new():
         prompt += "Edit overrides, Check, Manual reject, Note edit, Prod, [S]kip, Quit ?"
 
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.search(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.search(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
@@ -666,12 +682,13 @@ def do_new():
         elif answer == 'P':
             prod_maintainer()
         elif answer == 'R':
-            confirm = daklib.utils.our_raw_input("Really clear note (y/N)? ").lower()
+            confirm = utils.our_raw_input("Really clear note (y/N)? ").lower()
             if confirm == "y":
                 del changes["process-new note"]
         elif answer == 'S':
             done = 1
         elif answer == 'Q':
+            end()
             sys.exit(0)
 
 ################################################################################
@@ -682,6 +699,7 @@ def usage (exit_code=0):
     print """Usage: dak process-new [OPTION]... [CHANGES]...
   -a, --automatic           automatic run
   -h, --help                show this help and exit.
+  -C, --comments-dir=DIR    use DIR as comments-dir, for [o-]p-u-new
   -m, --manual-reject=MSG   manual reject with `msg'
   -n, --no-action           don't do anything
   -V, --version             display the version number and exit"""
@@ -692,11 +710,11 @@ def usage (exit_code=0):
 def init():
     global Cnf, Options, Logger, Upload, projectB, Sections, Priorities
 
-    Cnf = daklib.utils.get_conf()
+    Cnf = utils.get_conf()
 
     Arguments = [('a',"automatic","Process-New::Options::Automatic"),
                  ('h',"help","Process-New::Options::Help"),
-		 ('C',"comments-dir","Process-New::Options::Comments-Dir", "HasArg"),
+                 ('C',"comments-dir","Process-New::Options::Comments-Dir", "HasArg"),
                  ('m',"manual-reject","Process-New::Options::Manual-Reject", "HasArg"),
                  ('n',"no-action","Process-New::Options::No-Action")]
 
@@ -710,10 +728,10 @@ def init():
     if Options["Help"]:
         usage()
 
-    Upload = daklib.queue.Upload(Cnf)
+    Upload = queue.Upload(Cnf)
 
     if not Options["No-Action"]:
-        Logger = Upload.Logger = daklib.logging.Logger(Cnf, "process-new")
+        Logger = Upload.Logger = logging.Logger(Cnf, "process-new")
 
     projectB = Upload.projectB
 
@@ -732,13 +750,13 @@ def do_byhand():
         will_install = 1
         byhand = []
 
-        for file in files.keys():
-            if files[file]["type"] == "byhand":
-                if os.path.exists(file):
-                    print "W: %s still present; please process byhand components and try again." % (file)
+        for f in files.keys():
+            if files[f]["type"] == "byhand":
+                if os.path.exists(f):
+                    print "W: %s still present; please process byhand components and try again." % (f)
                     will_install = 0
                 else:
-                    byhand.append(file)
+                    byhand.append(f)
 
         answer = "XXXX"
         if Options["No-Action"]:
@@ -751,16 +769,16 @@ def do_byhand():
             prompt = "Manual reject, [S]kip, Quit ?"
 
         while prompt.find(answer) == -1:
-            answer = daklib.utils.our_raw_input(prompt)
-            m = daklib.queue.re_default_answer.search(prompt)
+            answer = utils.our_raw_input(prompt)
+            m = queue.re_default_answer.search(prompt)
             if answer == "":
                 answer = m.group(1)
             answer = answer[:1].upper()
 
         if answer == 'A':
             done = 1
-            for file in byhand:
-                del files[file]
+            for f in byhand:
+                del files[f]
         elif answer == 'M':
             Upload.do_reject(1, Options["Manual-Reject"])
             os.unlink(Upload.pkg.changes_file[:-8]+".dak")
@@ -768,39 +786,142 @@ def do_byhand():
         elif answer == 'S':
             done = 1
         elif answer == 'Q':
+            end()
             sys.exit(0)
 
 ################################################################################
 
+def get_accept_lock():
+    retry = 0
+    while retry < 10:
+        try:
+            os.open(Cnf["Process-New::AcceptedLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
+            retry = 10
+        except OSError, e:
+            if e.errno == errno.EACCES or e.errno == errno.EEXIST:
+                retry += 1
+                if (retry >= 10):
+                    utils.fubar("Couldn't obtain lock; assuming 'dak process-unchecked' is already running.")
+                else:
+                    print("Unable to get accepted lock (try %d of 10)" % retry)
+                time.sleep(60)
+            else:
+                raise
+
+def move_to_dir (dest, perms=0660, changesperms=0664):
+    utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
+    file_keys = Upload.pkg.files.keys()
+    for f in file_keys:
+        utils.move (f, dest, perms=perms)
+
+def is_source_in_queue_dir(qdir):
+    entries = [ x for x in os.listdir(qdir) if x.startswith(Upload.pkg.changes["source"])
+                and x.endswith(".changes") ]
+    for entry in entries:
+        # read the .dak
+        u = queue.Upload(Cnf)
+        u.pkg.changes_file = os.path.join(qdir, entry)
+        u.update_vars()
+        if not u.pkg.changes["architecture"].has_key("source"):
+            # another binary upload, ignore
+            continue
+        if Upload.pkg.changes["version"] != u.pkg.changes["version"]:
+            # another version, ignore
+            continue
+        # found it!
+        return True
+    return False
+
+def move_to_holding(suite, queue_dir):
+    print "Moving to %s holding area." % (suite.upper(),)
+    if Options["No-Action"]:
+    	return
+    Logger.log(["Moving to %s" % (suite,), Upload.pkg.changes_file])
+    Upload.dump_vars(queue_dir)
+    move_to_dir(queue_dir)
+    os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+
+def _accept():
+    if Options["No-Action"]:
+        return
+    (summary, short_summary) = Upload.build_summaries()
+    Upload.accept(summary, short_summary)
+    os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+
+def do_accept_stableupdate(suite, q):
+    queue_dir = Cnf["Dir::Queue::%s" % (q,)]
+    if not Upload.pkg.changes["architecture"].has_key("source"):
+        # It is not a sourceful upload.  So its source may be either in p-u
+        # holding, in new, in accepted or already installed.
+        if is_source_in_queue_dir(queue_dir):
+            # It's in p-u holding, so move it there.
+            print "Binary-only upload, source in %s." % (q,)
+            move_to_holding(suite, queue_dir)
+        elif Upload.source_exists(Upload.pkg.changes["source"],
+                Upload.pkg.changes["version"]):
+            # dak tells us that there is source available.  At time of
+            # writing this means that it is installed, so put it into
+            # accepted.
+            print "Binary-only upload, source installed."
+            _accept()
+        elif is_source_in_queue_dir(Cnf["Dir::Queue::Accepted"]):
+            # The source is in accepted, the binary cleared NEW: accept it.
+            print "Binary-only upload, source in accepted."
+            _accept()
+        elif is_source_in_queue_dir(Cnf["Dir::Queue::New"]):
+            # It's in NEW.  We expect the source to land in p-u holding
+            # pretty soon.
+            print "Binary-only upload, source in new."
+            move_to_holding(suite, queue_dir)
+        else:
+            # No case applicable.  Bail out.  Return will cause the upload
+            # to be skipped.
+            print "ERROR"
+            print "Stable update failed.  Source not found."
+            return
+    else:
+        # We are handling a sourceful upload.  Move to accepted if currently
+        # in p-u holding and to p-u holding otherwise.
+        if is_source_in_queue_dir(queue_dir):
+            print "Sourceful upload in %s, accepting." % (q,)
+            _accept()
+        else:
+            move_to_holding(suite, queue_dir)
+
 def do_accept():
     print "ACCEPT"
     if not Options["No-Action"]:
-        retry = 0
-	while retry < 10:
-	    try:
-		lock_fd = os.open(Cnf["Process-New::AcceptedLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
-                retry = 10
-	    except OSError, e:
-		if errno.errorcode[e.errno] == 'EACCES' or errno.errorcode[e.errno] == 'EEXIST':
-		    retry += 1
-		    if (retry >= 10):
-			daklib.utils.fubar("Couldn't obtain lock; assuming 'dak process-unchecked' is already running.")
-		    else:
-			print("Unable to get accepted lock (try %d of 10)" % retry)
-		    time.sleep(60)
-		else:
-		    raise
+        get_accept_lock()
         (summary, short_summary) = Upload.build_summaries()
-        Upload.accept(summary, short_summary)
-        os.unlink(Upload.pkg.changes_file[:-8]+".dak")
-	os.unlink(Cnf["Process-New::AcceptedLockFile"])
+    try:
+        if Cnf.FindB("Dinstall::SecurityQueueHandling"):
+            Upload.dump_vars(Cnf["Dir::Queue::Embargoed"])
+            move_to_dir(Cnf["Dir::Queue::Embargoed"])
+            Upload.queue_build("embargoed", Cnf["Dir::Queue::Embargoed"])
+            # Check for override disparities
+            Upload.Subst["__SUMMARY__"] = summary
+        else:
+            # Stable updates need to be copied to proposed-updates holding
+            # area instead of accepted.  Sourceful uploads need to go
+            # to it directly, binaries only if the source has not yet been
+            # accepted into p-u.
+            for suite, q in [("proposed-updates", "ProposedUpdates"),
+                    ("oldstable-proposed-updates", "OldProposedUpdates")]:
+                if not Upload.pkg.changes["distribution"].has_key(suite):
+                    continue
+                return do_accept_stableupdate(suite, q)
+            # Just a normal upload, accept it...
+            _accept()
+    finally:
+        if not Options["No-Action"]:
+            os.unlink(Cnf["Process-New::AcceptedLockFile"])
 
 def check_status(files):
     new = byhand = 0
-    for file in files.keys():
-        if files[file]["type"] == "byhand":
+    for f in files.keys():
+        if files[f]["type"] == "byhand":
             byhand = 1
-        elif files[file].has_key("new"):
+        elif files[f].has_key("new"):
             new = 1
     return (new, byhand)
 
@@ -835,7 +956,7 @@ def end():
         sets = "set"
         if accept_count > 1:
             sets = "sets"
-        sys.stderr.write("Accepted %d package %s, %s.\n" % (accept_count, sets, daklib.utils.size_type(int(accept_bytes))))
+        sys.stderr.write("Accepted %d package %s, %s.\n" % (accept_count, sets, utils.size_type(int(accept_bytes))))
         Logger.log(["total",accept_count,accept_bytes])
 
     if not Options["No-Action"]:
@@ -849,16 +970,16 @@ def do_comments(dir, opref, npref, line, fn):
         if len(lines) == 0 or lines[0] != line + "\n": continue
         changes_files = [ x for x in os.listdir(".") if x.startswith(comm[7:]+"_")
                                 and x.endswith(".changes") ]
-	changes_files = sort_changes(changes_files)
+        changes_files = sort_changes(changes_files)
         for f in changes_files:
-                f = daklib.utils.validate_changes_file_arg(f, 0)
-                if not f: continue
-                print "\n" + f
-                fn(f, "".join(lines[1:]))
+            f = utils.validate_changes_file_arg(f, 0)
+            if not f: continue
+            print "\n" + f
+            fn(f, "".join(lines[1:]))
 
         if opref != npref and not Options["No-Action"]:
-                newcomm = npref + comm[len(opref):]
-                os.rename("%s/%s" % (dir, comm), "%s/%s" % (dir, newcomm))
+            newcomm = npref + comm[len(opref):]
+            os.rename("%s/%s" % (dir, comm), "%s/%s" % (dir, newcomm))
 
 ################################################################################
 
@@ -883,7 +1004,6 @@ def comment_reject(changes_file, comments):
     Upload.init_vars()
     Upload.update_vars()
     Upload.update_subst()
-    files = Upload.pkg.files
 
     if not recheck():
         pass # dak has its own reasons to reject as well, which is fine
@@ -912,14 +1032,14 @@ def main():
 
     commentsdir = Cnf.get("Process-New::Options::Comments-Dir","")
     if commentsdir:
-	if changes_files != []:
-		sys.stderr.write("Can't specify any changes files if working with comments-dir")
-		sys.exit(1)
-	do_comments(commentsdir, "ACCEPT.", "ACCEPTED.", "OK", comment_accept)
-	do_comments(commentsdir, "REJECT.", "REJECTED.", "NOTOK", comment_reject)
+        if changes_files != []:
+            sys.stderr.write("Can't specify any changes files if working with comments-dir")
+            sys.exit(1)
+        do_comments(commentsdir, "ACCEPT.", "ACCEPTED.", "OK", comment_accept)
+        do_comments(commentsdir, "REJECT.", "REJECTED.", "NOTOK", comment_reject)
     else:
         for changes_file in changes_files:
-            changes_file = daklib.utils.validate_changes_file_arg(changes_file, 0)
+            changes_file = utils.validate_changes_file_arg(changes_file, 0)
             if not changes_file:
                 continue
             print "\n" + changes_file