ubuntu-dev-tools/ubuntu-build

#!/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, Launchpad, PersonTeam
from launchpadlib.credentials import TokenAuthorizationException
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)

        try:
            # Will fail here if we have no credentials, bail out
            Launchpad.login()
        except TokenAuthorizationException:
            sys.exit(1)

        # Get the ubuntu archive
        ubuntu_archive = Distribution("ubuntu").getArchive()
        # 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()