ubuntu-dev-tools/ubuntu-build

#!/usr/bin/python
#
#   ubuntu-build - command line interface for Launchpad buildd operations.
#
#   Copyright (C) 2007 Canonical Ltd.
#   Authors:
#    - Martin Pitt <martin.pitt@canonical.com>
#    - Jonathan Davies <jpds@ubuntu.com>
#    - Michael Bienia <geser@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
from ubuntutools.lp.udtexceptions import (SeriesNotFoundException,
        PackageNotFoundException, PocketDoesNotExistError,)
from ubuntutools.lp.lpapicache import Distribution, PersonTeam
from ubuntutools.misc import splitReleasePocket

# 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.
valid_archs =  set(["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 = "append", dest = "architecture",
    help = "Rebuild or rescore a specific architecture. " \
        "Valid architectures include: " \
        "%s." % ", ".join(valid_archs))

# Batch processing options
batch_options = OptionGroup(
	optParser, "Batch processing",
	"These options and parameter ordering is only available in --batch mode.\n"
	"Usage: ubuntu-build --batch [options] <package>...")
batch_options.add_option(
	'--batch', action = 'store_true', dest = 'batch', default = False,
	help = 'Enable batch mode')
batch_options.add_option(
	'--series', action = 'store', dest = 'series', type = 'string',
	help = 'Selects the Ubuntu series to operate on (default: current development series)')
batch_options.add_option(
	'--retry', action = 'store_true', dest = 'retry', default = False,
	help = 'Retry builds (give-back).')
batch_options.add_option(
	'--rescore', action = 'store', dest = 'priority', type = 'int',
	help = 'Rescore builds to <priority>.')
batch_options.add_option(
	'--arch2', action = 'append', dest = 'architecture', type = 'string',
	help = "Affect only 'architecture' (can be used several times). "
        "Valid architectures are: %s." % ', '.join(valid_archs))

# Add the retry options to the main group.
optParser.add_option_group(retryRescoreOptions)
# Add the batch mode to the main group.
optParser.add_option_group(batch_options)

# Parse our options.
(options, args) = optParser.parse_args()

if not len(args):
	optParser.print_help()
	sys.exit(1)

if not options.batch:
	# 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(1)

	# 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 options.architecture:
	    if options.architecture[0] not in valid_archs:
		print >> sys.stderr, "Invalid architecture specified: %s." % options.architecture[0]
		sys.exit(1)
	    else:
		oneArch = True
	else:
	    oneArch = False

	# split release and pocket
	try:
		(release, pocket) = splitReleasePocket(release)
	except PocketDoesNotExistError, e:
		print 'E: %s' % e
		sys.exit(1)

	# Get the ubuntu archive
	try:
		ubuntu_archive = Distribution('ubuntu').getArchive()
	# Will fail here if we have no credentials, bail out
	except IOError:
		sys.exit(1)
	# Get list of published sources for package in question.
	try:
		sources = ubuntu_archive.getSourcePackage(package, release, pocket)
		distroseries = Distribution('ubuntu').getSeries(release)
	except (SeriesNotFoundException, PackageNotFoundException), e:
	    print e
	    sys.exit(1)
	# Get list of builds for that package.
	builds = sources.getBuilds()

	# Find out the version and component in given release.
	version = sources.getVersion()
	component = sources.getComponent()

	# Operations that are remaining may only be done by Ubuntu developers (retry)
	# or buildd admins (rescore). Check if the proper permissions are in place.
	me = PersonTeam.me
	if op == "rescore": necessaryPrivs = me.isLpTeamMember('launchpad-buildd-admins')
	if op == "retry": necessaryPrivs = me.canUploadPackage(
		ubuntu_archive, distroseries, sources.getPackageName(), sources.getComponent())

	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.architecture[0]:
		# 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)

# Batch mode

if not options.architecture:
	# no specific architectures specified, assume all valid ones
	archs = valid_archs
else:
	archs = set(options.architecture)

# filter out duplicate and invalid architectures
archs.intersection_update(valid_archs)

release = options.series or Distribution('ubuntu').getDevelopmentSeries().name
try:
    (release, pocket) = splitReleasePocket(release)
except PocketDoesNotExistError, e:
    print 'E: %s' % e
    sys.exit(1)

ubuntu_archive = Distribution('ubuntu').getArchive()
try:
	distroseries = Distribution('ubuntu').getSeries(release)
except SeriesNotFoundException, e:
	print e
	sys.exit(1)
me = PersonTeam.me

# Check permisions (part 1): Rescoring can only be done by buildd admins
can_rescore = options.priority and me.isLpTeamMember('launchpad-buildd-admins') or False
if options.priority and not can_rescore:
	print >> sys.stderr, "You don't have the permissions to rescore builds. Ignoring your rescore request."

for pkg in args:
	try:
		pkg = ubuntu_archive.getSourcePackage(pkg, release, pocket)
	except PackageNotFoundException, e:
		print e
		continue

	# Check permissions (part 2): check upload permissions for the source package
	can_retry = options.retry and me.canUploadPackage(ubuntu_archive, distroseries, pkg.getPackageName(), pkg.getComponent())
	if options.retry and not can_retry:
		print >> sys.stderr, "You don't have the permissions to retry the build of '%s'. Ignoring your request." % pkg.getPackageName()

	print "The source version for '%s' in '%s' (%s) is: %s" % (
			pkg.getPackageName(), release, pocket, pkg.getVersion())

	print pkg.getBuildStates(archs)
	if can_retry:
		print pkg.retryBuilds(archs)
	if options.priority and can_rescore:
		print pkg.rescoreBuilds(archs, options.priority)

	print ''