mirror of
https://git.launchpad.net/ubuntu-dev-tools
synced 2025-03-12 15:41:09 +00:00
0eeb93ee0c
Python logging by default sends all output to stderr, but that's not what normal programs usually do and is not expected for these scripts. Change the ubuntutools.getLogger() method to return a logger with handlers correctly set up to send INFO level (or lower) logs to stdout and WARNING level (or higher; technically INFO+1 level or higher) logs to stderr. This results in normally logged output going to stdout and warnings/errors going to stderr, as expected.
283 lines
11 KiB
Python
Executable File
283 lines
11 KiB
Python
Executable File
#!/usr/bin/python3
|
|
#
|
|
# 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
|
|
|
|
from ubuntutools import getLogger
|
|
Logger = getLogger()
|
|
|
|
|
|
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", "riscv64", "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"):
|
|
Logger.error("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:
|
|
Logger.error("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 as error:
|
|
Logger.error(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) as error:
|
|
Logger.error(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(),
|
|
pocket=pocket)
|
|
|
|
if op in ('rescore', 'retry') and not necessary_privs:
|
|
Logger.error("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.
|
|
Logger.info("The source version for '%s' in %s (%s) is at %s." %
|
|
(package, release.capitalize(), component, version))
|
|
|
|
Logger.info("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
|
|
Logger.info("%s: %s." % (build.arch_tag, build.buildstate))
|
|
if op == 'rescore':
|
|
if build.can_be_rescored:
|
|
# FIXME: make priority an option
|
|
priority = 5000
|
|
Logger.info('Rescoring build %s to %d...' % (build.arch_tag, priority))
|
|
build.rescore(score=priority)
|
|
else:
|
|
Logger.info('Cannot rescore build on %s.' % build.arch_tag)
|
|
if op == 'retry':
|
|
if build.can_be_retried:
|
|
Logger.info('Retrying build on %s...' % build.arch_tag)
|
|
build.retry()
|
|
else:
|
|
Logger.info('Cannot retry build on %s.' % build.arch_tag)
|
|
|
|
# We are done
|
|
if done:
|
|
sys.exit(0)
|
|
|
|
Logger.info("No builds for '%s' found in the %s release" % (package, release.capitalize()))
|
|
Logger.info("It may have been built in a former release.")
|
|
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 as error:
|
|
Logger.error(error)
|
|
sys.exit(1)
|
|
|
|
ubuntu_archive = Distribution('ubuntu').getArchive()
|
|
try:
|
|
distroseries = Distribution('ubuntu').getSeries(release)
|
|
except SeriesNotFoundException as error:
|
|
Logger.error(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:
|
|
Logger.error("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 as error:
|
|
Logger.error(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:
|
|
Logger.error("You don't have the permissions to retry the "
|
|
"build of '%s'. Ignoring your request."
|
|
% pkg.getPackageName())
|
|
|
|
Logger.info("The source version for '%s' in '%s' (%s) is: %s" %
|
|
(pkg.getPackageName(), release, pocket, pkg.getVersion()))
|
|
|
|
Logger.info(pkg.getBuildStates(archs))
|
|
if can_retry:
|
|
Logger.info(pkg.retryBuilds(archs))
|
|
if options.priority and can_rescore:
|
|
Logger.info(pkg.rescoreBuilds(archs, options.priority))
|
|
|
|
Logger.info('')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|