#!/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 split_release_pocket
def main():
# 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", "armhf", "arm64", "amd64", "hppa", "i386", "ia64",
"lpia", "powerpc", "ppc64el", "s390x", "sparc"])
# Prepare our option parser.
opt_parser = OptionParser(usage)
# Retry options
retry_rescore_options = OptionGroup(opt_parser, "Retry and rescore options",
"These options may only be used with "
"the 'retry' and 'rescore' operations.")
retry_rescore_options.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(opt_parser, "Batch processing",
"These options and parameter ordering is only "
"available in --batch mode.\nUsage: "
"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.
opt_parser.add_option_group(retry_rescore_options)
# Add the batch mode to the main group.
opt_parser.add_option_group(batch_options)
# Parse our options.
(options, args) = opt_parser.parse_args()
if not len(args):
opt_parser.print_help()
sys.exit(1)
if not options.batch:
# Check we have the correct number of arguments.
if len(args) < 3:
opt_parser.error("Incorrect number of arguments.")
try:
package = str(args[0]).lower()
release = str(args[1]).lower()
op = str(args[2]).lower()
except IndexError:
opt_parser.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:
one_arch = True
else:
one_arch = False
# split release and pocket
try:
(release, pocket) = split_release_pocket(release)
except PocketDoesNotExistError, error:
print 'E: %s' % error
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), error:
print error
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":
necessary_privs = me.isLpTeamMember('launchpad-buildd-admins')
if op == "retry":
necessary_privs = me.canUploadPackage(ubuntu_archive, distroseries,
sources.getPackageName(),
sources.getComponent())
if op in ('rescore', 'retry') and not necessary_privs:
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 one_arch 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
if not release:
release = (Distribution('ubuntu').getDevelopmentSeries().name
+ '-proposed')
try:
(release, pocket) = split_release_pocket(release)
except PocketDoesNotExistError, error:
print 'E: %s' % error
sys.exit(1)
ubuntu_archive = Distribution('ubuntu').getArchive()
try:
distroseries = Distribution('ubuntu').getSeries(release)
except SeriesNotFoundException, error:
print error
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, error:
print error
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 ''
if __name__ == '__main__':
main()