X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=dak%2Fprocess_new.py;h=9ed65cc568cf90d5bdb34e39251f1f0ae4e8b307;hb=e58293b290b33e0033491fce6afc5645e5748d93;hp=37a902aeb27e74310cad5bf4d386967a99d8d257;hpb=06b17e68fd4a76e7a12f741f26654e55bff05c79;p=dak.git

diff --git a/dak/process_new.py b/dak/process_new.py
old mode 100644
new mode 100755
index 37a902ae..9ed65cc5
--- a/dak/process_new.py
+++ b/dak/process_new.py
@@ -39,10 +39,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,18 +70,18 @@ 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)
                 found = 0
                 for q in ["Accepted", "Embargoed", "Unembargoed"]:
@@ -89,14 +89,14 @@ def recheck():
                         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, file))
+                    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:
@@ -108,8 +108,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()
@@ -151,7 +151,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"]
@@ -159,6 +159,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"])
@@ -193,6 +197,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]
@@ -262,7 +269,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():
@@ -301,17 +308,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)
@@ -325,16 +332,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
 
@@ -343,21 +350,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()
@@ -376,7 +383,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:
@@ -388,7 +395,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:
@@ -398,9 +405,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
@@ -422,12 +429,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))
@@ -447,24 +454,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()
@@ -487,23 +494,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
 
 ################################################################################
@@ -513,15 +520,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)
 
 ################################################################################
 
@@ -531,16 +538,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")
@@ -552,21 +559,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()
@@ -577,7 +584,7 @@ def prod_maintainer ():
             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
@@ -586,12 +593,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"
 
@@ -609,8 +616,8 @@ 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)
+            (olderr, newerr) = (database.get_suite_id(suite) == -1,
+              database.get_suite_id(override) == -1)
             if olderr or newerr:
                 (oinv, newinv) = ("", "")
                 if olderr: oinv = "invalid "
@@ -621,15 +628,15 @@ def do_new():
             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
@@ -652,8 +659,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()
@@ -674,7 +681,7 @@ 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':
@@ -702,7 +709,7 @@ 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"),
@@ -720,10 +727,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
 
@@ -742,13 +749,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"]:
@@ -761,16 +768,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")
@@ -787,13 +794,13 @@ def get_accept_lock():
     retry = 0
     while retry < 10:
         try:
-            lock_fd = os.open(Cnf["Process-New::AcceptedLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL)
+            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':
+            if e.errno == errno.EACCES or e.errno == errno.EEXIST:
                 retry += 1
                 if (retry >= 10):
-                    daklib.utils.fubar("Couldn't obtain lock; assuming 'dak process-unchecked' is already running.")
+                    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)
@@ -801,33 +808,96 @@ def get_accept_lock():
                 raise
 
 def move_to_dir (dest, perms=0660, changesperms=0664):
-    daklib.utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
+    utils.move (Upload.pkg.changes_file, dest, perms=changesperms)
     file_keys = Upload.pkg.files.keys()
-    for file in file_keys:
-        daklib.utils.move (file, dest, perms=perms)
+    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 = entry
+        u.update_vars()
+        if not 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(),)
+    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 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_qdir(queue_dir):
+            # It's in p-u holding, so move it there.
+            move_to_holding(suite, queue_dir)
+        elif is_source_in_qdir(Cnf["Dir::Queue::New"]):
+            # It's in NEW.  We expect the source to land in p-u holding
+            # pretty soon.
+            move_to_holding(suite, queue_dir)
+        elif is_source_in_qdir(Cnf["Dir::Queue::Accepted"]):
+            # The source is in accepted, the binary cleared NEW: accept it.
+            Upload.accept(summary, short_summary)
+            os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+        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.
+            Upload.accept(summary, short_summary)
+            os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+	return
+    move_to_holding(suite, queue_dir)
 
 def do_accept():
     print "ACCEPT"
     if not Options["No-Action"]:
         get_accept_lock()
         (summary, short_summary) = Upload.build_summaries()
-    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:
-        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...
+            Upload.accept(summary, short_summary)
+            os.unlink(Upload.pkg.changes_file[:-8]+".dak")
+    finally:
+        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)
 
@@ -862,7 +932,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"]:
@@ -878,7 +948,7 @@ def do_comments(dir, opref, npref, line, fn):
                                 and x.endswith(".changes") ]
         changes_files = sort_changes(changes_files)
         for f in changes_files:
-            f = daklib.utils.validate_changes_file_arg(f, 0)
+            f = utils.validate_changes_file_arg(f, 0)
             if not f: continue
             print "\n" + f
             fn(f, "".join(lines[1:]))
@@ -910,7 +980,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
@@ -946,7 +1015,7 @@ def main():
         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