X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=dak%2Fprocess_new.py;h=f15a56003f67ae82e5ec347328d94bdae8100125;hb=1c35448b880358d020e81339657e3435fdda9434;hp=b231543717827fe5aafbd75a41cfc2a82cebaffb;hpb=39327828e659bb8b3c34f34d95d8bbfd33b470f8;p=dak.git diff --git a/dak/process_new.py b/dak/process_new.py index b2315437..f15a5600 100755 --- a/dak/process_new.py +++ b/dak/process_new.py @@ -41,6 +41,8 @@ ################################################################################ +from __future__ import with_statement + import copy import errno import os @@ -48,14 +50,18 @@ import readline import stat import sys import time +import contextlib +import pwd import apt_pkg, apt_inst import examine_package + from daklib import database -from daklib import logging +from daklib import daklog from daklib import queue from daklib import utils from daklib.regexes import re_no_epoch, re_default_answer, re_isanum -from daklib.dak_exceptions import CantOpenError +from daklib.dak_exceptions import CantOpenError, AlreadyLockedError, CantGetLockError +from daklib.summarystats import SummaryStats # Globals Cnf = None #: Configuration, apt_pkg.Configuration @@ -97,7 +103,7 @@ def recheck(): source_epochless_version = re_no_epoch.sub('', source_version) dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version) found = 0 - for q in ["Accepted", "Embargoed", "Unembargoed"]: + for q in ["Accepted", "Embargoed", "Unembargoed", "Newstage"]: if Cnf.has_key("Dir::Queue::%s" % (q)): if os.path.exists(Cnf["Dir::Queue::%s" % (q)] + '/' + dsc_filename): found = 1 @@ -221,7 +227,7 @@ def sort_changes(changes_files): mtime = os.stat(d["filename"])[stat.ST_MTIME] if mtime < oldest: oldest = mtime - have_note += (database.has_new_comment(d["source"], d["version"])) + have_note += (database.has_new_comment(d["source"], d["version"], True)) per_source[source]["oldest"] = oldest if not have_note: per_source[source]["note_state"] = 0; # none @@ -492,7 +498,8 @@ def edit_note(note): elif answer == 'Q': end() sys.exit(0) - database.add_new_comment(Upload.pkg.changes["source"], Upload.pkg.changes["version"], newnote, utils.whoami()) + + database.add_new_comment(Upload.pkg.changes["source"], Upload.pkg.changes["version"], newnote, utils.whoami(), bool(Options["Trainee"])) ################################################################################ @@ -547,6 +554,7 @@ def do_bxa_notification(): def add_overrides (new): changes = Upload.pkg.changes files = Upload.pkg.files + srcpkg = changes.get("source") projectB.query("BEGIN WORK") for suite in changes["suite"].keys(): @@ -556,6 +564,7 @@ def add_overrides (new): type_id = database.get_override_type_id(new[pkg]["type"]) priority_id = new[pkg]["priority id"] section_id = new[pkg]["section id"] + Logger.log(["%s overrides" % (srcpkg), suite, new[pkg]["component"], new[pkg]["type"], new[pkg]["priority"], new[pkg]["section"]]) 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 f in new[pkg]["files"]: if files[f].has_key("new"): @@ -569,16 +578,21 @@ def add_overrides (new): ################################################################################ -def prod_maintainer (): +def prod_maintainer (note): # Here we prepare an editor and get them ready to prod... (fd, temp_filename) = utils.temp_filename() + temp_file = os.fdopen(fd, 'w') + if len(note) > 0: + for line in note: + temp_file.write(line) + temp_file.close() editor = os.environ.get("EDITOR","vi") answer = 'E' while answer == 'E': os.system("%s %s" % (editor, temp_filename)) - f = os.fdopen(fd) - prod_message = "".join(f.readlines()) - f.close() + temp_fh = utils.open_file(temp_filename) + prod_message = "".join(temp_fh.readlines()) + temp_fh.close() print "Prod message:" print utils.prefix_multi_line_string(prod_message," ",include_blank_lines=1) prompt = "[P]rod, Edit, Abandon, Quit ?" @@ -589,12 +603,12 @@ def prod_maintainer (): if answer == "": answer = m.group(1) answer = answer[:1].upper() - os.unlink(temp_filename) - if answer == 'A': - return - elif answer == 'Q': - end() - sys.exit(0) + os.unlink(temp_filename) + if answer == 'A': + return + elif answer == 'Q': + end() + sys.exit(0) # Otherwise, do the proding... user_email_address = utils.whoami() + " <%s>" % ( Cnf["Dinstall::MyAdminAddress"]) @@ -666,7 +680,7 @@ def do_new(): print "W: [!] marked entries must be fixed before package can be processed." if note: print "W: note must be removed before package can be processed." - prompt += "Remove note, " + prompt += "RemOve all notes, Remove note, " prompt += "Edit overrides, Check, Manual reject, Note edit, Prod, [S]kip, Quit ?" @@ -678,7 +692,13 @@ def do_new(): answer = answer[:1].upper() if answer == 'A' and not Options["Trainee"]: - done = add_overrides (new) + try: + check_daily_lock() + done = add_overrides (new) + Logger.log([utils.getusername(), "NEW ACCEPT: %s" % (Upload.pkg.changes_file)]) + except CantGetLockError: + print "Hello? Operator! Give me the number for 911!" + print "Dinstall in the locked area, cant process packages, come back later" elif answer == 'C': check_pkg() elif answer == 'E' and not Options["Trainee"]: @@ -688,16 +708,22 @@ def do_new(): reject_message=Options["Manual-Reject"], note=database.get_new_comments(changes.get("source", ""))) if not aborted: + Logger.log([utils.getusername(), "NEW REJECT: %s" % (Upload.pkg.changes_file)]) os.unlink(Upload.pkg.changes_file[:-8]+".dak") done = 1 elif answer == 'N': edit_note(database.get_new_comments(changes.get("source", ""))) elif answer == 'P' and not Options["Trainee"]: prod_maintainer(database.get_new_comments(changes.get("source", ""))) - elif answer == 'R': + Logger.log([utils.getusername(), "NEW PROD: %s" % (Upload.pkg.changes_file)]) + elif answer == 'R' and not Options["Trainee"]: confirm = utils.our_raw_input("Really clear note (y/N)? ").lower() if confirm == "y": database.delete_new_comments(changes.get("source"), changes.get("version")) + elif answer == 'O' and not Options["Trainee"]: + confirm = utils.our_raw_input("Really clear all notes (y/N)? ").lower() + if confirm == "y": + database.delete_all_new_comments(changes.get("source")) elif answer == 'S': done = 1 elif answer == 'Q': @@ -750,9 +776,9 @@ def init(): if not Options["No-Action"]: try: - Logger = Upload.Logger = logging.Logger(Cnf, "process-new") + Logger = Upload.Logger = daklog.Logger(Cnf, "process-new") except CantOpenError, e: - Options["Trainee"] = "Oh yes" + Options["Trainee"] = "True" projectB = Upload.projectB @@ -797,10 +823,17 @@ def do_byhand(): answer = answer[:1].upper() if answer == 'A': - done = 1 - for f in byhand: - del files[f] + try: + check_daily_lock() + done = 1 + for f in byhand: + del files[f] + Logger.log([utils.getusername(), "BYHAND ACCEPT: %s" % (Upload.pkg.changes_file)]) + except CantGetLockError: + print "Hello? Operator! Give me the number for 911!" + print "Dinstall in the locked area, cant process packages, come back later" elif answer == 'M': + Logger.log([utils.getusername(), "BYHAND REJECT: %s" % (Upload.pkg.changes_file)]) Upload.do_reject(1, Options["Manual-Reject"]) os.unlink(Upload.pkg.changes_file[:-8]+".dak") done = 1 @@ -812,22 +845,41 @@ def do_byhand(): ################################################################################ -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 check_daily_lock(): + """ + Raises CantGetLockError if the dinstall daily.lock exists. + """ + + try: + os.open(Cnf["Process-New::DinstallLockFile"], os.O_RDONLY | os.O_CREAT | os.O_EXCL) + except OSError, e: + if e.errno == errno.EEXIST or e.errno == errno.EACCES: + raise CantGetLockError + + os.unlink(Cnf["Process-New::DinstallLockFile"]) + + +@contextlib.contextmanager +def lock_package(package): + """ + Lock C{package} so that noone else jumps in processing it. + + @type package: string + @param package: source package name to lock + """ + + path = os.path.join(Cnf["Process-New::LockDir"], package) + try: + fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDONLY) + except OSError, e: + if e.errno == errno.EEXIST or e.errno == errno.EACCES: + user = pwd.getpwuid(os.stat(path)[stat.ST_UID])[4].split(',')[0].replace('.', '') + raise AlreadyLockedError, user + + try: + yield fd + finally: + os.unlink(path) def move_to_dir (dest, perms=0660, changesperms=0664): utils.move (Upload.pkg.changes_file, dest, perms=changesperms) @@ -866,7 +918,7 @@ def _accept(): if Options["No-Action"]: return (summary, short_summary) = Upload.build_summaries() - Upload.accept(summary, short_summary) + Upload.accept(summary, short_summary, targetdir=Cnf["Dir::Queue::Newstage"]) os.unlink(Upload.pkg.changes_file[:-8]+".dak") def do_accept_stableupdate(suite, q): @@ -884,16 +936,23 @@ def do_accept_stableupdate(suite, q): # writing this means that it is installed, so put it into # accepted. print "Binary-only upload, source installed." + Logger.log([utils.getusername(), "PUNEW ACCEPT: %s" % (Upload.pkg.changes_file)]) _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." + Logger.log([utils.getusername(), "PUNEW ACCEPT: %s" % (Upload.pkg.changes_file)]) _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) + elif is_source_in_queue_dir(Cnf["Dir::Queue::Newstage"]): + # It's in newstage. Accept into the holding area + print "Binary-only upload, source in newstage." + Logger.log([utils.getusername(), "PUNEW ACCEPT: %s" % (Upload.pkg.changes_file)]) + _accept() else: # No case applicable. Bail out. Return will cause the upload # to be skipped. @@ -912,30 +971,25 @@ def do_accept_stableupdate(suite, q): def do_accept(): print "ACCEPT" if not Options["No-Action"]: - get_accept_lock() (summary, short_summary) = Upload.build_summaries() - 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"]) + 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() def check_status(files): new = byhand = 0 @@ -953,32 +1007,41 @@ def do_pkg(changes_file): Upload.update_subst() files = Upload.pkg.files - if not recheck(): - return - - (new, byhand) = check_status(files) - if new or byhand: - if new: - do_new() - if byhand: - do_byhand() - (new, byhand) = check_status(files) - - if not new and not byhand: - do_accept() + try: + with lock_package(Upload.pkg.changes["source"]): + if not recheck(): + return + + (new, byhand) = check_status(files) + if new or byhand: + if new: + do_new() + if byhand: + do_byhand() + (new, byhand) = check_status(files) + + if not new and not byhand: + try: + check_daily_lock() + do_accept() + except CantGetLockError: + print "Hello? Operator! Give me the number for 911!" + print "Dinstall in the locked area, cant process packages, come back later" + except AlreadyLockedError, e: + print "Seems to be locked by %s already, skipping..." % (e) ################################################################################ def end(): - accept_count = Upload.accept_count - accept_bytes = Upload.accept_bytes + accept_count = SummaryStats().accept_count + accept_bytes = SummaryStats().accept_bytes if accept_count: sets = "set" if accept_count > 1: sets = "sets" 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]) + Logger.log([utils.getusername(), "total",accept_count,accept_bytes]) if not Options["No-Action"] and not Options["Trainee"]: Logger.close() @@ -1064,6 +1127,7 @@ def main(): if not changes_file: continue print "\n" + changes_file + do_pkg (changes_file) end()