mirror of
https://git.launchpad.net/ubuntu-dev-tools
synced 2025-05-06 22:41:35 +00:00
010af53d7c
This results in a major refactor of the code to use launchpadlib directly instead of the ubuntutools.lp.lpapicache module in ubuntu-dev-tools which is idiosyncratic and does not expose the full launchpad API. Easier to rewrite to use the standard library.
432 lines
15 KiB
Python
Executable File
432 lines
15 KiB
Python
Executable File
#!/usr/bin/python3
|
|
#
|
|
# ubuntu-build - command line interface for Launchpad buildd operations.
|
|
#
|
|
# Copyright (C) 2007-2024 Canonical Ltd.
|
|
# Authors:
|
|
# - Martin Pitt <martin.pitt@canonical.com>
|
|
# - Jonathan Davies <jpds@ubuntu.com>
|
|
# - Michael Bienia <geser@ubuntu.com>
|
|
# - Steve Langasek <steve.langasek@canonical.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, version 3 of the License.
|
|
#
|
|
# 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/>.
|
|
#
|
|
|
|
# pylint: disable=invalid-name
|
|
# pylint: enable=invalid-name
|
|
|
|
import argparse
|
|
import sys
|
|
|
|
from launchpadlib.credentials import TokenAuthorizationException
|
|
from launchpadlib.launchpad import Launchpad
|
|
import lazr.restfulclient.errors
|
|
|
|
from ubuntutools import getLogger
|
|
from ubuntutools.lp.udtexceptions import PocketDoesNotExistError
|
|
from ubuntutools.misc import split_release_pocket
|
|
|
|
Logger = getLogger()
|
|
|
|
|
|
def getBuildStates(pkg, archs):
|
|
res = []
|
|
|
|
for build in pkg.getBuilds():
|
|
if build.arch_tag in archs:
|
|
res.append(f" {build.arch_tag}: {build.buildstate}")
|
|
msg = "\n".join(res)
|
|
return f"Build state(s) for '{pkg.source_package_name}':\n{msg}"
|
|
|
|
def rescoreBuilds(pkg, archs, score):
|
|
res = []
|
|
|
|
for build in pkg.getBuilds():
|
|
arch = build.arch_tag
|
|
if arch in archs:
|
|
if build.rescore(score):
|
|
res.append(f" {arch}: done")
|
|
else:
|
|
res.append(f" {arch}: failed")
|
|
msg = "\n".join(res)
|
|
return f"Rescoring builds of '{pkg.source_package_name}' to {score}:\n{msg}"
|
|
|
|
def retryBuilds(pkg, archs):
|
|
res = []
|
|
for build in pkg.getBuilds():
|
|
arch = build.arch_tag
|
|
if arch in archs:
|
|
try:
|
|
build.retry()
|
|
res.append(f" {arch}: done")
|
|
except lazr.restfulclient.errors.BadRequest:
|
|
res.append(f" {arch}: failed")
|
|
msg = "\n".join(res)
|
|
return f"Retrying builds of '{pkg.source_package_name}':\n{msg}"
|
|
|
|
|
|
def main():
|
|
# Usage.
|
|
usage = "%(prog)s <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(
|
|
[
|
|
"armhf",
|
|
"arm64",
|
|
"amd64",
|
|
"i386",
|
|
"powerpc",
|
|
"ppc64el",
|
|
"riscv64",
|
|
"s390x",
|
|
]
|
|
)
|
|
|
|
# Prepare our option parser.
|
|
parser = argparse.ArgumentParser(usage=usage)
|
|
|
|
parser.add_argument(
|
|
"-a",
|
|
"--arch",
|
|
action="append",
|
|
dest="architecture",
|
|
help=f"Rebuild or rescore a specific architecture. Valid architectures "
|
|
f"include: {', '.join(valid_archs)}.",
|
|
)
|
|
|
|
parser.add_argument("-A", "--archive", help="operate on ARCHIVE",
|
|
default="ubuntu")
|
|
|
|
# Batch processing options
|
|
batch_options = parser.add_argument_group(
|
|
"Batch processing",
|
|
"These options and parameter ordering is only "
|
|
"available in --batch mode.\nUsage: "
|
|
"ubuntu-build --batch [options] <package>...",
|
|
)
|
|
batch_options.add_argument(
|
|
"--batch", action="store_true", dest="batch", help="Enable batch mode"
|
|
)
|
|
batch_options.add_argument(
|
|
"--series",
|
|
action="store",
|
|
dest="series",
|
|
help="Selects the Ubuntu series to operate on (default: current development series)",
|
|
)
|
|
batch_options.add_argument(
|
|
"--retry", action="store_true", dest="retry", help="Retry builds (give-back)."
|
|
)
|
|
batch_options.add_argument(
|
|
"--rescore",
|
|
action="store",
|
|
dest="priority",
|
|
type=int,
|
|
help="Rescore builds to <priority>.",
|
|
)
|
|
batch_options.add_argument(
|
|
"--state", action="store", dest="state",
|
|
help="Act on builds that are in the specified state",
|
|
)
|
|
|
|
parser.add_argument("packages", metavar="package", nargs="*", help=argparse.SUPPRESS)
|
|
|
|
# Parse our options.
|
|
args = parser.parse_args()
|
|
|
|
launchpad = Launchpad.login_with("ubuntu-dev-tools", "production",
|
|
version="devel")
|
|
me = launchpad.me
|
|
|
|
is_buildd_admin = any(t.name == "launchpad-buildd-admins" \
|
|
for t in me.super_teams)
|
|
|
|
ubuntu = launchpad.distributions['ubuntu']
|
|
|
|
if args.batch:
|
|
release = args.series
|
|
if not release:
|
|
release = ubuntu.getDevelopmentSeries().name + "-proposed"
|
|
try:
|
|
(release, pocket) = split_release_pocket(release)
|
|
except PocketDoesNotExistError as error:
|
|
Logger.error(error)
|
|
sys.exit(1)
|
|
else:
|
|
# Check we have the correct number of arguments.
|
|
if len(args.packages) < 3:
|
|
parser.error("Incorrect number of arguments.")
|
|
|
|
try:
|
|
package = str(args.packages[0]).lower()
|
|
release = str(args.packages[1]).lower()
|
|
operation = str(args.packages[2]).lower()
|
|
except IndexError:
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
archive = launchpad.archives.getByReference(reference=args.archive)
|
|
try:
|
|
distroseries = ubuntu.getSeries(name_or_version=release)
|
|
except lazr.restfulclient.errors.NotFound as error:
|
|
Logger.error(error)
|
|
sys.exit(1)
|
|
|
|
if not args.batch:
|
|
# Check our operation.
|
|
if operation not in ("rescore", "retry", "status"):
|
|
Logger.error("Invalid operation: %s.", operation)
|
|
sys.exit(1)
|
|
|
|
# If the user has specified an architecture to build, we only wish to
|
|
# rebuild it and nothing else.
|
|
if args.architecture:
|
|
if args.architecture[0] not in valid_archs:
|
|
Logger.error("Invalid architecture specified: %s.", args.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 list of published sources for package in question.
|
|
try:
|
|
sources = archive.getPublishedSources(
|
|
distro_series=distroseries,
|
|
pocket=pocket,
|
|
source_name=package,
|
|
status='Published')[0]
|
|
except IndexError as error:
|
|
Logger.error("No publication found for package %s", package)
|
|
sys.exit(1)
|
|
# Get list of builds for that package.
|
|
builds = sources.getBuilds()
|
|
|
|
# Find out the version and component in given release.
|
|
version = sources.source_package_version
|
|
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 operation == "rescore":
|
|
necessary_privs = is_buildd_admin
|
|
if operation == "retry":
|
|
necessary_privs = archive.checkUpload(
|
|
component=sources.getComponent(),
|
|
distroseries=distroseries,
|
|
person=launchpad.me,
|
|
pocket=pocket,
|
|
sourcepackagename=sources.getPackageName(),
|
|
)
|
|
|
|
if operation 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.",
|
|
operation,
|
|
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 != args.architecture[0]:
|
|
# Skip this architecture.
|
|
continue
|
|
|
|
done = True
|
|
Logger.info("%s: %s.", build.arch_tag, build.buildstate)
|
|
if operation == "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 operation == "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 args.architecture:
|
|
# no specific architectures specified, assume all valid ones
|
|
archs = valid_archs
|
|
else:
|
|
archs = set(args.architecture)
|
|
|
|
# filter out duplicate and invalid architectures
|
|
archs.intersection_update(valid_archs)
|
|
|
|
# Check permisions (part 1): Rescoring can only be done by buildd admins
|
|
can_rescore = args.priority and is_buildd_admin
|
|
if args.priority and not can_rescore:
|
|
Logger.error(
|
|
"You don't have the permissions to rescore builds. Ignoring your rescore request."
|
|
)
|
|
|
|
if not args.packages:
|
|
retry_count = 0
|
|
|
|
if not args.state:
|
|
if args.retry:
|
|
args.state='Failed to build'
|
|
elif args.priority:
|
|
args.state='Needs building'
|
|
# there is no equivalent to series.getBuildRecords() for a ppa.
|
|
# however, we don't want to have to traverse all build records for
|
|
# all series when working on the main archive, so we use
|
|
# series.getBuildRecords() for ubuntu and handle ppas separately
|
|
series = ubuntu.getSeries(name_or_version=release)
|
|
if args.archive == 'ubuntu':
|
|
builds = series.getBuildRecords(build_state=args.state,
|
|
pocket=pocket)
|
|
else:
|
|
builds = []
|
|
for build in archive.getBuildRecords(build_state=args.state,
|
|
pocket=pocket):
|
|
if not build.current_source_publication:
|
|
continue
|
|
if build.current_source_publication.distro_series==series:
|
|
builds.append(build)
|
|
for build in builds:
|
|
if build.arch_tag not in archs:
|
|
continue
|
|
if not build.current_source_publication:
|
|
continue
|
|
# fixme: refactor
|
|
# Check permissions (part 2): check upload permissions for the
|
|
# source package
|
|
can_retry = args.retry and archive.checkUpload(
|
|
component=build.current_source_publication.component_name,
|
|
distroseries=series,
|
|
person=launchpad.me,
|
|
pocket=pocket,
|
|
sourcepackagename=build.source_package_name,
|
|
)
|
|
if args.retry and not can_retry:
|
|
Logger.error(
|
|
"You don't have the permissions to retry the "
|
|
"build of '%s', skipping.",
|
|
build.source_package_name
|
|
)
|
|
continue
|
|
Logger.info(
|
|
"The source version for '%s' in '%s' (%s) is: %s",
|
|
build.source_package_name,
|
|
release,
|
|
pocket,
|
|
build.source_package_version
|
|
)
|
|
|
|
if args.retry:
|
|
Logger.info("Retrying build of %s on %s...",
|
|
build.source_package_name, build.arch_tag)
|
|
retry_count += 1
|
|
build.retry()
|
|
|
|
if args.priority and can_rescore:
|
|
if build.can_be_rescored:
|
|
build.rescore(score=args.priority)
|
|
else:
|
|
Logger.info("Cannot rescore build of %s on %s.",
|
|
build.source_package_name, build.arch_tag)
|
|
|
|
Logger.info("")
|
|
if args.retry:
|
|
Logger.info("%d package builds retried", retry_count)
|
|
sys.exit(0)
|
|
|
|
|
|
for pkg in args.packages:
|
|
try:
|
|
pkg = archive.getPublishedSources(
|
|
distro_series=distroseries,
|
|
pocket=pocket,
|
|
source_name=pkg,
|
|
status='Published')[0]
|
|
except IndexError as error:
|
|
Logger.error("No publication found for package %s", pkg)
|
|
continue
|
|
|
|
# Check permissions (part 2): check upload permissions for the source
|
|
# package
|
|
can_retry = args.retry and archive.checkUpload(
|
|
component=pkg.component_name,
|
|
distroseries=distroseries,
|
|
person=launchpad.me,
|
|
pocket=pocket,
|
|
sourcepackagename=pkg.source_package_name,
|
|
)
|
|
if args.retry and not can_retry:
|
|
Logger.error(
|
|
"You don't have the permissions to retry the "
|
|
"build of '%s'. Ignoring your request.",
|
|
pkg.source_package_name,
|
|
)
|
|
|
|
Logger.info(
|
|
"The source version for '%s' in '%s' (%s) is: %s",
|
|
pkg.source_package_name,
|
|
release,
|
|
pocket,
|
|
pkg.source_package_version,
|
|
)
|
|
|
|
Logger.info(getBuildStates(pkg, archs))
|
|
if can_retry:
|
|
Logger.info(retryBuilds(pkg, archs))
|
|
if args.priority and can_rescore:
|
|
Logger.info(rescoreBuilds(pkg, archs, args.priority))
|
|
|
|
Logger.info("")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|