X-Git-Url: https://git.decadent.org.uk/gitweb/?p=dak.git;a=blobdiff_plain;f=dak%2Ftransitions.py;h=68c65b6a070bf9dbe84d3f8a664c95ccd89572d0;hp=374beabbb9967a24a36a9616f474977c47b9dece;hb=0d69fff35ef45fda573467873ae2f01ca1954650;hpb=1408d82381556c9e2b3eaa04412846c766a011db diff --git a/dak/transitions.py b/dak/transitions.py old mode 100644 new mode 100755 index 374beabb..68c65b6a --- a/dak/transitions.py +++ b/dak/transitions.py @@ -1,7 +1,12 @@ #!/usr/bin/env python -# Display, edit and check the release manager's transition file. -# Copyright (C) 2008 Joerg Jaspert +""" +Display, edit and check the release manager's transition file. + +@contact: Debian FTP Master +@copyright: 2008 Joerg Jaspert +@license: GNU General Public License version 2 or later +""" # 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 @@ -23,18 +28,23 @@ ################################################################################ -import os, pg, sys, time, errno, fcntl, tempfile, pwd, re +import os +import sys +import time +import errno +import fcntl +import tempfile import apt_pkg -import daklib.database -import daklib.utils -import syck -# Globals -Cnf = None -Options = None -projectB = None +from daklib.dbconn import * +from daklib import utils +from daklib.dak_exceptions import TransitionsError +from daklib.regexes import re_broken_package +import yaml -re_broken_package = re.compile(r"[a-zA-Z]\w+\s+\-.*") +# Globals +Cnf = None #: Configuration, apt_pkg.Configuration +Options = None #: Parsed CommandLine arguments ################################################################################ @@ -42,39 +52,44 @@ re_broken_package = re.compile(r"[a-zA-Z]\w+\s+\-.*") #### This may run within sudo !! #### ##################################### def init(): - global Cnf, Options, projectB + """ + Initialize. Sets up database connection, parses commandline arguments. + + @attention: This function may run B{within sudo} + + """ + global Cnf, Options apt_pkg.init() - Cnf = daklib.utils.get_conf() + Cnf = utils.get_conf() - Arguments = [('h',"help","Edit-Transitions::Options::Help"), + Arguments = [('a',"automatic","Edit-Transitions::Options::Automatic"), + ('h',"help","Edit-Transitions::Options::Help"), ('e',"edit","Edit-Transitions::Options::Edit"), ('i',"import","Edit-Transitions::Options::Import", "HasArg"), ('c',"check","Edit-Transitions::Options::Check"), ('s',"sudo","Edit-Transitions::Options::Sudo"), ('n',"no-action","Edit-Transitions::Options::No-Action")] - for i in ["help", "no-action", "edit", "import", "check", "sudo"]: + for i in ["automatic", "help", "no-action", "edit", "import", "check", "sudo"]: if not Cnf.has_key("Edit-Transitions::Options::%s" % (i)): Cnf["Edit-Transitions::Options::%s" % (i)] = "" - apt_pkg.ParseCommandLine(Cnf, Arguments, sys.argv) + apt_pkg.parse_commandline(Cnf, Arguments, sys.argv) - Options = Cnf.SubTree("Edit-Transitions::Options") + Options = Cnf.subtree("Edit-Transitions::Options") if Options["help"]: usage() - whoami = os.getuid() - whoamifull = pwd.getpwuid(whoami) - username = whoamifull[0] + username = utils.getusername() if username != "dak": print "Non-dak user: %s" % username Options["sudo"] = "y" - projectB = pg.connect(Cnf["DB::Name"], Cnf["DB::Host"], int(Cnf["DB::Port"])) - daklib.database.init(Cnf, projectB) + # Initialise DB connection + DBConn() ################################################################################ @@ -89,6 +104,7 @@ Options: -i, --import check and import transitions from file -c, --check check the transitions file, remove outdated entries -S, --sudo use sudo to update transitions file + -a, --automatic don't prompt (only affects check). -n, --no-action don't do anything (only affects check)""" sys.exit(exit_code) @@ -99,15 +115,29 @@ Options: #### This may run within sudo !! #### ##################################### def load_transitions(trans_file): + """ + Parse a transition yaml file and check it for validity. + + @attention: This function may run B{within sudo} + + @type trans_file: string + @param trans_file: filename to parse + + @rtype: dict or None + @return: validated dictionary of transition entries or None + if validation fails, empty string if reading C{trans_file} + returned something else than a dict + + """ # Parse the yaml file sourcefile = file(trans_file, 'r') sourcecontent = sourcefile.read() failure = False try: - trans = syck.load(sourcecontent) - except syck.error, msg: + trans = yaml.safe_load(sourcecontent) + except yaml.YAMLError as exc: # Someone fucked it up - print "ERROR: %s" % (msg) + print "ERROR: %s" % (exc) return None # lets do further validation here @@ -184,12 +214,18 @@ def load_transitions(trans_file): #### This may run within sudo !! #### ##################################### def lock_file(f): + """ + Lock a file + + @attention: This function may run B{within sudo} + + """ for retry in range(10): lock_fd = os.open(f, os.O_RDWR | os.O_CREAT) try: fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) return lock_fd - except OSError, e: + except OSError as e: if errno.errorcode[e.errno] == 'EACCES' or errno.errorcode[e.errno] == 'EEXIST': print "Unable to get lock for %s (try %d of 10)" % \ (file, retry+1) @@ -197,7 +233,7 @@ def lock_file(f): else: raise - daklib.utils.fubar("Couldn't obtain lock for %s." % (f)) + utils.fubar("Couldn't obtain lock for %s." % (f)) ################################################################################ @@ -205,20 +241,28 @@ def lock_file(f): #### This may run within sudo !! #### ##################################### def write_transitions(from_trans): - """Update the active transitions file safely. - This function takes a parsed input file (which avoids invalid - files or files that may be be modified while the function is - active), and ensure the transitions file is updated atomically - to avoid locks.""" + """ + Update the active transitions file safely. + This function takes a parsed input file (which avoids invalid + files or files that may be be modified while the function is + active) and ensure the transitions file is updated atomically + to avoid locks. - trans_file = Cnf["Dinstall::Reject::ReleaseTransitions"] + @attention: This function may run B{within sudo} + + @type from_trans: dict + @param from_trans: transitions dictionary, as returned by L{load_transitions} + + """ + + trans_file = Cnf["Dinstall::ReleaseTransitions"] trans_temp = trans_file + ".tmp" trans_lock = lock_file(trans_file) temp_lock = lock_file(trans_temp) destfile = file(trans_temp, 'w') - syck.dump(from_trans, destfile) + yaml.safe_dump(from_trans, destfile, default_flow_style=False) destfile.close() os.rename(trans_temp, trans_file) @@ -227,19 +271,24 @@ def write_transitions(from_trans): ################################################################################ -class ParseException(Exception): - pass - ########################################## #### This usually runs within sudo !! #### ########################################## def write_transitions_from_file(from_file): - """We have a file we think is valid; if we're using sudo, we invoke it - here, otherwise we just parse the file and call write_transitions""" + """ + We have a file we think is valid; if we're using sudo, we invoke it + here, otherwise we just parse the file and call write_transitions + + @attention: This function usually runs B{within sudo} + + @type from_file: filename + @param from_file: filename of a transitions file + + """ # Lets check if from_file is in the directory we expect it to be in - if not os.path.abspath(from_file).startswith(Cnf["Transitions::TempPath"]): - print "Will not accept transitions file outside of %s" % (Cnf["Transitions::TempPath"]) + if not os.path.abspath(from_file).startswith(Cnf["Dir::TempPath"]): + print "Will not accept transitions file outside of %s" % (Cnf["Dir::TempPath"]) sys.exit(3) if Options["sudo"]: @@ -248,26 +297,38 @@ def write_transitions_from_file(from_file): else: trans = load_transitions(from_file) if trans is None: - raise ParseException, "Unparsable transitions file %s" % (file) + raise TransitionsError("Unparsable transitions file %s" % (file)) write_transitions(trans) ################################################################################ def temp_transitions_file(transitions): - # NB: file is unlinked by caller, but fd is never actually closed. - # We need the chmod, as the file is (most possibly) copied from a - # sudo-ed script and would be unreadable if it has default mkstemp mode + """ + Open a temporary file and dump the current transitions into it, so users + can edit them. + + @type transitions: dict + @param transitions: current defined transitions + + @rtype: string + @return: path of newly created tempfile + + @note: NB: file is unlinked by caller, but fd is never actually closed. + We need the chmod, as the file is (most possibly) copied from a + sudo-ed script and would be unreadable if it has default mkstemp mode + """ - (fd, path) = tempfile.mkstemp("", "transitions", Cnf["Transitions::TempPath"]) - os.chmod(path, 0644) + (fd, path) = tempfile.mkstemp("", "transitions", Cnf["Dir::TempPath"]) + os.chmod(path, 0o644) f = open(path, "w") - syck.dump(transitions, f) + yaml.safe_dump(transitions, f, default_flow_style=False) return path ################################################################################ def edit_transitions(): - trans_file = Cnf["Dinstall::Reject::ReleaseTransitions"] + """ Edit the defined transitions. """ + trans_file = Cnf["Dinstall::ReleaseTransitions"] edit_file = temp_transitions_file(load_transitions(trans_file)) editor = os.environ.get("EDITOR", "vi") @@ -276,7 +337,7 @@ def edit_transitions(): result = os.system("%s %s" % (editor, edit_file)) if result != 0: os.unlink(edit_file) - daklib.utils.fubar("%s invocation failed for %s, not removing tempfile." % (editor, edit_file)) + utils.fubar("%s invocation failed for %s, not removing tempfile." % (editor, edit_file)) # Now try to load the new file test = load_transitions(edit_file) @@ -297,7 +358,7 @@ def edit_transitions(): answer = "XXX" while prompt.find(answer) == -1: - answer = daklib.utils.our_raw_input(prompt) + answer = utils.our_raw_input(prompt) if answer == "": answer = default answer = answer[:1].upper() @@ -324,24 +385,37 @@ def edit_transitions(): ################################################################################ def check_transitions(transitions): + """ + Check if the defined transitions still apply and remove those that no longer do. + @note: Asks the user for confirmation first unless -a has been set. + + """ + global Cnf + to_dump = 0 to_remove = [] + info = {} + + session = DBConn().session() + # Now look through all defined transitions for trans in transitions: t = transitions[trans] source = t["source"] expected = t["new"] - # Will be None if nothing is in testing. - current = daklib.database.get_suite_version(source, "testing") + # Will be an empty list if nothing is in testing. + sourceobj = get_source_in_suite(source, "testing", session) - print_info(trans, source, expected, t["rm"], t["reason"], t["packages"]) + info[trans] = get_info(trans, source, expected, t["rm"], t["reason"], t["packages"]) + print info[trans] - if current == None: + if sourceobj is None: # No package in testing print "Transition source %s not in testing, transition still ongoing." % (source) else: - compare = apt_pkg.VersionCompare(current, expected) + current = sourceobj.version + compare = apt_pkg.version_compare(current, expected) if compare < 0: # This is still valid, the current version in database is older than # the new version we wait for @@ -364,8 +438,10 @@ def check_transitions(transitions): if Options["no-action"]: answer="n" + elif Options["automatic"]: + answer="y" else: - answer = daklib.utils.our_raw_input(prompt).lower() + answer = utils.our_raw_input(prompt).lower() if answer == "": answer = "n" @@ -375,9 +451,26 @@ def check_transitions(transitions): sys.exit(0) elif answer == 'y': print "Committing" - for remove in to_remove: + subst = {} + subst['__SUBJECT__'] = "Transitions completed: " + ", ".join(sorted(to_remove)) + subst['__TRANSITION_MESSAGE__'] = "The following transitions were removed:\n" + for remove in sorted(to_remove): + subst['__TRANSITION_MESSAGE__'] += info[remove] + '\n' del transitions[remove] + # If we have a mail address configured for transitions, + # send a notification + subst['__TRANSITION_EMAIL__'] = Cnf.get("Transitions::Notifications", "") + if subst['__TRANSITION_EMAIL__'] != "": + print "Sending notification to %s" % subst['__TRANSITION_EMAIL__'] + subst['__DAK_ADDRESS__'] = Cnf["Dinstall::MyEmailAddress"] + subst['__BCC__'] = 'X-DAK: dak transitions' + if Cnf.has_key("Dinstall::Bcc"): + subst["__BCC__"] += '\nBcc: %s' % Cnf["Dinstall::Bcc"] + message = utils.TemplateSubst(subst, + os.path.join(Cnf["Dir::Templates"], 'transition.removed')) + utils.send_mail(message) + edit_file = temp_transitions_file(transitions) write_transitions_from_file(edit_file) @@ -388,47 +481,85 @@ def check_transitions(transitions): ################################################################################ -def print_info(trans, source, expected, rm, reason, packages): - print """Looking at transition: %s +def get_info(trans, source, expected, rm, reason, packages): + """ + Print information about a single transition. + + @type trans: string + @param trans: Transition name + + @type source: string + @param source: Source package + + @type expected: string + @param expected: Expected version in testing + + @type rm: string + @param rm: Responsible RM + + @type reason: string + @param reason: Reason + + @type packages: list + @param packages: list of blocked packages + + """ + return """Looking at transition: %s Source: %s New Version: %s Responsible: %s Description: %s Blocked Packages (total: %d): %s """ % (trans, source, expected, rm, reason, len(packages), ", ".join(packages)) - return ################################################################################ def transition_info(transitions): + """ + Print information about all defined transitions. + Calls L{get_info} for every transition and then tells user if the transition is + still ongoing or if the expected version already hit testing. + + @type transitions: dict + @param transitions: defined transitions + """ + + session = DBConn().session() + for trans in transitions: t = transitions[trans] source = t["source"] expected = t["new"] # Will be None if nothing is in testing. - current = daklib.database.get_suite_version(source, "testing") + sourceobj = get_source_in_suite(source, "testing", session) - print_info(trans, source, expected, t["rm"], t["reason"], t["packages"]) + print get_info(trans, source, expected, t["rm"], t["reason"], t["packages"]) - if current == None: + if sourceobj is None: # No package in testing print "Transition source %s not in testing, transition still ongoing." % (source) else: - compare = apt_pkg.VersionCompare(current, expected) + compare = apt_pkg.version_compare(sourceobj.version, expected) print "Apt compare says: %s" % (compare) if compare < 0: # This is still valid, the current version in database is older than # the new version we wait for - print "This transition is still ongoing, we currently have version %s" % (current) + print "This transition is still ongoing, we currently have version %s" % (sourceobj.version) else: print "This transition is over, the target package reached testing, should be removed" - print "%s wanted version: %s, has %s" % (source, expected, current) + print "%s wanted version: %s, has %s" % (source, expected, sourceobj.version) print "-------------------------------------------------------------------------" ################################################################################ def main(): + """ + Prepare the work to be done, do basic checks. + + @attention: This function may run B{within sudo} + + """ global Cnf ##################################### @@ -437,28 +568,28 @@ def main(): init() # Check if there is a file defined (and existant) - transpath = Cnf.get("Dinstall::Reject::ReleaseTransitions", "") + transpath = Cnf.get("Dinstall::ReleaseTransitions", "") if transpath == "": - daklib.utils.warn("Dinstall::Reject::ReleaseTransitions not defined") + utils.warn("Dinstall::ReleaseTransitions not defined") sys.exit(1) if not os.path.exists(transpath): - daklib.utils.warn("ReleaseTransitions file, %s, not found." % - (Cnf["Dinstall::Reject::ReleaseTransitions"])) + utils.warn("ReleaseTransitions file, %s, not found." % + (Cnf["Dinstall::ReleaseTransitions"])) sys.exit(1) # Also check if our temp directory is defined and existant - temppath = Cnf.get("Transitions::TempPath", "") + temppath = Cnf.get("Dir::TempPath", "") if temppath == "": - daklib.utils.warn("Transitions::TempPath not defined") + utils.warn("Dir::TempPath not defined") sys.exit(1) if not os.path.exists(temppath): - daklib.utils.warn("Temporary path %s not found." % - (Cnf["Transitions::TempPath"])) + utils.warn("Temporary path %s not found." % + (Cnf["Dir::TempPath"])) sys.exit(1) if Options["import"]: try: write_transitions_from_file(Options["import"]) - except ParseException, m: + except TransitionsError as m: print m sys.exit(2) sys.exit(0) @@ -470,7 +601,7 @@ def main(): transitions = load_transitions(transpath) if transitions == None: # Something very broken with the transitions, exit - daklib.utils.warn("Could not parse existing transitions file. Aborting.") + utils.warn("Could not parse existing transitions file. Aborting.") sys.exit(2) if Options["edit"]: