#!/usr/bin/python # # buildd - command line interface for Launchpad buildd operations. # # Copyright (C) 2007 Canonical Ltd. # Authors: # - Martin Pitt <martin.pitt@canonical.com> # - Jonathan Davies <jpds@ubuntu.com> # # 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 # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # Our modules to import. import sys from optparse import OptionGroup from optparse import OptionParser import ubuntutools.lp.udtexceptions from ubuntutools.lp.lpapiwrapper import LpApiWrapper # Usage. usage = "%prog <srcpackage> <release> <operation>\n\n" usage += "Where operation may be one of: rescore, retry, or status.\n" usage += "Only Launchpad Buildd Admins may rescore package builds." # Valid architectures. validArchs = ["armel", "amd64", "hppa", "i386", "ia64", "lpia", "powerpc", "sparc"] # Prepare our option parser. optParser = OptionParser(usage) # Retry options retryRescoreOptions = OptionGroup(optParser, "Retry and rescore options", "These options may only be used with the 'retry' and 'rescore' operations.") retryRescoreOptions.add_option("-a", "--arch", type = "string", action = "store", dest = "architecture", help = "Rebuild or rescore a specific architecture. " \ "Valid architectures include: " \ "%s." % ", ".join(validArchs)) # Add the retry options to the main group. optParser.add_option_group(retryRescoreOptions) # Parse our options. (options, args) = optParser.parse_args() # 'help' called by itself - show our help. try: if args[0].lower() in ("help") and len(args) == 1: optParser.print_help() sys.exit(0) except IndexError: optParser.print_help() sys.exit(0) # Check we have the correct number of arguments. if len(args) < 3: optParser.error("Incorrect number of arguments.") try: package = str(args[0]).lower() release = str(args[1]).lower() op = str(args[2]).lower() except IndexError: optParser.print_help() sys.exit(0) # Check our operation. if op not in ("rescore", "retry", "status"): print >> sys.stderr, "Invalid operation: %s." % op sys.exit(1) # If the user has specified an architecture to build, we only wish to rebuild it # and nothing else. if op not in ("retry", 'rescore') and options.architecture: print >> sys.stderr, "Operation %s does not use the --arch option." % op sys.exit(1) elif op in ("retry", "rescore") and options.architecture: if options.architecture not in validArchs: print >> sys.stderr, "Invalid architecture specified: %s." % options.architecture sys.exit(1) else: oneArch = True else: oneArch = False # ubuntu-dev-tools modules # Import here to improve speed perception parsing options for user. import ubuntutools.lp.functions as lp_functions # split release and pocket if '-' in release: (release, pocket) = release.split('-') else: pocket = 'Release' pocket = pocket.capitalize() if pocket not in ('Release', 'Security', 'Updates', 'Proposed', 'Backports'): print 'Unknown pocket: %s' % pocket sys.exit(1) # Initialize ubuntu distribution collection. lpapiwrapper = LpApiWrapper() ubuntuDist = lpapiwrapper.getUbuntuDistribution() # Get main Ubuntu archive. archive = lpapiwrapper.getUbuntuArchive() # Check the release exists. try: release_series = lpapiwrapper.getUbuntuSeries(release) except ubuntutools.lp.udtexceptions.SeriesNotFoundException, e: print e sys.exit(1) # Get list of published sources for package in question. sources = lpapiwrapper.getUbuntuSourcePackage(package, release, pocket) # Get list of builds for that package. builds = sources.getBuilds() # Find out the version in given release. version = sources.source_package_version # Get the component the package is in. component = sources.component_name # Operations that are remaining may only be done by Ubuntu developers (retry) # or buildd admins (rescore). Check if the proper permissions are in place. if op == "rescore": necessaryPrivs = lp_functions.isLPTeamMember('launchpad-buildd-admins') if op == "retry": necessaryPrivs = lp_functions.canUploadPackage(package, release) if op in ('rescore', 'retry') and not necessaryPrivs: print >> sys.stderr, "You cannot perform the %s operation on a %s package " \ "as you do not have the permissions to do this action." % (op, component) sys.exit(1) # Output details. print "The source version for '%s' in %s (%s) is at %s." % (package, release.capitalize(), component, version) print "Current build status for this package:" # Output list of arches for package and their status. done = False for build in builds: if oneArch and build.arch_tag != options.archictecture: # Skip this architecture. continue done = True print "%s: %s." % (build.arch_tag, build.buildstate) if op == 'rescore': if build.can_be_rescored: # FIXME: make priority an option priority = 5000 print 'Rescoring build %s to %d...' % (build.arch_tag, priority) build.rescore(score = priority) else: print 'Cannot rescore build on %s.' % build.arch_tag if op == 'retry': if build.can_be_retried: print 'Retrying build on %s...' % build.arch_tag build.retry() else: print 'Cannot retry build on %s.' % build.arch_tag # We are done if done: sys.exit(0) print "No builds for '%s' found in the %s release - it may have been " \ "built in a former release." % (package, release.capitalize()) sys.exit(0)